along/secondo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
dfd1e745480fabd88139d2804acb90d5b6dc055e
secondo/Algebras/SymbolicTrajectory/Algorithms.cpp
along dfd1e74548 firs commit
2026-01-23 17:03:45 +08:00

5483 lines
168 KiB
C++
Raw Blame History

/*
----
This file is part of SECONDO.
Copyright (C) 2004, University in Hagen, Department of 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
----
//paragraph [1] Title: [{\Large \bf \begin {center}] [\end {center}}]
//[TOC] [\tableofcontents]
Started March 2012, Fabio Vald\'{e}s
[TOC]
\section{Overview}
This is the implementation of the Symbolic Trajectory Algebra.
\section{Defines and Includes}
*/
#include "Algorithms.h"
using namespace temporalalgebra;
using namespace std;
namespace stj{
/*
\subsection{Function ~GetText~}
Returns the pattern text as specified by the user.
*/
string Pattern::GetText() const {
return text.substr(0, text.length() - 1);
}
/*
\subsection{Function ~isValid~}
Decides whether the pattern is suitable for the type M.
*/
bool Pattern::isValid(const string& type) const {
for (int i = 0; i < getSize(); i++) {
if (type.length() < 6) {
return false;
}
}
for (unsigned int i = 0; i < conds.size(); i++) {
for (int j = 0; j < conds[i].getVarKeysSize(); j++) {
switch (conds[i].getKey(j)) {
case 0: { // label
if (type != MLabel::BasicType()) {
return false;
}
break;
}
case 1: { // place
if (type != MPlace::BasicType()) {
return false;
}
break;
}
case 8: { // labels
if (type.substr(1, 5) != Label::BasicType()) {
return false;
}
break;
}
case 9: { // places
if (type.substr(1, 5) != Place::BasicType()) {
return false;
}
break;
}
default: {}
}
}
}
for (unsigned int i = 0; i < assigns.size(); i++) {
if ((!assigns[i].getText(0).empty() && (type != MLabel::BasicType())) ||
(!assigns[i].getText(1).empty() && (type != MPlace::BasicType())) ||
(!assigns[i].getText(8).empty() && (type != MLabels::BasicType())) ||
(!assigns[i].getText(9).empty() && (type != MPlaces::BasicType()))) {
return false;
}
}
return true;
}
/*
\subsection{Function ~isCompatible~}
Checks whether an extended pattern is compatible to a certain tuple type. The
attribute number refers to the master attribute, whose type has to be a symbolic
trajectory.
For indextmatches2, majorAttrNo and majorValueNo are irrelevant.
*/
bool Pattern::isCompatible(TupleType *ttype, const int majorAttrNo,
vector<pair<int, string> >& relevantAttrs, int& majorValueNo) {
relevantAttrs = Tools::getRelevantAttrs(ttype, majorAttrNo, majorValueNo);
// cout << "attrs: ";
// for (unsigned int i = 0; i < relevantAttrs.size(); i++) {
// cout << "(" << relevantAttrs[i].first << ": " << relevantAttrs[i].second
// << ") ";
// }
// cout << endl;
vector<pair<Word, SetRel> > values;
for (int i = 0; i < getSize(); i++) {
values = elems[i].getValues();
if (values.size() > 0) { // atom has values
if (values.size() != relevantAttrs.size()) {
cout << "wrong number of values (" << values.size() << " instead of "
<< relevantAttrs.size() << ") in atom " << i << endl;
return false;
}
for (unsigned int j = 0; j < values.size(); j++) {
if (!Tools::checkAttrType(relevantAttrs[j].second, values[j].first)) {
cout << "wrong type (atom " << i << ", specification " << j << ")"
<< endl;
return false;
}
}
}
}
return true;
}
/*
\subsection{Function ~getPattern~}
Calls the parser.
*/
Pattern* Pattern::getPattern(string input, bool classify, Tuple *tuple /* =0 */,
ListExpr ttype /* = 0 */) {
if (input.find('\n') == string::npos) {
input.append("\n");
}
const char *patternChar = input.c_str();
return parseString(patternChar, classify, tuple, ttype);
}
bool Pattern::containsFinalState(set<int> &states) {
set<int> result;
set_intersection(states.begin(), states.end(), finalStates.begin(),
finalStates.end(), std::inserter(result, result.begin()));
return !result.empty();
}
bool Pattern::parseNFA() {
IntNfa* intNfa = 0;
if (parsePatternRegEx(regEx.c_str(), &intNfa) != 0) {
return false;
}
intNfa->nfa.makeDeterministic();
intNfa->nfa.minimize();
intNfa->nfa.bringStartStateToTop();
map<int, set<int> >::iterator it;
for (unsigned int i = 0; i < intNfa->nfa.numOfStates(); i++) {
map<int, set<int> > transitions = intNfa->nfa.getState(i).getTransitions();
map<int, int> newTrans;
for (it = transitions.begin(); it != transitions.end(); it++) {
newTrans[it->first] = *(it->second.begin());
}
nfa.push_back(newTrans);
if (intNfa->nfa.isFinalState(i)) {
finalStates.insert(i);
}
}
// printNfa(nfa, finalStates);
delete intNfa;
return true;
}
/*
\subsection{Function ~simplifyNFA~}
*/
void Pattern::simplifyNFA(vector<map<int, int> >& result) {
result.clear();
string ptext = GetText().substr(0, GetText().find("=>"));
ptext = ptext.substr(0, ptext.find("//")); //remove assignments and conditions
for (unsigned int i = 1; i < ptext.length(); i++) {
if ((ptext[i - 1] == ']') && ((ptext[i] == '*') || (ptext[i] == '+'))) {
ptext[i] = ' '; // eliminate repetition of regular expressions
}
}
Pattern *pnew = Pattern::getPattern(ptext, false);
vector<map<int, int> > oldNFA;
pnew->getNFA(oldNFA);
delete pnew;
result.resize(oldNFA.size());
map<int, int>::iterator im;
for (int i = 0; i < (int)oldNFA.size(); i++) {
for (im = oldNFA[i].begin(); im != oldNFA[i].end(); im++) {
if (im->second != i) { // eliminate * and + loops
result[i][im->first] = im->second;
}
}
}
// TODO: do it more elegantly!
set<int> foundFinalStates;
int maxState = 0;
for (unsigned int i = 0; i < result.size(); i++) {
for (im = result[i].begin(); im != result[i].end(); im++) {
if (finalStates.find(im->second) != finalStates.end()) {
foundFinalStates.insert(im->second);
}
if (im->second > maxState) {
maxState = im->second;
}
}
}
if (finalStates != foundFinalStates) {
finalStates.clear();
finalStates.insert(maxState);
// cout << "final state is now " << maxState << endl;
}
// Tools::printNfa(result, finalStates);
}
/*
\subsection{Function ~findNFApaths~}
*/
void Pattern::findNFApaths(vector<map<int, int> >& simpleNFA,
set<pair<set<int>, int> >& result) {
result.clear();
set<pair<set<int>, int> > newPaths;
set<int> elems;
set<pair<set<int>, int> >::iterator is;
map<int, int>::iterator im;
result.insert(make_pair(elems, 0));
bool proceed = true;
while (proceed) {
for (is = result.begin(); is != result.end(); is++) {
map<int, int> trans = simpleNFA[is->second];
for (im = trans.begin(); im != trans.end(); im++) {
elems = is->first; // get old transition set
elems.insert(im->first); // add new transition
newPaths.insert(make_pair(elems, im->second)); // and new state
}
if (simpleNFA[is->second].empty()) { // no transition available
newPaths.insert(*is); // keep path
}
}
result = newPaths;
newPaths.clear();
proceed = false;
for (is = result.begin(); is != result.end(); is++) {
if (finalStates.find(is->second) == finalStates.end()) { // no final state
proceed = true; // continue pathfinding
}
}
}
}
/*
\subsection{Function ~getCrucialElems~}
*/
void Pattern::getCrucialElems(const set<pair<set<int>, int> >& paths,
set<int>& result) {
set<int> elems, temp;
set<pair<set<int>, int> >::iterator is;
set<int>::iterator it;
is = paths.begin();
elems = is->first;
is++;
while (is != paths.end()) { // collect crucial elems
// cout << "{";
// for (it = is->first.begin(); it != is->first.end(); it++) {
// cout << *it << " ";
// }
// cout << "} {";
// for (it = elems.begin(); it != elems.end(); it++) {
// cout << *it << " ";
// }
// cout << "}";
set_intersection(is->first.begin(), is->first.end(), elems.begin(),
elems.end(), std::inserter(temp, temp.begin()));
// cout << " --> {";
// for (it = temp.begin(); it != temp.end(); it++) {
// cout << *it << " ";
// }
// cout << "}" << endl;
elems = temp;
temp.clear();
is++;
}
// cout << "crucial elements: {";
for (it = elems.begin(); it != elems.end(); it++) {
// cout << *it << " ";
result.insert(*it);
}
// cout << "}" << endl;
}
/*
\subsection{Function ~tmatches~}
Computes whether a tuple with several trajectories of different types matches
the pattern.
*/
ExtBool Pattern::tmatches(Tuple *tuple, const int attrno, ListExpr ttype) {
ExtBool result = ST_UNDEF;
vector<pair<int, string> > relevantAttrs;
int majorValueNo = -1;
if (isCompatible(tuple->GetTupleType(), attrno, relevantAttrs, majorValueNo)){
if (initEasyCondOpTrees(true, tuple, ttype) && !isNFAempty()) {
TMatch tmatch(this, tuple, ttype, attrno, relevantAttrs, majorValueNo);
result = tmatch.matches();
}
}
deleteAtomValues(relevantAttrs);
return result;
}
/*
function ~getConstValue~
Extracts a constant value from a moving attribute at a certain instant, e.g.,
for an mpoint attribute, the function yields a point result.
*/
template<class Moving, class Intime, class Constant>
void Condition::getConstValue(Attribute *src, const Instant& inst,
Attribute*& result) {
if (src != 0) {
Intime it(true);
((Moving*)src)->AtInstant(inst, it);
result->CopyFrom((Constant*)&(it.value));
}
else {
result = new Constant(true);
}
}
void Condition::getConstValue(Attribute *src, const std::string& type,
const Instant& inst, Attribute*& result) {
if (type == "mlabel") {
getConstValue<MLabel, ILabel, Label>(src, inst, result);
}
else if (type == "mlabels") {
getConstValue<MLabels, ILabels, Labels>(src, inst, result);
}
else if (type == "mplace") {
getConstValue<MPlace, IPlace, Place>(src, inst, result);
}
else if (type == "mplaces") {
getConstValue<MPlaces, IPlaces, Places>(src, inst, result);
}
else if (type == "mbool") {
getConstValue<MBool, IBool, CcBool>(src, inst, result);
}
else if (type == "mint") {
getConstValue<MInt, IInt, CcInt>(src, inst, result);
}
else if (type == "mreal") {
getConstValue<MReal, IReal, CcReal>(src, inst, result);
}
else if (type == "mpoint") {
getConstValue<MPoint, IPoint, Point>(src, inst, result);
}
else if (type == "mregion") {
getConstValue<MRegion, IRegion, Region>(src, inst, result);
}
else {
cout << "INVALID type " << type << endl;
result = 0;
}
}
string Condition::getType(const int t, const string& var,
Tuple *tuple /* = 0 */, ListExpr ttype /* = 0 */) {
if (t > 99) {
if (tuple && ttype) {
if (var.empty()) {
return nl->ToString(nl->First(nl->Nth(t - 99, nl->Second(ttype))));
}
return "." + nl->ToString(nl->First(nl->Nth(t - 99, nl->Second(ttype))));
}
else {
return ".ERROR";
}
}
switch (t) {
case 0: return ".label";
case 1: return ".place";
case 2: return ".time";
case 3: return ".start";
case 4: return ".end";
case 5: return ".leftclosed";
case 6: return ".rightclosed";
case 7: return ".card";
case 8: return ".labels";
case 9: return ".places";
default: return ".ERROR";
}
}
string Condition::toString() const {
stringstream result;
result << text << endl;
for (unsigned int j = 0; j < varKeys.size(); j++) {
result << j << ": " << varKeys[j].first << "." << varKeys[j].second << endl;
}
return result.str();
}
void Condition::setValuePtr(unsigned int pos, string& value) {
if (pos < pointers.size()) {
((Label*)pointers[pos])->Set(true, value);
}
}
void Condition::setValuePtr(unsigned int pos, pair<string,unsigned int>& value){
if (pos < pointers.size()) {
((Place*)pointers[pos])->Set(true, value);
}
}
void Condition::clearTimePtr(unsigned int pos) {
if (pos < pointers.size()) {
if (((Periods*)pointers[pos])->IsDefined()) {
((Periods*)pointers[pos])->Clear();
}
}
}
void Condition::mergeAddTimePtr(unsigned int pos, Interval<Instant>& value) {
if (pos < pointers.size()) {
((Periods*)pointers[pos])->MergeAdd(value);
}
}
void Condition::setTimePtr(unsigned int pos, const Periods& per) {
if (pos < pointers.size()) {
((Periods*)pointers[pos])->CopyFrom(&per);
}
}
void Condition::setStartEndPtr(unsigned int pos, Instant& value) {
if (pos < pointers.size()) {
*((Instant*)pointers[pos]) = value;
}
}
void Condition::setCardPtr(unsigned int pos, int value) {
if (pos < pointers.size()) {
((CcInt*)pointers[pos])->Set(true, value);
}
}
void Condition::cleanLabelsPtr(unsigned int pos) {
if (pos < pointers.size()) {
((Labels*)pointers[pos])->Clean();
}
}
void Condition::appendToLabelsPtr(unsigned int pos, string& value) {
if (pos < pointers.size()) {
((Labels*)pointers[pos])->Append(value);
}
}
void Condition::appendToLabelsPtr(unsigned int pos, set<string>& values) {
if (pos < pointers.size()) {
((Labels*)pointers[pos])->Append(values);
}
}
void Condition::cleanPlacesPtr(unsigned int pos) {
if (pos < pointers.size()) {
((Places*)pointers[pos])->Clean();
}
}
void Condition::appendToPlacesPtr(unsigned int pos,
pair<string, unsigned int>& value) {
if (pos < pointers.size()) {
((Places*)pointers[pos])->Append(value);
}
}
void Condition::appendToPlacesPtr(unsigned int pos,
set<pair<string, unsigned int> >& values) {
if (pos < pointers.size()) {
((Places*)pointers[pos])->Append(values);
}
}
void Condition::setLeftRightclosedPtr(unsigned int pos, bool value) {
if (pos < pointers.size()) {
((CcBool*)pointers[pos])->Set(true, value);
}
}
/*
\subsection{Function ~getPointer~}
Static function invoked by ~initCondOpTrees~ or ~initAssignOpTrees~
*/
pair<string, Attribute*> Pattern::getPointer(const int key,
const bool isInterval /* = true */, Tuple *tuple /* = 0 */) {
pair<string, Attribute*> result;
if (key > 99) { // attribute name
SecondoCatalog* sc = SecondoSystem::GetCatalog();
AttributeType attrType = tuple->GetTupleType()->GetAttributeType(key - 100);
string type = sc->GetTypeName(attrType.algId, attrType.typeId);
// cout << "TYPE is " << type << endl;
if (isInterval) {
if (type == "mplace" || type == "mplaces") {
result.second = new Region(1);
result.first = "[const region pointer "
+ nl->ToString(listutils::getPtrList(result.second)) + "]";
}
else {
result.second = tuple->GetAttribute(key - 100)->Clone();
result.first = "[const " + type + " pointer "
+ nl->ToString(listutils::getPtrList(result.second)) + "]";
}
}
else {
if (Tools::isRelevantAttr(type)) { // moving attribute
Instant inst(datetime::instanttype);
Condition::getConstValue(0, type, inst, result.second);
type = type.substr(1);
}
else { // constant attribute type
result.second = tuple->GetAttribute(key - 100)->Clone();
}
result.first = "[const " + type + " pointer "
+ nl->ToString(listutils::getPtrList(result.second)) + "]";
// cout << result.first << endl;
}
}
else {
if (isInterval) {
switch (key) {
case 0: { // label, type Label
result.second = new Label(true);
result.first = "[const label pointer "
+ nl->ToString(listutils::getPtrList(result.second)) + "]";
break;
}
case 1: { // place, type Place
result.second = new Place(true);
result.first = "[const place pointer "
+ nl->ToString(listutils::getPtrList(result.second)) + "]";
break;
}
case 2: { // time, type Periods
result.second = new Periods(1);
result.first = "[const periods pointer "
+ nl->ToString(listutils::getPtrList(result.second)) + "]";
break;
}
case 3: // start, type Instant
case 4: { // end, type Instant
result.second = new datetime::DateTime(datetime::instanttype);
result.first = "[const instant pointer "
+ nl->ToString(listutils::getPtrList(result.second)) + "]";
break;
}
case 5: // leftclosed, type CcBool
case 6: { // rightclosed, type CcBool
result.second = new CcBool(false);
result.first = "[const bool pointer "
+ nl->ToString(listutils::getPtrList(result.second)) + "]";
break;
}
case 7: { // card, type CcInt
result.second = new CcInt(false);
result.first = "[const int pointer "
+ nl->ToString(listutils::getPtrList(result.second)) + "]";
break;
}
case 8: { // labels, type Labels
result.second = new Labels(true);
result.first = "[const labels pointer "
+ nl->ToString(listutils::getPtrList(result.second)) + "]";
break;
}
default: { // places, type Places
result.second = new Places(true);
result.first = "[const places pointer "
+ nl->ToString(listutils::getPtrList(result.second)) + "]";
}
}
}
else { // used for indextmatches2
if (key >= 2 && key <= 4) { // time, start, end: type instant
result.second = new datetime::DateTime(datetime::instanttype);
result.first = "[const instant pointer "
+ nl->ToString(listutils::getPtrList(result.second)) + "]";
}
}
}
return result;
}
/*
\subsection{Function ~initCondOpTrees~}
For a pattern with conditions, an operator tree structure is prepared.
*/
bool Pattern::initCondOpTrees(Tuple *tuple /* = 0 */, ListExpr ttype /* = 0 */,
const bool mainAttr) {
for (unsigned int i = 0; i < conds.size(); i++) { // opTrees for conditions
// if (!mainAttr) {
// conds[i].collectInstantVars(varToElem);
// }
if (!conds[i].initOpTree(tuple, ttype)) {
cout << "Operator tree for condition " << i << " uninitialized" << endl;
return false;
}
}
return true;
}
bool Condition::initOpTree(Tuple *tuple /* = 0 */, ListExpr ttype /* = 0 */) {
string q(""), part, toReplace("");
pair<string, Attribute*> strAttr;
vector<Attribute*> ptrs;
if (!isTreeOk()) {
q = "query " + text;
for (unsigned int i = 0; i < varKeys.size(); i++) { // init pointers
// cout << "|| " << varKeys[i].first << "|" << varKeys[i].second
// << "|" << endl;
// bool isInterval = instantVars.find(varKeys[i].first) == instantVars.end();
bool isInterval = true;
strAttr = Pattern::getPointer(getKey(i), isInterval, tuple);
ptrs.push_back(strAttr.second);
toReplace = getVar(i) + getType(getKey(i), getVar(i), tuple, ttype);
q.replace(q.find(toReplace), toReplace.length(), strAttr.first);
// cout << "init op tree for | " << q << endl;
}
pair<QueryProcessor*, OpTree> qp_optree = Tools::processQueryStr(q, -1);
if (!qp_optree.first) {
return false;
}
setOpTree(qp_optree);
setPointers(ptrs);
ptrs.clear();
setTreeOk(true);
}
return true;
}
/*
\subsection{Function ~initEasyCondOpTrees~}
For a pattern with conditions, an operator tree structure is prepared.
*/
bool Pattern::initEasyCondOpTrees(const bool mainAttr, Tuple *tuple /* = 0 */,
ListExpr ttype /* = 0 */) {
string q(""), part, toReplace("");
pair<string, Attribute*> strAttr;
vector<Attribute*> ptrs;
for (unsigned int i = 0; i < easyConds.size(); i++) {
if (!easyConds[i].isTreeOk()) {
q = "query " + easyConds[i].getText();
for (int j = 0; j < easyConds[i].getVarKeysSize(); j++) { // init pointers
// cout << "|" << easyConds[i].getVar(j) << "|" << easyConds[i].getKey(j)
// << "|" << varPos[easyConds[i].getVar(j)].first << " "
// << varPos[easyConds[i].getVar(j)].second << endl;
strAttr = getPointer(easyConds[i].getKey(j), true, tuple);
ptrs.push_back(strAttr.second);
string var = easyConds[i].getVar(j);
toReplace = var
+ Condition::getType(easyConds[i].getKey(j), var, tuple, ttype);
q.replace(q.find(toReplace), toReplace.length(), strAttr.first);
// cout << "# " << q << endl;
}
pair<QueryProcessor*, OpTree> qp_optree = Tools::processQueryStr(q, -1);
if (!qp_optree.first) {
cout << "Op tree for easy condition " << i << " uninitialized" << endl;
return false;
}
easyConds[i].setOpTree(qp_optree);
easyConds[i].setPointers(ptrs);
ptrs.clear();
easyConds[i].setTreeOk(true);
}
}
return true;
}
/*
\subsection{Function ~deleteCondOpTrees~}
Removes the corresponding structures.
*/
void Pattern::deleteCondOpTrees() {
for (unsigned int i = 0; i < conds.size(); i++) {
if (conds[i].isTreeOk()) {
conds[i].deleteOpTree();
}
}
}
/*
\subsection{Function ~deleteEasyCondOpTrees~}
Removes the corresponding structures.
*/
void Pattern::deleteEasyCondOpTrees() {
for (unsigned int i = 0; i < easyConds.size(); i++) {
if (easyConds[i].isTreeOk()) {
easyConds[i].deleteOpTree();
}
}
}
/*
\section{Functions for class ~TMatch~}
\subsection{Constructor}
*/
TMatch::TMatch(Pattern *pat, Tuple *tuple, ListExpr tt, const int _attrno,
vector<pair<int, string> >& _relevantAttrs, const int _valueno) {
p = pat;
t = tuple;
ttype = tt;
attrno = _attrno;
valueno = _valueno;
matching = 0;
type = Tools::getDataType(t->GetTupleType(), attrno);
relevantAttrs = _relevantAttrs;
}
/*
\subsection{Function ~matches~}
*/
ExtBool TMatch::matches() {
set<int> states;
states.insert(0); // initial state
int noMainComponents = GetNoMainComponents();
if (!p->hasConds() && !p->hasAssigns()) {
for (int i = 0; i < noMainComponents; i++) {
if (!performTransitions(i, states)) {
return ST_FALSE;
}
}
if (p->containsFinalState(states)) {
return ST_TRUE;
}
else {
return ST_FALSE;
}
}
pathMatrix = Tools::createSetMatrix(noMainComponents, p->elemToVar.size());
for (int i = 0; i < noMainComponents; i++) {
if (!performTransitionsWithMatrix(i, states)) {
Tools::deleteSetMatrix(pathMatrix, noMainComponents);
return ST_FALSE;
}
}
if (!p->containsFinalState(states)) {
Tools::deleteSetMatrix(pathMatrix, noMainComponents);
return ST_FALSE;
}
if (!p->initCondOpTrees(t, ttype)) {
Tools::deleteSetMatrix(pathMatrix, noMainComponents);
return ST_FALSE;
}
if (!p->hasAssigns()) {
bool result = findMatchingBinding(0);
Tools::deleteSetMatrix(pathMatrix, noMainComponents);
return (result ? ST_TRUE : ST_FALSE);
}
return ST_TRUE;
}
/*
\subsection{Function ~GetNoMainComponents~}
*/
int TMatch::GetNoMainComponents() const {
switch (type) {
case MLABEL: {
return ((MLabel*)t->GetAttribute(attrno))->GetNoComponents();
}
case MLABELS: {
return ((MLabels*)t->GetAttribute(attrno))->GetNoComponents();
}
case MPLACE: {
return ((MPlace*)t->GetAttribute(attrno))->GetNoComponents();
}
case MPLACES: {
return ((MPlaces*)t->GetAttribute(attrno))->GetNoComponents();
}
default: { // cannot occur
return -1;
}
}
}
/*
\subsection{Function ~GetInterval~}
*/
void TMatch::GetInterval(const int u, SecInterval& iv) const {
switch (type) {
case MLABEL: {
((MLabel*)t->GetAttribute(attrno))->GetInterval(u, iv);
return;
}
case MLABELS: {
((MLabels*)t->GetAttribute(attrno))->GetInterval(u, iv);
return;
}
case MPLACE: {
((MPlace*)t->GetAttribute(attrno))->GetInterval(u, iv);
return;
}
case MPLACES: {
((MPlaces*)t->GetAttribute(attrno))->GetInterval(u, iv);
return;
}
}
}
/*
\subsection{Function ~labelsMatch~}
*/
bool TMatch::labelsMatch(const set<string>& tlabels, const int atom,
const int pos) {
set<string> plabels;
pair<Word, SetRel> values = p->elems[atom].values[pos];
if (values.first.addr == 0) {
return true;
}
((Labels*)values.first.addr)->GetValues(plabels);
return Tools::relationHolds(tlabels, plabels, values.second);
}
/*
\subsection{Function ~placesMatch~}
*/
bool TMatch::placesMatch(const set<pair<string, unsigned int> >& tplaces,
const int atom, const int pos) {
set<string> pplaces;
pair<Word, SetRel> values = p->elems[atom].values[pos];
if (values.first.addr == 0) {
return true;
}
string type = p->elems[atom].types[pos];
if (type == Labels::BasicType()) {
if (((Labels*)values.first.addr)->IsDefined()) {
((Labels*)values.first.addr)->GetValues(pplaces);
return Tools::relationHolds(tplaces, pplaces, values.second);
}
else {
cout << "ERROR: type/value mismatch" << endl;
return false;
}
}
else if (type == Rectangle<2>::BasicType()) {
return true; // no further test required
}
else if (type == Region::BasicType()) {
Region reg(*((Region*)(values.first.addr)));
cout << "CHECK region ";
return Tools::relationHolds(tplaces, reg, values.second);
}
else {
cout << "ERROR: invalid type " << type << endl;
return false;
}
}
/*
\subsection{Function ~mainValuesMatch~}
*/
bool TMatch::mainValuesMatch(const int u, const int atom) {
switch (type) {
case MLABEL: {
if (u < 0 || u >= ((MLabel*)t->GetAttribute(attrno))->GetNoComponents()) {
return false;
}
set<string> labels;
string label;
((MLabel*)t->GetAttribute(attrno))->GetValue(u, label);
labels.insert(label);
return labelsMatch(labels, atom, valueno);
}
case MLABELS: {
if (u < 0 || u >= ((MLabels*)t->GetAttribute(attrno))->GetNoComponents()){
return false;
}
set<string> labels;
((MLabels*)t->GetAttribute(attrno))->GetValues(u, labels);
return labelsMatch(labels, atom, valueno);
}
case MPLACE: {
if (u < 0 || u >= ((MPlace*)t->GetAttribute(attrno))->GetNoComponents()) {
return false;
}
set<pair<string, unsigned int> > places;
pair<string, unsigned int> place;
((MPlace*)t->GetAttribute(attrno))->GetValue(u, place);
places.insert(place);
return placesMatch(places, atom, valueno);
}
case MPLACES: {
if (u < 0 || u >= ((MPlaces*)t->GetAttribute(attrno))->GetNoComponents()){
return false;
}
set<pair<string, unsigned int> > places;
((MPlaces*)t->GetAttribute(attrno))->GetValues(u, places);
return placesMatch(places, atom, valueno);
}
default: { // cannot occur
return false;
}
}
}
/*
\subsection{Function ~otherValuesMatch~}
*/
bool TMatch::otherValuesMatch(const int pos, const SecInterval& iv,
const int atom) {
pair<Word, SetRel> values = p->elems[atom].values[pos];
if (values.first.addr == 0) {
return true;
}
pair<int, string> attrInfo = relevantAttrs[pos];
if (attrInfo.first == attrno) {
return true;
}
int start(-1), end(-1);
if (attrInfo.second == "mlabel") {
MLabel *mlabel = (MLabel*)t->GetAttribute(attrInfo.first);
start = mlabel->Position(iv.start);
end = mlabel->Position(iv.end);
if (start == -1 || end == -1) {
return false;
}
temporalalgebra::SecInterval iv1, iv2;
mlabel->GetInterval(start, iv1);
mlabel->GetInterval(end, iv2);
if (!iv.lc && iv.start == iv1.end) {
start++;
}
if (!iv.rc && iv.end == iv2.start) {
end--;
}
set<string> tlabels, plabels, labels;
string label;
for (int i = start; i <= end; i++) {
mlabel->GetValue(i, label);
tlabels.insert(label);
}
((Labels*)values.first.addr)->GetValues(plabels);
return Tools::relationHolds(tlabels, plabels, values.second);
}
else if (attrInfo.second == "mlabels") {
MLabels *mlabels = (MLabels*)t->GetAttribute(attrInfo.first);
start = mlabels->Position(iv.start);
end = mlabels->Position(iv.end);
if (start == -1 || end == -1) {
return false;
}
set<string> tlabels, plabels, labels;
string label;
for (int i = start; i <= end; i++) {
mlabels->GetValues(i, labels);
tlabels.insert(labels.begin(), labels.end());
}
((Labels*)values.first.addr)->GetValues(plabels);
return Tools::relationHolds(tlabels, plabels, values.second);
}
else if (attrInfo.second == "mplace") {
// TODO.
}
else if (attrInfo.second == "mplaces") {
// TODO.
}
else if (attrInfo.second == "mpoint") {
MPoint *mpoint = (MPoint*)t->GetAttribute(attrInfo.first);
Periods per(true);
per.Add(iv);
MPoint mpAtPer(true);
mpoint->AtPeriods(per, mpAtPer);
if (mpAtPer.IsEmpty()) {
return false;
}
return Tools::relationHolds(mpAtPer, *((Region*)values.first.addr),
values.second);
}
else if (attrInfo.second == "mregion") {
MRegion *mreg = (MRegion*)t->GetAttribute(attrInfo.first);
Periods per(true);
per.Add(iv);
MRegion mrAtPer(true);
mreg->AtPeriods(&per, &mrAtPer);
if (mrAtPer.IsEmpty()) {
return false;
}
return Tools::relationHolds(mrAtPer, *((Region*)values.first.addr),
values.second);
}
else if (attrInfo.second == "mbool") {
MBool *mbool = (MBool*)t->GetAttribute(attrInfo.first);
start = mbool->Position(iv.start);
end = mbool->Position(iv.end);
if (start == -1 || end == -1) {
return false;
}
set<bool> boolSet;
UBool ub(true);
for (int i = start; i <= end; i++) {
mbool->Get(i, ub);
boolSet.insert(ub.constValue.GetValue());
}
return Tools::relationHolds(boolSet,
((CcBool*)values.first.addr)->GetValue(), values.second);
}
else if (attrInfo.second == "mint") {
Range<CcInt> trange(true), prange(true);
MInt *mint = (MInt*)t->GetAttribute(attrInfo.first);
UInt unit(true);
int firstpos(mint->Position(iv.start)), lastpos(mint->Position(iv.end));
if (firstpos >= 0 && lastpos >= firstpos &&
lastpos < mint->GetNoComponents()) {
set<int> intSet;
for (int i = firstpos; i <= lastpos; i++) {
mint->Get(i, unit);
intSet.insert(unit.constValue.GetValue());
}
return Tools::relationHolds(*((Range<CcReal>*)values.first.addr), intSet,
values.second);
}
return false;
}
else if (attrInfo.second == "mreal") {
Range<CcReal> trange(true);
MReal *mreal = (MReal*)t->GetAttribute(attrInfo.first);
UReal ureal(true), urealTemp(true);
int firstpos(mreal->Position(iv.start)), lastpos(mreal->Position(iv.end));
if (firstpos >= 0 && lastpos >= firstpos &&
lastpos < mreal->GetNoComponents()) {
bool correct = true;
CcReal ccmin(0.0, true), ccmax(0.0, true);
Interval<CcReal> minMax(ccmin, ccmax, true, true);
set<Interval<CcReal>, ivCmp> ivSet;
for (int i = firstpos; i <= lastpos; i++) {
mreal->Get(i, ureal);
minMax.start.Set(ureal.Min(correct));
minMax.end.Set(ureal.Max(correct));
ivSet.insert(minMax);
}
for (set<Interval<CcReal>, ivCmp>::iterator it = ivSet.begin();
it != ivSet.end(); it++) {
trange.MergeAdd(*it);
}
return Tools::relationHolds<CcReal>(trange,
*((Range<CcReal>*)values.first.addr), values.second);
}
return false;
}
else { // error
cout << "TYPE is " << attrInfo.second << endl;
return false;
}
return true;
}
/*
\subsection{Function ~valuesMatch~}
*/
bool TMatch::valuesMatch(const int u, const int atom, const bool checkMain) {
SecInterval iv(true);
if (checkMain) {
if (!mainValuesMatch(u, atom)) {
return false;
}
}
GetInterval(u, iv);
for (unsigned int pos = 0; pos < relevantAttrs.size(); pos++) {
if (!otherValuesMatch(pos, iv, atom)) {
return false;
}
}
return true;
}
/*
\subsection{Function ~easyCondsMatch~}
*/
bool TMatch::easyCondsMatch(const int u, const int atom) {
set<int> pos = p->getEasyCondPos(atom);
if (p->elems[atom].getW() || pos.empty() || p->easyConds.empty()) {
return true;
}
IndexMatchInfo imi(p->getElemFromAtom(atom), u);
std::map<std::string, int> vte = p->getVarToElem();
for (set<int>::iterator it = pos.begin(); it != pos.end(); it++) {
switch (type) {
case MLABEL: {
MLabel *traj = (MLabel*)t->GetAttribute(attrno);
if (!p->easyConds[*it].evaluate<MLabel>(imi, traj, vte, t, ttype)) {
return false;
}
break;
}
case MLABELS: {
MLabels *traj = (MLabels*)t->GetAttribute(attrno);
if (!p->easyConds[*it].evaluate<MLabels>(imi, traj, vte, t, ttype)) {
return false;
}
break;
}
case MPLACE: {
MPlace *traj = (MPlace*)t->GetAttribute(attrno);
if (!p->easyConds[*it].evaluate<MPlace>(imi, traj, vte, t, ttype)) {
return false;
}
break;
}
case MPLACES: {
MPlaces *traj = (MPlaces*)t->GetAttribute(attrno);
if (!p->easyConds[*it].evaluate<MPlaces>(imi, traj, vte, t, ttype)) {
return false;
}
break;
}
}
}
return true;
}
/*
\subsection{Function ~performTransitionsWithMatrix~}
*/
bool TMatch::performTransitionsWithMatrix(const int u, set<int>& states) {
map<int, int> transitions;
for (set<int>::iterator it = states.begin(); it != states.end(); it++) {
map<int, int> trans = p->nfa[*it]; // collect possible transitions
transitions.insert(trans.begin(), trans.end());
}
if (transitions.empty()) { // no possible transition available
return false;
}
states.clear();
map<int, int>::iterator it, itn;
set<unsigned int>::iterator itu;
if (u < GetNoMainComponents() - 1) { // usual case
for (it = transitions.begin(); it != transitions.end(); it++) {
if (p->elems[it->first].getW() != NO) {
states.insert(states.end(), it->second);
map<int, int> nextTrans = p->nfa[it->second];
for (itn = nextTrans.begin(); itn != nextTrans.end(); itn++) {
itu = pathMatrix[u][p->atomicToElem[it->first]].end();
pathMatrix[u][p->atomicToElem[it->first]].insert
(itu, p->atomicToElem[itn->first]);
}
}
else {
set<string> ivs;
SecInterval iv;
GetInterval(u, iv);
p->elems[it->first].getI(ivs);
if (Tools::timesMatch(iv, ivs) && valuesMatch(u, it->first, true)
&& easyCondsMatch(u, it->first)) {
states.insert(states.end(), it->second);
map<int, int> nextTrans = p->nfa[it->second];
for (itn = nextTrans.begin(); itn != nextTrans.end(); itn++) {
itu = pathMatrix[u][p->atomicToElem[it->first]].end();
pathMatrix[u][p->atomicToElem[it->first]].insert
(itu, p->atomicToElem[itn->first]);
}
}
}
}
}
else { // last row; mark final states with -1
for (it = transitions.begin(); it != transitions.end(); it++) {
if (p->elems[it->first].getW() != NO) {
states.insert(states.end(), it->second);
if (p->finalStates.count(it->second)) { // store last matching
pathMatrix[u][p->atomicToElem[it->first]].insert(UINT_MAX);
}
}
else {
set<string> ivs;
SecInterval iv;
GetInterval(u, iv);
p->elems[it->first].getI(ivs);
if (Tools::timesMatch(iv, ivs) && valuesMatch(u, it->first, true)
&& easyCondsMatch(u, it->first)) {
states.insert(states.end(), it->second);
if (p->finalStates.count(it->second)) { // store last matching
pathMatrix[u][p->atomicToElem[it->first]].insert(UINT_MAX);
}
}
}
}
}
return !states.empty();
}
/*
\subsection{Function ~performTransitions~}
*/
bool TMatch::performTransitions(const int u, set<int>& states) {
map<int, int> transitions;
for (set<int>::iterator it = states.begin(); it != states.end(); it++) {
map<int, int> trans = p->nfa[*it]; // collect possible transitions
transitions.insert(trans.begin(), trans.end());
}
if (transitions.empty()) { // no possible transition available
return false;
}
states.clear();
map<int, int>::iterator it;
for (it = transitions.begin(); it != transitions.end(); it++) {
if (p->elems[it->first].getW() != NO) {
states.insert(states.end(), it->second);
}
else {
set<string> ivs;
SecInterval iv;
GetInterval(u, iv);
p->elems[it->first].getI(ivs);
if (Tools::timesMatch(iv, ivs) && valuesMatch(u, it->first, true)
&& easyCondsMatch(u, it->first)) {
states.insert(states.end(), it->second);
}
}
}
return !states.empty();
}
/*
\subsection{Function ~conditionsMatch~}
*/
bool TMatch::conditionsMatch(const IndexMatchInfo &imi) {
Attribute *attr = t->GetAttribute(attrno);
std::map<std::string, int> varToElem = p->getVarToElem();
for (unsigned int i = 0; i < p->conds.size(); i++) {
switch (type) {
case MLABEL: {
if (!p->conds[i].evaluate(imi, (MLabel*)attr, varToElem, t, ttype)) {
// cout << "False cond " << p->conds[i].getText() << endl;
return false;
}
break;
}
case MLABELS: {
if (!p->conds[i].evaluate(imi, (MLabels*)attr, varToElem, t, ttype)) {
return false;
}
break;
}
case MPLACE: {
if (!p->conds[i].evaluate(imi, (MPlace*)attr, varToElem, t, ttype)) {
return false;
}
break;
}
case MPLACES: {
if (!p->conds[i].evaluate(imi, (MPlaces*)attr, varToElem, t, ttype)) {
return false;
}
break;
}
default: { // cannot occur
return false;
}
}
}
// cout << "True conditions!!!" << endl;
return true;
}
/*
\subsection{Function ~findBinding~}
Recursively finds all bindings in the matching set matrix and checks whether
they fulfill every condition, stopping immediately after the first success.
*/
bool TMatch::findBinding(const int u, const int elem, IndexMatchInfo& imi) {
bool inserted = imi.extendOrInsert(elem, u);
if (*(pathMatrix[u][elem].begin()) == UINT_MAX) { // complete match
if (conditionsMatch(imi)) {
return true;
}
}
else {
for (set<unsigned int>::reverse_iterator it = pathMatrix[u][elem].rbegin();
it != pathMatrix[u][elem].rend(); it++) {
if (findBinding(u + 1, *it, imi)) {
return true;
}
}
}
imi.reduceOrErase(elem, inserted);
return false;
}
/*
\subsection{Function ~findMatchingBinding~}
Searches for a binding which fulfills every condition.
*/
bool TMatch::findMatchingBinding(const int startState) {
if ((startState < 0) || (startState > (int)p->nfa.size() - 1)) {
return false; // illegal start state
}
if (p->conds.empty()) {
return true;
}
map<int, int> transitions = p->nfa[startState];
IndexMatchInfo imi;
map<int, int>::reverse_iterator itm;
for (itm = transitions.rbegin(); itm != transitions.rend(); itm++) {
if (findBinding(0, p->atomicToElem[itm->first], imi)) {
return true;
}
}
return false;
}
TypeConstructor tupleindexTC(
TupleIndex<UnitPos, UnitPos>::BasicType(),
TupleIndex<UnitPos, UnitPos>::Property,
TupleIndex<UnitPos, UnitPos>::Out, TupleIndex<UnitPos, UnitPos>::In,
0, 0,
TupleIndex<UnitPos, UnitPos>::Create, TupleIndex<UnitPos,UnitPos>::Delete,
TupleIndex<UnitPos, UnitPos>::Open, TupleIndex<UnitPos, UnitPos>::Save,
TupleIndex<UnitPos, UnitPos>::Close, TupleIndex<UnitPos, UnitPos>::Clone,
0,
TupleIndex<UnitPos, UnitPos>::SizeOfObj,
TupleIndex<UnitPos, UnitPos>::TypeCheck);
TypeConstructor tupleindex2TC(
TupleIndex<NewInterval, UnitPos>::BasicType(),
TupleIndex<NewInterval, UnitPos>::Property,
TupleIndex<NewInterval, UnitPos>::Out,
TupleIndex<NewInterval, UnitPos>::In,
0, 0,
TupleIndex<NewInterval, UnitPos>::Create,
TupleIndex<NewInterval, UnitPos>::Delete,
TupleIndex<NewInterval, UnitPos>::Open,
TupleIndex<NewInterval, UnitPos>::Save,
TupleIndex<NewInterval, UnitPos>::Close,
TupleIndex<NewInterval, UnitPos>::Clone,
0,
TupleIndex<NewInterval, UnitPos>::SizeOfObj,
TupleIndex<NewInterval, UnitPos>::TypeCheck);
/*
\section{Functions for class ~TMatchIndexLI~}
\subsection{Constructor for indextmatches}
*/
TMatchIndexLI::TMatchIndexLI(Relation *r, ListExpr tt,
TupleIndex<UnitPos, UnitPos> *t, int a,
Pattern *pat, int majorValueNo, DataType type) :
IndexMatchSuper(r, pat, a, type), ttList(tt), ti(t), ti2(0),
valueNo(majorValueNo), firstEnd(0) {
TupleType *tupletype = rel->GetTupleType();
relevantAttrs = Tools::getRelevantAttrs(tupletype, a, majorValueNo);
// tupletype->DeleteIfAllowed();
}
/*
\subsection{Constructor for indextmatches2}
*/
TMatchIndexLI::TMatchIndexLI(Relation *r, ListExpr tt,
TupleIndex<NewInterval, UnitPos> *t, Pattern *p) :
IndexMatchSuper(r, p), ttList(tt), ti(0), ti2(t), valueNo(-1), firstEnd(0) {
TupleType *tupletype = rel->GetTupleType();
int dummy = INT_MIN;
relevantAttrs = Tools::getRelevantAttrs(tupletype, -1, dummy);
// tupletype->DeleteIfAllowed();
}
/*
\subsection{Destructor}
*/
TMatchIndexLI::~TMatchIndexLI() {
firstEnd = 0;
}
/*
\subsection{Function ~tiCompatibleToRel~}
*/
bool TMatchIndexLI::tiCompatibleToRel() {
SecondoCatalog* sc = SecondoSystem::GetCatalog();
TupleType *ttype = rel->GetTupleType();
IndexType indexType;
unsigned int pos;
pair<AttributeType, string> attrType;
for (int i = 0; i < ttype->GetNoAttributes(); i++) {
attrType.first = ttype->GetAttributeType(i);
attrType.second = sc->GetTypeName(attrType.first.algId,
attrType.first.typeId);
indexType = (ti!= 0 ? ti->attrToIndex[i].first : ti2->attrToIndex[i].first);
pos = (ti != 0 ? ti->attrToIndex[i].second : ti2->attrToIndex[i].second);
switch (indexType) {
case TRIE: {
if (attrType.second != "mlabel" && attrType.second != "mplace" &&
attrType.second != "mlabels" && attrType.second != "mplaces") {
return false;
}
if (pos >= (ti != 0 ? ti->tries.size() : ti2->tries.size())) {
return false;
}
break;
}
case BTREE: {
if (attrType.second != "mint") {
return false;
}
if (pos >= (ti != 0 ? ti->btrees.size() : ti2->btrees.size())) {
return false;
}
break;
}
case RTREE1: {
if (attrType.second != "mreal") {
return false;
}
if (pos >= (ti != 0 ? ti->rtrees1.size() : ti2->rtrees1.size())) {
return false;
}
break;
}
case RTREE2: {
if (attrType.second != "mpoint" && attrType.second != "mregion") {
return false;
}
if (pos >= (ti != 0 ? ti->rtrees2.size() : ti2->rtrees2.size())) {
return false;
}
break;
}
default: { // case NONE
break;
}
}
}
return true;
}
/*
\subsection{Function ~getNoComponents~}
*/
int TMatchIndexLI::getNoComponents(const TupleId tId, const int attrNo) {
string type = nl->ToString(nl->Second(nl->Nth(attrNo+1, nl->Second(ttList))));
if (type == "mlabel" || type == "mlabels" || type == "mplace" ||
type == "mplaces") {
return getTrajSize(tId, Tools::getDataType(type));
}
return Tools::getNoComponents(rel, tId, type, attrNo);
}
/*
\subsection{Function ~getFirstEnd~}
*/
Instant TMatchIndexLI::getFirstEnd(const TupleId id) {
Instant temp(datetime::instanttype), result(datetime::instanttype);
result.ToMaximum();
Tuple *t = rel->GetTuple(id, false);
for (unsigned int i = 0; i < relevantAttrs.size(); i++) {
if (relevantAttrs[i].second == "mlabel") {
((MLabel*)t->GetAttribute(relevantAttrs[i].first))->FinalInstant(temp);
}
else if (relevantAttrs[i].second == "mlabels") {
((MLabels*)t->GetAttribute(relevantAttrs[i].first))->FinalInstant(temp);
}
else if (relevantAttrs[i].second == "mplace") {
((MPlace*)t->GetAttribute(relevantAttrs[i].first))->FinalInstant(temp);
}
else if (relevantAttrs[i].second == "mplaces") {
((MPlaces*)t->GetAttribute(relevantAttrs[i].first))->FinalInstant(temp);
}
else if (relevantAttrs[i].second == "mpoint") {
((MPoint*)t->GetAttribute(relevantAttrs[i].first))->FinalInstant(temp);
}
else if (relevantAttrs[i].second == "mregion") {
((MRegion*)t->GetAttribute(relevantAttrs[i].first))->FinalInstant(temp);
}
else if (relevantAttrs[i].second == "mbool") {
((MBool*)t->GetAttribute(relevantAttrs[i].first))->FinalInstant(temp);
}
else if (relevantAttrs[i].second == "mint") {
((MInt*)t->GetAttribute(relevantAttrs[i].first))->FinalInstant(temp);
}
else if (relevantAttrs[i].second == "mreal") {
((MReal*)t->GetAttribute(relevantAttrs[i].first))->FinalInstant(temp);
}
else {
cout << "invalid type " << relevantAttrs[i].second << endl;
return result;
}
if (temp < result) { // find minimum
result = temp;
}
}
t->DeleteIfAllowed();
return result;
}
/*
\subsection{Function ~getResultForAtomPart~}
*/
void TMatchIndexLI::getResultForAtomPart(pair<int, pair<IndexType, int> >
indexInfo, pair<Word, SetRel> values, string type, vector<Periods*> &prev,
vector<Periods*> &result, const int prevCrucial, const bool mainAttr,
bool checkPrev /* = false */) {
vector<set<int> > temp1, temp2;
vector<Periods*> tempp2;
if (mainAttr) {
temp1.resize(rel->GetNoTuples() + 1);
temp2.resize(rel->GetNoTuples() + 1);
}
else {
tempp2.resize(rel->GetNoTuples() + 1, 0);
}
result.resize(rel->GetNoTuples() + 1);
int valueNo = 0;
bool proceed = false;
if (mainAttr) {
proceed = getSingleIndexResult(indexInfo, values, type, valueNo, temp1);
}
else {
proceed = getSingleIndexResult(indexInfo, values, type, valueNo, result);
}
set<int> tmp;
if (!proceed && !mainAttr) { //
}
while (proceed) {
valueNo++;
if (mainAttr) {
proceed = getSingleIndexResult(indexInfo, values, type, valueNo, temp2);
}
else {
proceed = getSingleIndexResult(indexInfo, values, type, valueNo, tempp2);
}
switch (values.second) {
case STANDARD:
case INTERSECT: // unite intermediate results
if (mainAttr) {
for (int i = 1; i <= rel->GetNoTuples(); i++) {
temp1[i].insert(temp2[i].begin(), temp2[i].end());
}
}
else {
Periods pertmp(true);
for (int i = 1; i <= rel->GetNoTuples(); i++) {
if (result[i] != 0 && tempp2[i] != 0) {
if (!result[i]->IsOrdered()) {
result[i]->EndBulkLoad(true);
}
if (!tempp2[i]->IsEmpty() && !tempp2[i]->IsOrdered()) {
tempp2[i]->EndBulkLoad(true);
}
result[i]->Union(*(tempp2[i]), pertmp);
// result[i]->CopyFrom(&pertmp);
result[i]->DeleteIfAllowed();
result[i] = (Periods*)pertmp.compress();
}
else if (result[i] == 0 && tempp2[i] != 0) {
if (!tempp2[i]->IsOrdered()) {
tempp2[i]->EndBulkLoad(true);
}
// result[i] = new Periods(*(tempp2[i]));
result[i] = (Periods*)(tempp2[i])->compress();
}
}
}
break;
case SUPERSET:
case EQUAL: // intersect intermediate results
if (mainAttr) {
for (int i = 1; i <= rel->GetNoTuples(); i++) {
std::set_intersection(temp1[i].begin(), temp1[i].end(),
temp2[i].begin(), temp2[i].end(), std::inserter(tmp, tmp.begin()));
temp1[i] = tmp;
tmp.clear();
}
}
else {
Periods pertmp(true);
for (int i = 1; i <= rel->GetNoTuples(); i++) {
if (result[i] != 0 && tempp2[i] != 0) {
result[i]->EndBulkLoad(true);
tempp2[i]->EndBulkLoad(true);
result[i]->Intersection(*(tempp2[i]), pertmp);
result[i]->CopyFrom(&pertmp);
}
else if (result[i] != 0) {
result[i]->DeleteIfAllowed();
result[i] = 0;
}
}
}
break;
default: { // case DISJOINT: ignore
break;
}
}
if (mainAttr) {
temp2.clear();
temp2.resize(rel->GetNoTuples() + 1);
}
else {
for (int i = 1; i <= rel->GetNoTuples(); i++) {
if (tempp2[i] != 0) {
tempp2[i]->DeleteIfAllowed();
tempp2[i] = 0;
}
}
}
}
if (mainAttr) {
if (prevCrucial == -1) { // standard version
if (!checkPrev) {
for (int i = 1; i <= rel->GetNoTuples(); i++) {
if (!temp1[i].empty()) {
result[i] = new Periods(1);
unitsToPeriods(temp1[i], i, indexInfo.first, result[i]);
}
}
}
else { // create periods iff necessary
for (int i = 1; i <= rel->GetNoTuples(); i++) {
if (!temp1[i].empty() && prev[i]) {
result[i] = new Periods(1);
unitsToPeriods(temp1[i], i, indexInfo.first, result[i]);
}
}
}
}
else {
// if (mainAttr) {
if (!checkPrev) {
for (int i = 1; i <= rel->GetNoTuples(); i++) {
if (!temp1[i].empty() && indexResult[prevCrucial][i] != 0) {
result[i] = new Periods(1);
unitsToPeriods(temp1[i], i, indexInfo.first, result[i]);
}
}
}
else { // create periods iff necessary
for (int i = 1; i <= rel->GetNoTuples(); i++) {
if (!temp1[i].empty() && prev[i] && indexResult[prevCrucial][i] != 0){
result[i] = new Periods(1);
unitsToPeriods(temp1[i], i, indexInfo.first, result[i]);
}
}
}
}
// else {
// if (!checkPrev) {
// for (int i = 1; i <= rel->GetNoTuples(); i++) {
// if (!temp1[i].empty() && indexResult2[prevCrucial][i] != 0) {
// result[i] = new Periods(1);
// unitsToPeriods(temp1[i], i, indexInfo.first, result[i]);
// }
// }
// }
// else { // create periods iff necessary
// for (int i = 1; i <= rel->GetNoTuples(); i++) {
// if (!temp1[i].empty() && prev[i] &&
// indexResult2[prevCrucial][i] != 0) {
// result[i] = new Periods(1);
// unitsToPeriods(temp1[i], i, indexInfo.first, result[i]);
// }
// }
// }
// }
}
}
/*
\subsection{Function ~getResultForAtomTime~}
*/
bool TMatchIndexLI::getResultForAtomTime(const int atomNo,
const int prevCrucial, vector<Periods*> &result) {
PatElem atom;
p->getElem(atomNo, atom);
set<string> ivs;
atom.getI(ivs);
if (ivs.empty()) {
return false;
}
for (set<string>::iterator it = ivs.begin(); it != ivs.end(); it++) {
if (!Tools::isInterval(*it)) {
return false;
}
}
SecInterval ivInst(true);
CcReal start(true, 0);
CcReal end(true, 0);
vector<set<int> > temp1, temp2;
temp1.resize(rel->GetNoTuples() + 1);
temp2.resize(rel->GetNoTuples() + 1);
set<int> tmp;
bool first = true;
bool indexApplied = false;
for (set<string>::iterator it = ivs.begin(); it != ivs.end(); it++) {
Tools::stringToInterval(*it, ivInst);
start.Set(true, ivInst.start.ToDouble());
end.Set(true, ivInst.end.ToDouble());
if (!(start == end) || start.GetValue() != 0.0) {
Interval<CcReal> iv(start, end, true, false);
if (first) {
Tools::queryRtree1(ti->timeIndex, iv, temp1);
first = false;
}
else {
Tools::queryRtree1(ti->timeIndex, iv, temp2);
for (int i = 1; i <= rel->GetNoTuples(); i++) {
std::set_intersection(temp1[i].begin(), temp1[i].end(),
temp2[i].begin(), temp2[i].end(), std::inserter(tmp, tmp.begin()));
temp1[i] = tmp;
tmp.clear();
}
}
indexApplied = true;
}
}
if (!indexApplied) {
return false;
}
if (prevCrucial == -1) {
for (int i = 1; i <= rel->GetNoTuples(); i++) {
if (!temp1[i].empty()) {
result[i] = new Periods(0);
unitsToPeriods(temp1[i], i, attrNo, result[i]);
}
}
}
else {
for (int i = 1; i <= rel->GetNoTuples(); i++) {
if (!temp1[i].empty() && indexResult[prevCrucial][i] != 0) {
result[i] = new Periods(0);
unitsToPeriods(temp1[i], i, attrNo, result[i]);
}
}
}
return true;
}
/*
\subsection{Function ~storeIndexResult~}
*/
void TMatchIndexLI::storeIndexResult(const int atomNo, const int prevCrucial,
const bool mainAttr, int &noResults) {
if (!mainAttr && indexResult2[atomNo] != 0) {
return;
}
noResults = 0;
PatElem atom;
p->getElem(atomNo, atom);
map<int, pair<IndexType, int> >::iterator it
= (ti != 0 ? ti->attrToIndex.begin() : ti2->attrToIndex.begin());
int noRelevantAttrs = 0;
while (it != (ti != 0 ? ti->attrToIndex.end() : ti2->attrToIndex.end())) {
if (it->second.first != NONE) {
noRelevantAttrs++;
}
it++;
}
if (noRelevantAttrs != atom.getNoValues()) {
cout << "Error: " << noRelevantAttrs << " != " << atom.getNoValues()<< endl;
return;
}
vector<set<int> > result;
vector<Periods*> periods, temp;
if (mainAttr) {
result.resize(rel->GetNoTuples() + 1);
}
periods.resize(rel->GetNoTuples() + 1, 0);
temp.resize(rel->GetNoTuples() + 1, 0);
int pos(0), pred(0);
bool intersect = mainAttr ?
getResultForAtomTime(atomNo, prevCrucial, periods) : false;
Periods tmp(0);
if (mainAttr) {
if (indexResult[atomNo] == 0) {
indexResult[atomNo] = new IndexRetrieval*[rel->GetNoTuples() + 1];
memset(indexResult[atomNo], 0, (rel->GetNoTuples() + 1)*sizeof(void*));
}
indexResult[atomNo][0] = new IndexRetrieval(0, 0);
}
else {
if (indexResult2[atomNo] == 0) {
indexResult2[atomNo] = new IndexRetrieval2*[rel->GetNoTuples() + 1];
memset(indexResult2[atomNo], 0, (rel->GetNoTuples() + 1)*sizeof(void*));
}
indexResult2[atomNo][0] = new IndexRetrieval2(0, 0);
}
// for (it = ti->attrToIndex.begin(); it != ti->attrToIndex.end(); it++) {
// cout << it->first << " ---> " << it->second.second << endl;
// }
it = (ti != 0 ? ti->attrToIndex.begin() : ti2->attrToIndex.begin());
while (it != (ti != 0 ? ti->attrToIndex.end() : ti2->attrToIndex.end())) {
if (!intersect && it->second.second != -1 &&
atom.values[pos].first.addr != 0) {
// cout << "call gRFAP " << it->first << endl;
getResultForAtomPart(*it, atom.values[pos], atom.types[pos], temp,
periods, prevCrucial, mainAttr);
intersect = true;
// cout << atom.values.size() << "values, after " << it->first << ", pos "
// << pos << ": ";
// for (int i = 1; i <= rel->GetNoTuples(); i++) {
// cout << result[i].size() << " ";
// }
// cout << endl;
}
else {
if (it->second.second != -1 && atom.values[pos].first.addr != 0) {
// cout << "call xgRFAP for attr " << it->first << endl;
getResultForAtomPart(*it, atom.values[pos], atom.types[pos], periods,
temp, prevCrucial, mainAttr, true);
for (int i = 1; i <= rel->GetNoTuples(); i++) {
if (periods[i] && temp[i]) {
if (!periods[i]->IsOrdered()) {
periods[i]->EndBulkLoad(true);
}
if (!temp[i]->IsOrdered()) {
temp[i]->EndBulkLoad(true);
}
periods[i]->Intersection(*temp[i], tmp);
periods[i]->CopyFrom(&tmp);
tmp.Clear();
temp[i]->DeleteIfAllowed();
temp[i] = 0;
}
else if (periods[i]) {
periods[i]->DeleteIfAllowed();
periods[i] = 0;
}
else if (temp[i]) {
temp[i]->DeleteIfAllowed();
temp[i] = 0;
}
}
temp.clear();
temp.resize(rel->GetNoTuples() + 1);
}
}
if (it->second.first != NONE) {
pos++;
}
it++;
} // index information collected and intersected
if (mainAttr) { // version for indextmatches
if (prevCrucial == -1) { // standard version
for (int i = 1; i <= rel->GetNoTuples(); i++) {
periodsToUnits(periods[i], i, result[i]);
if (periods[i]) {
periods[i]->DeleteIfAllowed();
}
if (!result[i].empty()) {
indexResult[atomNo][pred]->succ = i; // refresh succ of pred
if (indexResult[atomNo][i] == 0) {
indexResult[atomNo][i] = new IndexRetrieval(pred, i, result[i]);
memset((void*)indexResult[atomNo][i], 0, sizeof(void*));
noResults++;
}
pred = i;
}
}
}
else { // process periods only if tuple id is still active and relevant
for (int i = 1; i <= rel->GetNoTuples(); i++) {
if (indexResult[prevCrucial][i] != 0) { // previous index result exists
periodsToUnits(periods[i], i, result[i]);
if (periods[i]) {
periods[i]->DeleteIfAllowed();
}
if (!result[i].empty()) {
indexResult[atomNo][pred]->succ = i; // refresh succ of pred
if (indexResult[atomNo][i] == 0) {
indexResult[atomNo][i] = new IndexRetrieval(pred, i, result[i]);
memset((void*)indexResult[atomNo][i], 0, sizeof(void*));
noResults++;
}
pred = i;
}
}
else if (periods[i]) {
periods[i]->DeleteIfAllowed();
}
}
}
}
else { // version for indextmatches2
set<string> ivsAtom;
atom.getI(ivsAtom);
set<string>::iterator it = ivsAtom.begin();
Periods perAtom(false), perSpec(false), perTemp(true);
if (ivsAtom.empty()) {
perAtom.SetDefined(false);
}
else {
perAtom.SetDefined(true);
}
while (it != ivsAtom.end()) {
// cout << "process |" << *it << "|" << endl;
Tools::specToPeriods(*it, ti2->timeLimits, perSpec);
if (it == ivsAtom.begin()) { // first specification
perAtom.CopyFrom(&perSpec);
// cout << "1st RESULT: " << perSpec << endl;
}
else {
perAtom.Intersection(perSpec, perTemp);
perAtom.CopyFrom(&perTemp);
perTemp.Clear();
// cout << "intermediate RESULT: " << perAtom << endl;
}
it++;
}
if (prevCrucial == -1) {
for (int i = 1; i <= rel->GetNoTuples(); i++) {
if (periods[i]) {
if (!periods[i]->IsEmpty()) { // index result exists
indexResult2[atomNo][pred]->succ = i;
if (perAtom.IsDefined()) {
if (!periods[i]->IsOrdered()) {
periods[i]->EndBulkLoad(true, false);
}
periods[i]->Intersection(perAtom, perTemp);
periods[i]->CopyFrom(&perTemp);
}
indexResult2[atomNo][i] = new IndexRetrieval2(pred, 0, periods[i]);
noResults++;
pred = i;
}
else { // remove empty results
periods[i]->DeleteIfAllowed();
}
}
}
}
else {
for (int i = 1; i <= rel->GetNoTuples(); i++) {
if (indexResult2[prevCrucial][i] != 0 && periods[i] != 0) {
if (!periods[i]->IsEmpty()) { // prev. index result exists
indexResult2[atomNo][pred]->succ = i; // refresh succ of pred
if (perAtom.IsDefined()) {
if (!periods[i]->IsOrdered()) {
periods[i]->EndBulkLoad(true, false);
}
periods[i]->Intersection(perAtom, perTemp);
periods[i]->CopyFrom(&perTemp);
}
indexResult2[atomNo][i] = new IndexRetrieval2(pred, 0, periods[i]);
noResults++;
pred = i;
}
else { // remove empty results
periods[i]->DeleteIfAllowed();
}
}
else if (periods[i] != 0) {
periods[i]->DeleteIfAllowed();
}
}
}
}
if (mainAttr) {
indexResult[atomNo][pred]->succ = 0; // set successor to 0 for final id
}
else {
indexResult2[atomNo][pred]->succ = 0;
}
// if (!mainAttr) {
// cout << "index result for atom " << atomNo << ":" << endl;
// for (int i = 1; i <= rel->GetNoTuples(); i++) {
// if (indexResult2[atomNo][i] != 0) {
// cout << "tuple " << i << ": " << indexResult2[atomNo][i]->pred
// << ", " << indexResult2[atomNo][i]->succ << ", "
// << *(indexResult2[atomNo][i]->per) << endl;
// }
// }
// }
}
/*
\subsection{Function ~initMatchInfo~}
*/
void TMatchIndexLI::initMatchInfo(const bool mainAttr) {
PatElem atom;
for (set<int>::iterator it = crucialAtoms.begin(); it != crucialAtoms.end();
it++) {
// cout << "removed ids ";
p->getElem(*it, atom);
int oldId = 0;
if (atom.isRelevantForTupleIndex()) {
int id = mainAttr ? indexResult[*it][0]->succ :
indexResult2[*it][0]->succ;
// if (id == 0) { // no index result
// cout << "crucial atom " << *it << ": no index result; EXIT" << endl;
// return;
// }
while (id > 0) {
for (int i = oldId + 1; i < id; i++) {
removeIdFromIndexResult(i, mainAttr);
active[i] = false;
}
oldId = id;
id = mainAttr ? indexResult[*it][oldId]->succ :
indexResult2[*it][oldId]->succ;
}
for (int i = oldId + 1; i <= rel->GetNoTuples(); i++) {
removeIdFromIndexResult(i, mainAttr);
active[i] = false;
// cout << i << ",";
}
}
// cout << " because of crucial atom " << *it << endl;
}
unsigned int pred = 0;
DataType type;
if (mainAttr) { // version for indextmatches
matchInfo = new IndexMatchSlot**[p->getNFAsize()];
memset(matchInfo, 0, p->getNFAsize() * sizeof(void*));
newMatchInfo = new IndexMatchSlot**[p->getNFAsize()];
memset(newMatchInfo, 0, p->getNFAsize() * sizeof(void*));
for (int s = 0; s < p->getNFAsize(); s++) {
matchInfo[s] = new IndexMatchSlot*[rel->GetNoTuples() + 1];
memset(matchInfo[s], 0, (rel->GetNoTuples() + 1) * sizeof(void*));
newMatchInfo[s] = new IndexMatchSlot*[rel->GetNoTuples() + 1];
memset(newMatchInfo[s], 0, (rel->GetNoTuples() + 1) * sizeof(void*));
matchInfo[s][0] = new IndexMatchSlot();
newMatchInfo[s][0] = new IndexMatchSlot();
}
type = Tools::getDataType(rel->GetTupleType(), attrNo);
for (TupleId id = 1; id <= (TupleId)rel->GetNoTuples(); id++) {
if (active[id]) {
activeTuples++;
IndexMatchInfo imi(false);
if (loopStates.find(0) != loopStates.end()) {
imi.range = true;
}
for (int s = 0; s < p->getNFAsize(); s++) {
matchInfo[s][id] = new IndexMatchSlot();
matchInfo[s][id]->pred = pred;
matchInfo[s][pred]->succ = id;
newMatchInfo[s][id] = new IndexMatchSlot();
newMatchInfo[s][id]->pred = pred;
newMatchInfo[s][pred]->succ = id;
}
matchInfo[0][id]->imis.push_back(imi);
pred = id;
trajSize[id] = getTrajSize(id, type);
}
}
for (int s = 0; s < p->getNFAsize(); s++) {
matchInfo[s][pred]->succ = 0; // set succ of last active tid to 0
newMatchInfo[s][pred]->succ = 0;
}
}
else { // version for indextmatches2
matchInfo2 = new IndexMatchSlot2**[p->getNFAsize()];
memset(matchInfo2, 0, p->getNFAsize() * sizeof(void*));
newMatchInfo2 = new IndexMatchSlot2**[p->getNFAsize()];
memset(newMatchInfo2, 0, p->getNFAsize() * sizeof(void*));
for (int s = 0; s < p->getNFAsize(); s++) {
matchInfo2[s] = new IndexMatchSlot2*[rel->GetNoTuples() + 1];
memset(matchInfo2[s], 0, (rel->GetNoTuples() + 1) * sizeof(void*));
newMatchInfo2[s] = new IndexMatchSlot2*[rel->GetNoTuples() + 1];
memset(newMatchInfo2[s], 0, (rel->GetNoTuples() + 1) * sizeof(void*));
matchInfo2[s][0] = new IndexMatchSlot2();
newMatchInfo2[s][0] = new IndexMatchSlot2();
}
for (TupleId id = 1; id <= (TupleId)rel->GetNoTuples(); id++) {
if (active[id]) {
activeTuples++;
IndexMatchInfo2 imi;
for (int s = 0; s < p->getNFAsize(); s++) {
matchInfo2[s][id] = new IndexMatchSlot2();
matchInfo2[s][id]->pred = pred;
matchInfo2[s][pred]->succ = id;
newMatchInfo2[s][id] = new IndexMatchSlot2();
newMatchInfo2[s][id]->pred = pred;
newMatchInfo2[s][pred]->succ = id;
}
matchInfo2[0][id]->imis.push_back(imi);
// cout << "pushed back imi for id " << id << endl;
pred = id;
}
}
for (int s = 0; s < p->getNFAsize(); s++) {
matchInfo2[s][pred]->succ = 0; // set succ of last active tid to 0
newMatchInfo2[s][pred]->succ = 0;
}
}
}
/*
\subsection{Function ~atomMatch~}
*/
bool TMatchIndexLI::atomMatch(int state, pair<int, int> trans,
const bool rewrite /* = false */) {
// cout << "atomMatch(" << state << ", " << trans.first << ", "
// << trans.second << ") called" << endl;
PatElem atom;
p->getElem(trans.first, atom);
set<string> ivs;
atom.getI(ivs);
SecInterval iv;
vector<TupleId> toRemove;
p->getElem(trans.first, atom);
bool transition = false;
IndexMatchInfo *imiPtr = 0;
if (atom.isRelevantForTupleIndex()) {
if (indexResult[trans.first] == 0) {
int noResults;
storeIndexResult(trans.first, -1, true, noResults);
}
TupleId id = indexResult[trans.first][0]->succ;
int minUnit = INT_MAX;
while (id > 0) {
bool totalMatch = false;
set<int>::reverse_iterator it =
indexResult[trans.first][id]->units.rbegin();
while (active[id] && it != indexResult[trans.first][id]->units.rend()) {
unsigned int numOfIMIs = (matchInfo[state][id] != 0 ?
matchInfo[state][id]->imis.size() : 0);
for (unsigned int i = 0; i < numOfIMIs; i++) {
imiPtr = &matchInfo[state][id]->imis[i];
bool ok = (imiPtr->range ? imiPtr->next <= *it : imiPtr->next == *it);
if (ok) {
Tuple *t = rel->GetTuple(id, false);
TMatch tmatch(p, t, ttList, attrNo, relevantAttrs, valueNo);
bool match = false;
ExtBool matchRec = ST_UNDEF;
if (matchRecord[trans.first][id] != 0) {
matchRec = matchRecord[trans.first][id]->getMatchRecord(*it);
if (matchRec == ST_TRUE) {
match = true;
}
}
else {
matchRecord[trans.first][id] = new DoubleUnitSet();
}
if (matchRec == ST_UNDEF) {
getInterval(id, *it, iv);
match = tmatch.valuesMatch(*it, trans.first, false) &&
Tools::timesMatch(iv, ivs) &&
tmatch.easyCondsMatch(*it, trans.first);
matchRecord[trans.first][id]->addMatchRecord(*it, match);
}
if (match) {
transition = true;
IndexMatchInfo newIMI(false, *it + 1, imiPtr->binding,
imiPtr->prevElem);
if (loopStates.find(trans.second) != loopStates.end()) {
newIMI.range = true;
}
totalMatch = p->isFinalState(trans.second) &&
newIMI.finished(trajSize[id]);
if (p->hasConds() || rewrite) {
extendBinding(newIMI, trans.first, false, totalMatch ? id : 0);
if (totalMatch && p->hasConds()) {
ExtBool condRec = ST_UNDEF;
if (condRecord[id] != 0) {
condRec = condRecord[id]->getCondRecord(newIMI);
}
else {
condRecord[id] = new DoubleBindingSet();
}
if (condRec != ST_UNDEF) {
totalMatch = (condRec == ST_TRUE ? true : false);
}
else {
TMatch tmatch(p, t, ttList, attrNo, relevantAttrs, valueNo);
totalMatch = tmatch.conditionsMatch(newIMI);
condRecord[id]->addCondRecord(newIMI, totalMatch);
}
}
}
if (totalMatch) {
if (rewrite) {
NewPair<TupleId, IndexMatchInfo> res(id, newIMI);
matchesR.push_back(res);
// cout << "Result: " << id << "; ";
// newIMI.print(true);
}
else {
matches.push_back(id); // complete match
// cout << "MATCH for id " << id << endl;
toRemove.push_back(id);
// cout << id << " removed (wild match) " << activeTuples
// << " active tuples" << endl;
i = numOfIMIs; // stop processing this tuple id
active[id] = false;
}
}
else if (!newIMI.exhausted(trajSize[id])) { // continue
newMatchInfo[trans.second][id]->imis.push_back(newIMI);
// cout << "Pushed back imi for id " << id << ", range="
// << (newIMI.range ? "TRUE" : "FALSE") << endl;
}
if (*it < minUnit) {
minUnit = *it;
}
}
else {
if (imiPtr->range && canBeDeactivated(id, state, trans.first)) {
// cout << "*Deactivate id " << id << endl;
toRemove.push_back(id);
}
}
t->DeleteIfAllowed();
}
}
it++;
}
TupleId oldId = id;
id = indexResult[trans.first][id]->succ;
if (canBeDeactivated(oldId, state, trans.first, true)) {
// cout << "#### deactivate " << oldId << endl;
toRemove.push_back(oldId);
}
remove(toRemove, true);
}
if (minUnit > unitCtr && minUnit < INT_MAX) {
unitCtr = minUnit; //set counter to minimum of index results
}
}
else { // consider all existing imi instances
// cout << "not relevant for index; consider all instances; "
// << (*matchInfoPtr)[state][0].succ << " "
// << (*newMatchInfoPtr)[state][0].succ << endl;
TupleId id = matchInfo[state][0]->succ; // first active tuple id
while (id > 0) {
// cout << ": " << matchInfo[state][id]->imis.size()
// << " IMIs, state=" << state << ", id=" << id << endl;
unsigned int numOfIMIs = (matchInfo[state][id] != 0 ?
matchInfo[state][id]->imis.size() : 0);
unsigned int i = 0;
while (active[id] && i < numOfIMIs) {
bool totalMatch = false;
imiPtr = &(matchInfo[state][id]->imis[i]);
if (imiPtr->next + 1 >= unitCtr) {
Tuple *t = rel->GetTuple(id, false);
if (atom.getW() == NO) { // () or disjoint{...} or (monday _); no wc
TMatch tmatch(p, t, ttList, attrNo, relevantAttrs, valueNo);
if (imiPtr->range == false) { // exact matching required
bool match = false;
ExtBool matchRec = ST_UNDEF;
if (matchRecord[trans.first][id] != 0) {
matchRec = matchRecord[trans.first][id]->
getMatchRecord(imiPtr->next);
if (matchRec == ST_TRUE) {
match = true;
}
}
else {
matchRecord[trans.first][id] = new DoubleUnitSet();
}
if (matchRec == ST_UNDEF) {
getInterval(id, imiPtr->next, iv);
match = tmatch.valuesMatch(imiPtr->next, trans.first, false) &&
Tools::timesMatch(iv, ivs) &&
tmatch.easyCondsMatch(imiPtr->next, trans.first);
matchRecord[trans.first][id]->
addMatchRecord(imiPtr->next, match);
}
if (match) {
transition = true;
IndexMatchInfo newIMI(false, imiPtr->next + 1, imiPtr->binding,
imiPtr->prevElem);
totalMatch = p->isFinalState(trans.second) &&
newIMI.finished(trajSize[id]);
if (p->hasConds() || rewrite) {
extendBinding(newIMI, trans.first, false,totalMatch ? id : 0);
if (totalMatch && p->hasConds()) {
ExtBool condRec = ST_UNDEF;
if (condRecord[id] != 0) {
condRec = condRecord[id]->getCondRecord(newIMI);
}
else {
condRecord[id] = new DoubleBindingSet();
}
if (condRec != ST_UNDEF) {
totalMatch = (condRec == ST_TRUE ? true : false);
}
else {
TMatch tmatch(p, t, ttList, attrNo, relevantAttrs,
valueNo);
totalMatch = tmatch.conditionsMatch(newIMI);
condRecord[id]->addCondRecord(newIMI, totalMatch);
}
}
}
if (totalMatch) {
if (rewrite) {
NewPair<TupleId, IndexMatchInfo > res(id, newIMI);
matchesR.push_back(res);
// cout << "Result: " << id << "; ";
// newIMI.print(true);
}
else {
matches.push_back(id); // complete match
toRemove.push_back(id);
// cout << id << " removed (wild match) " << activeTuples
// << " active tuples" << endl;
i = numOfIMIs; // stop processing this tuple id
active[id] = false;
}
}
else if (!newIMI.exhausted(trajSize[id])) { // continue
newMatchInfo[trans.second][id]->imis.push_back(newIMI);
}
}
else {
if (imiPtr->range && canBeDeactivated(id, state, trans.first)) {
// cout << "*Deactivate id " << id << endl;
toRemove.push_back(id);
}
}
}
else { // wildcard before this transition; check all successors
int k = imiPtr->next;
while (k < trajSize[id]) {
bool match = false;
ExtBool matchRec = ST_UNDEF;
if (matchRecord[trans.first][id] != 0) {
matchRec = matchRecord[trans.first][id]->
getMatchRecord(k);
if (matchRec == ST_TRUE) {
match = true;
}
}
else {
matchRecord[trans.first][id] = new DoubleUnitSet();
}
if (matchRec == ST_UNDEF) {
getInterval(id, k, iv);
match = tmatch.valuesMatch(k, trans.first, false) &&
Tools::timesMatch(iv, ivs) &&
tmatch.easyCondsMatch(k, trans.first);
matchRecord[trans.first][id]-> addMatchRecord(k, match);
}
if (match) {
transition = true;
IndexMatchInfo newIMI(false, k + 1, imiPtr->binding,
imiPtr->prevElem);
totalMatch = p->isFinalState(trans.second) &&
newIMI.finished(trajSize[id]);
if (p->hasConds() || rewrite) {
extendBinding(newIMI, trans.first, false, totalMatch?id:0);
if (totalMatch && p->hasConds()) {
ExtBool condRec = ST_UNDEF;
if (condRecord[id] != 0) {
condRec = condRecord[id]->getCondRecord(newIMI);
}
else {
condRecord[id] = new DoubleBindingSet();
}
if (condRec != ST_UNDEF) {
totalMatch = (condRec == ST_TRUE ? true : false);
}
else {
TMatch tmatch(p, t, ttList, attrNo, relevantAttrs,
valueNo);
totalMatch = tmatch.conditionsMatch(newIMI);
condRecord[id]->addCondRecord(newIMI, totalMatch);
}
}
}
if (totalMatch) {
if (rewrite) {
NewPair<TupleId, IndexMatchInfo> res(id, newIMI);
matchesR.push_back(res);
// cout << "Result: " << id << "; ";
// newIMI.print(true);
}
else {
matches.push_back(id); // complete match
// cout << "MATCH for id " << id << " !!" << endl;
toRemove.push_back(id);
// cout << id << " removed (wild match) " << activeTuples
// << " active tuples" << endl;
k = trajSize[id];
i = numOfIMIs; // stop processing this tuple id
active[id] = false;
}
}
else if (!newIMI.exhausted(trajSize[id])) { // continue
newMatchInfo[trans.second][id]->imis.push_back(newIMI);
}
else {
if (canBeDeactivated(id, state, trans.first)) {
// cout << "Deactivate id " << id << endl;
toRemove.push_back(id);
}
}
k++;
}
}
}
}
else { // wildcard
transition = true;
IndexMatchInfo newIMI(true, imiPtr->next + 1, imiPtr->binding,
imiPtr->prevElem);
totalMatch = p->isFinalState(trans.second) &&
newIMI.finished(trajSize[id]);
if (p->hasConds() || rewrite) {
extendBinding(newIMI, trans.first, true, totalMatch ? id : 0);
if (totalMatch && p->hasConds()) {
ExtBool condRec = ST_UNDEF;
if (condRecord[id] != 0) {
condRec = condRecord[id]->getCondRecord(newIMI);
}
else {
condRecord[id] = new DoubleBindingSet();
}
if (condRec != ST_UNDEF) {
totalMatch = (condRec == ST_TRUE ? true : false);
}
else {
TMatch tmatch(p, t, ttList, attrNo, relevantAttrs, valueNo);
totalMatch = tmatch.conditionsMatch(newIMI);
condRecord[id]->addCondRecord(newIMI, totalMatch);
}
}
}
if (totalMatch) {
if (rewrite) {
NewPair<TupleId, IndexMatchInfo> res(id, newIMI);
matchesR.push_back(res);
// cout << "Result: " << id << "; ";
// newIMI.print(true);
}
else {
matches.push_back(id); // complete match
// cout << "complete match for id " << id << endl;
toRemove.push_back(id);
// cout << id << " removed (wild match) " << activeTuples
// << " active tuples" << endl;
i = numOfIMIs; // stop processing this tuple id
active[id] = false;
}
}
else if (!newIMI.exhausted(trajSize[id])) { // continue
newMatchInfo[trans.second][id]->imis.push_back(newIMI);
}
}
t->DeleteIfAllowed();
}
i++;
}
if (active[id]) {
if (!hasIdIMIs(id, true, state)) { // no IMIs for id and state
if (!hasIdIMIs(id, true)) { // no IMIs at all for id
toRemove.push_back(id);
// cout << id << " removed (wild mismatch) " << activeTuples
// << " active tuples" << endl;
}
}
}
id = matchInfo[state][id]->succ;
remove(toRemove, true);
}
}
// cout << "........ return " << (transition ? "TRUE" : "FALSE") << endl;
return transition;
}
/*
\subsection{Function ~extendBinding2~}
*/
void TMatchIndexLI::extendBinding2(Periods *per, const int elem,
const bool totalMatch, IndexMatchInfo2& imi) {
if (imi.binding.find(elem) == imi.binding.end()) { // elem not bound yet
imi.binding.insert(make_pair(elem, *per));
Periods inter(true);
Instant start(datetime::instanttype), end(datetime::instanttype);
if (elem == 0) { // *X Y (__)* ...
start.ToMinimum();
per->Minimum(end);
SecInterval iv(start, end, false, false);
inter.Add(iv);
}
else { // ... *Y (__)* ...
Periods lastBinding(true), unionResult(true);
imi.getBinding(elem - 1, lastBinding);
lastBinding.Minimum(start);
per->Maximum(end);
SecInterval iv(start, end, false, false);
inter.Add(iv);
if (!lastBinding.IsOrdered()) {
cout << "sort now" << endl;
lastBinding.EndBulkLoad(true, false);
cout << lastBinding.IsOrdered() << endl;
}
lastBinding.Union(*per, unionResult);
inter.Minus(unionResult); // [p_B.start, p_D.end] \ (p_B U p_D)
} // bind intervals between elements
imi.binding.insert(make_pair(-1 * elem - 1, inter));
if (totalMatch && elem == p->getNoElems() - 1) { // ... *X (__)* Y
Periods after(true);
bool leftclosed = false;
per->Maximum(start);
end.ToMaximum();
if (!per->IsEmpty()) {
SecInterval previousIv(start, end, false, false);
per->Get(per->GetNoComponents() - 1, previousIv);
leftclosed = !previousIv.rc;
}
SecInterval iv(start, end, leftclosed, false);
after.Add(iv);
imi.binding.insert(make_pair(-1 * elem - 2, after));
}
}
else { // extend existing binding; ... X [(__) | (__) (__) *(__)*] ...
Periods unionResult(true);
imi.binding[elem].Union(*per, imi.binding[elem]);
}
// cout << "elem " << elem << ": "; imi.print();
}
/*
\subsection{Function ~canBeDeactivated2~}
*/
bool TMatchIndexLI::canBeDeactivated2(const TupleId id, const int state,
const int atom) {
if (crucialAtoms.find(atom) != crucialAtoms.end()) {
for (int i = state + 1; i < p->getNFAsize(); i++) {
if (matchInfo2[i] != 0) {
if (matchInfo2[i][id] != 0) {
if (!matchInfo2[i][id]->imis.empty()) {
// cout << "------------DO NOT deactivate id " << id
// << ", has mI[" << i << "]" << endl;
return false;
}
}
}
if (newMatchInfo2[i] != 0) {
if (newMatchInfo2[i][id] != 0) {
if (!newMatchInfo2[i][id]->imis.empty()) {
// cout << "-----------DO NOT deactivate id " << id
// << ", has nMI[" << i << "]" << endl;
return false;
}
}
}
}
}
return true;
}
/*
\subsection{Function ~geoMatch~}
Checks whether geometric specifications from a pattern atom match the
corresponding information from the tuple. Applied for indextmatches2
*/
bool TMatchIndexLI::geoMatch(const int atomNo, Tuple *t, Periods *per) {
PatElem atom;
for (unsigned int i = 0; i < relevantAttrs.size(); i++) {
if (relevantAttrs[i].second == "mpoint") {
p->getElem(atomNo, atom);
pair<Word, SetRel> values = atom.values[i];
if (values.first.addr != 0) {
MPoint *mpoint = (MPoint*)t->GetAttribute(relevantAttrs[i].first);
MPoint mpAtPer(true);
mpoint->AtPeriods(*per, mpAtPer);
if (mpAtPer.IsEmpty()) {
return false;
}
if (!((Region*)values.first.addr)->IsEmpty()) {
if (!Tools::relationHolds(mpAtPer, *((Region*)values.first.addr),
values.second)) {
return false;
}
}
}
}
else if (relevantAttrs[i].second == "mregion") {
p->getElem(atomNo, atom);
pair<Word, SetRel> values = atom.values[i];
if (values.first.addr != 0) {
MRegion *mreg = (MRegion*)t->GetAttribute(relevantAttrs[i].first);
MRegion mrAtPer(true);
mreg->AtPeriods(per, &mrAtPer);
if (mrAtPer.IsEmpty()) {
return false;
}
if (!((Region*)values.first.addr)->IsEmpty()) {
if (!Tools::relationHolds(mrAtPer, *((Region*)values.first.addr),
values.second)) {
return false;
}
}
}
}
}
return true;
}
/*
\subsection{Function ~evaluateInstant~}
applied for indextmatches2
*/
bool Condition::evaluateInstant(const ListExpr tt, Tuple *t,
IndexMatchInfo2& imi) {
Word qResult;
for (int i = 0; i < getVarKeysSize(); i++) {
int key = getKey(i);
if (key > 99) { // reference to attribute of tuple, e.g., X.Trip
if (Tools::isMovingAttr(tt, key - 99)) {
string type = nl->ToString(nl->Second(nl->Nth(key-99, nl->Second(tt))));
getConstValue(t->GetAttribute(key - 100), type, imi.inst, pointers[i]);
}
else {
pointers[i]->CopyFrom(t->GetAttribute(key - 100));
}
}
else { // reference to instant; X.time
((Periods*)pointers[i])->DeleteIfAllowed();
pointers[i] = new datetime::DateTime(datetime::instanttype);
*((Instant*)pointers[i]) = imi.inst;
}
}
// cout << nl->ToString(qp->ListOfTree(getOpTree(), cout)) << endl;
getQP()->EvalS(getOpTree(), qResult, OPEN);
// cout << "result for |" << text << "| is "
// << (((CcBool*)qResult.addr)->GetValue() ? "TRUE" : "FALSE") << endl;
return ((CcBool*)qResult.addr)->GetValue();
}
/*
\subsection{Function ~evaluatePeriods~}
*/
bool Condition::evaluatePeriods(const ListExpr tt, Tuple *t, Periods *per) {
Word qResult;
// cout << "evaluate cond |" << text << "| ;" << *per << endl;
for (int i = 0; i < getVarKeysSize(); i++) {
int key = getKey(i);
if (key > 99) { // reference to attribute of tuple, e.g., X.Trip
if (Tools::isMovingAttr(tt, key - 99)) {
string type = nl->ToString(nl->Second(nl->Nth(key-99, nl->Second(tt))));
copyAndRestrictPtr(i, t, tt, key - 99, *per);
}
else { // constant attribute, e.g., X.Id
pointers[i]->CopyFrom(t->GetAttribute(key - 100));
}
}
else {
Interval<Instant> iv(true);
switch (key) {
case 2: {
((Periods*)pointers[i])->CopyFrom(per);
break;
}
case 3: {
per->Minimum(*((Instant*)pointers[i]));
break;
}
case 4: {
per->Maximum(*((Instant*)pointers[i]));
break;
}
case 5: {
if (per->IsEmpty()) {
((CcBool*)pointers[i])->SetDefined(false);
}
else {
per->Get(0, iv);
((CcBool*)pointers[i])->Set(true, iv.lc);
}
break;
}
case 6: {
if (per->IsEmpty()) {
((CcBool*)pointers[i])->SetDefined(false);
}
else {
per->Get(per->GetNoComponents() - 1, iv);
((CcBool*)pointers[i])->Set(true, iv.rc);
}
break;
}
default: {
cout << "Error: invalid key " << key << " in condition" << endl;
return false;
}
}
}
}
return true;
// getQP()->EvalS(getOpTree(), qResult, OPEN);
// cout << "result for |" << text << "| is "
// << (((CcBool*)qResult.addr)->GetValue() ? "TRUE" : "FALSE") << endl;
// return ((CcBool*)qResult.addr)->GetValue();
}
/*
\subsection{Function ~easyCondsMatch~}
applied for indextmatches2
*/
bool TMatchIndexLI::easyCondsMatch(const int atomNo, Tuple *t, Periods *per) {
set<int> pos = p->getEasyCondPos(atomNo);
if (pos.empty() || p->easyConds.empty()) {
return true;
}
MBool mbool(true);
Periods tempPer(true), interResult(true);
Word qResult;
for (set<int>::iterator it = pos.begin(); it != pos.end(); it++) {
if (!p->easyConds[*it].evaluatePeriods(ttList, t, per)) {
return false;
}
p->easyConds[*it].getQP()->EvalS(p->easyConds[*it].getOpTree(), qResult,
OPEN);
if (((MBool*)qResult.addr)->IsDefined() &&
((MBool*)qResult.addr)->IsOrdered()) {
CcBool *cctrue = new CcBool(true, true);
((MBool*)qResult.addr)->At(*cctrue, mbool);
cctrue->DeleteIfAllowed();
if (mbool.IsEmpty()) {
return false;
}
else {
if (interResult.IsEmpty()) { // no intermediate result existing
mbool.DefTime(interResult);
}
else { // compute intersection with previous result
mbool.DefTime(tempPer);
interResult.Intersection(tempPer, interResult);
}
if (interResult.IsEmpty()) {
// cout << "empty intersection result after cond #" << *it << endl;
return false;
}
// cout << "intersection after easy cond #" << *it << ": "
// << interResult << endl;
}
}
else if (((CcBool*)qResult.addr)->IsDefined()) {
if (!((CcBool*)qResult.addr)->GetValue()) {
// cout << "CcBool is defined and false" << endl;
return false;
}
}
else {
cout << "invalid result type for condition #" << *it << endl;
return false;
}
}
return true;
}
/*
\subsection{Function ~copyPtrFromAttr~}
Used for indextmatches2.
*/
bool Condition::copyPtrFromAttr(const int pos, Attribute *attr) {
if (pos < 0 || pos >= (int)pointers.size()) {
return false;
}
pointers[pos]->CopyFrom(attr);
return true;
}
/*
\subsection{Function ~copyAndRestrictPtr~}
Used for indextmatches2.
*/
void Condition::copyAndRestrictPtr(const int pos, Tuple *tuple,
const ListExpr ttype, const int key, const Periods& per) {
string attrtype = nl->ToString(nl->Second(nl->Nth(key,
nl->Second(ttype))));
if (instantVars.find(getVar(pos)) == instantVars.end()) { // interval variable
if (attrtype == "mbool") {
((MBool*)tuple->GetAttribute(key - 1))->AtPeriods(per,
*((MBool*)pointers[pos]));
}
else if (attrtype == "mint") {
((MInt*)tuple->GetAttribute(key - 1))->AtPeriods(per,
*((MInt*)pointers[pos]));
}
else if (attrtype == "mlabel") {
((MLabel*)tuple->GetAttribute(key - 1))->AtPeriods(per,
*((MLabel*)pointers[pos]));
}
else if (attrtype == "mlabels") {
((MLabels*)tuple->GetAttribute(key - 1))->AtPeriods(per,
*((MLabels*)pointers[pos]));
}
else if (attrtype == "mplace") {
MPlace mp(true);
Place::base value;
Region tmp(true);
std::string type;
Word geo;
((MPlace*)tuple->GetAttribute(key - 1))->AtPeriods(per, mp);
for (int i = 0; i < mp.GetNoComponents(); i++) {
mp.GetValue(i, value);
if (value.second > 0) {
Tools::getGeoFromORel("Places", value.second, false, geo, type);
if (type == "point") {
tmp.Union(*((Point*)geo.addr), (*((Region*)pointers[pos])));
}
else if (type == "line") {
tmp.Union(*((Line*)geo.addr), (*((Region*)pointers[pos])));
}
else if (type == "region") {
tmp.Union(*((Region*)geo.addr), (*((Region*)pointers[pos])));
}
else {
cout << "ERROR: type is " << type << endl; // cannot occur
}
}
}
}
else if (attrtype == "mplaces") {
((MPlaces*)tuple->GetAttribute(key - 1))->AtPeriods(per,
*((MPlaces*)pointers[pos]));
}
else if (attrtype == "mpoint") {
((temporalalgebra::MPoint*)tuple->GetAttribute(key - 1))->AtPeriods(per,
*((temporalalgebra::MPoint*)pointers[pos]));
}
else if (attrtype == "mreal") {
((temporalalgebra::MReal*)tuple->GetAttribute(key - 1))->AtPeriods(per,
*((temporalalgebra::MReal*)pointers[pos]));
}
else if (attrtype == "mregion") {
((temporalalgebra::MRegion*)tuple->GetAttribute(key - 1))->AtPeriods(&per,
(temporalalgebra::MRegion*)pointers[pos]);
}
}
else { // variable refers to an instant; delete old pointer
Instant inst;
per.Minimum(inst);
getConstValue(tuple->GetAttribute(key - 1), attrtype, inst, pointers[pos]);
}
}
/*
\subsection{Function ~setPtrToTimeValue~}
Used for indextmatches2.
*/
void Condition::setPtrToTimeValue(const int pos, const Periods& per) {
SecInterval iv(true);
Instant inst(datetime::instanttype);
if (!per.IsDefined()) {
clearTimePtr(pos);
return;
}
if (per.IsEmpty()) {
clearTimePtr(pos);
return;
}
switch (getKey(pos)) {
case 2: { // time
clearTimePtr(pos);
setTimePtr(pos, per);
break;
}
case 3: { // start
per.Minimum(inst);
setStartEndPtr(pos, inst);
break;
}
case 4: { // end
per.Maximum(inst);
setStartEndPtr(pos, inst);
break;
}
case 5: { // leftclosed
Interval<Instant> iv(true);
per.Get(0, iv);
setLeftRightclosedPtr(pos, iv.lc);
break;
}
case 6: { // rightclosed
Interval<Instant> iv(true);
per.Get(per.GetNoComponents() - 1, iv);
setLeftRightclosedPtr(pos, iv.rc);
break;
}
default: {
cout << "ERROR: key " << getKey(pos) << " is invalid" << endl;
}
}
}
/*
\subsection{Function ~condsMatch~}
Used for indextmatches2.
*/
bool TMatchIndexLI::condsMatch(Tuple *t, const IndexMatchInfo2& imi) {
if (!p->hasConds()) {
return true;
}
Word qResult;
vector<Condition> *conds = p->getConds();
Periods bindPer(true), interResult(true), tempPer(true);
interResult.Clear();
MBool mbool(true);
for (unsigned int i = 0; i < conds->size(); i++) {
// cout << "evaluate cond " << i << " % " << conds->at(i).getText() << endl;
// conds->at(i).evaluate(t, imi);
for (int j = 0; j < conds->at(i).getVarKeysSize(); j++) {
int elem = p->getElemFromVar(conds->at(i).getVar(j));
if (!imi.getBinding(elem, bindPer)) {
cout << "ERROR, binding for elem " << elem << " does not exist" << endl;
return false;
}
int key = conds->at(i).getKey(j);
// cout << conds->at(i).getVar(j) << " $ " << key << " $ "
// << elem << " $ " << iv << endl;
if (key > 99) { // reference to attribute, e.g., X.Pos
if (!t) {
cout << "tuple not found" << endl;
return false;
}
if (Tools::isMovingAttr(ttList, key - 99)) {
// cout << "restrict ptr to " << bindPer << endl;
conds->at(i).copyAndRestrictPtr(j, t, ttList, key - 99, bindPer);
}
else { // constant attribute type
if (!conds->at(i).copyPtrFromAttr(j, t->GetAttribute(key - 100))) {
cout << "ERROR: attribute " << key - 100 << " not copied" << endl;
return false;
}
}
}
else { // X.time, X.start, X.end, X.leftclosed, X.rightclosed
conds->at(i).setPtrToTimeValue(j, bindPer);
}
}
conds->at(i).getQP()->EvalS(conds->at(i).getOpTree(), qResult, OPEN);
if (((MBool*)qResult.addr)->IsDefined() &&
((MBool*)qResult.addr)->IsOrdered()) {
CcBool *cctrue = new CcBool(true, true);
((MBool*)qResult.addr)->At(*cctrue, mbool);
cctrue->DeleteIfAllowed();
if (interResult.IsEmpty()) { // no intermediate result existing
mbool.DefTime(interResult);
}
else { // compute intersection with previous result
mbool.DefTime(tempPer);
interResult.Intersection(tempPer, interResult);
}
if (interResult.IsEmpty()) {
// cout << "empty intersection result after cond #" << i << endl;
return false;
}
// cout << "intersection after cond #" << i << ": " << interResult << endl;
}
else if (((CcBool*)qResult.addr)->IsDefined()) {
if (!((CcBool*)qResult.addr)->GetValue()) {
// cout << "CcBool is defined and false" << endl;
return false;
}
}
else {
cout << "invalid result type for condition #" << i << endl;
return false;
}
}
return true;
}
/*
\subsection{Function ~atomMatch2~}
*/
bool TMatchIndexLI::atomMatch2(const int state, std::pair<int, int> trans) {
// cout << "atomMatch(" << state << ", " << trans.first << ", "
// << trans.second << ") called" << endl;
PatElem atom;
set<string> ivs;
atom.getI(ivs);
SecInterval iv;
vector<TupleId> toRemove;
p->getElem(trans.first, atom);
bool transition = false;
IndexMatchInfo2 *imiPtr = 0;
Periods *per = 0;
// if (atom.isRelevantForTupleIndex()) {
if (indexResult2[trans.first] == 0) { // no index result found yet
int noResults;
storeIndexResult(trans.first, -1, false, noResults);
}
TupleId id = indexResult2[trans.first][0]->succ; // id of first index result
Instant minInst(datetime::instanttype);
minInst.ToMaximum();
while (id > 0) {
bool totalMatch = false;
per = indexResult2[trans.first][id]->per; // retrive periods from index
if (active[id]) { // process only active tuples
unsigned int numOfIMIs = (matchInfo2[state][id] != 0 ?
matchInfo2[state][id]->imis.size() : 0);
for (unsigned int i = 0; i < numOfIMIs; i++) {
imiPtr = &matchInfo2[state][id]->imis[i];
if (imiPtr->checkPeriods(per)) {
Tuple *t = rel->GetTuple(id, false);
IndexMatchInfo2 newIMI(imiPtr, per);
bool match = geoMatch(trans.first, t, per) &&
easyCondsMatch(trans.first, t, per);
if (match) {
transition = true;
totalMatch = p->isFinalState(trans.second);
// if (p->hasConds()) {
extendBinding2(per, p->getElemFromAtom(trans.first), totalMatch,
newIMI);
if (totalMatch && p->hasConds()) {
totalMatch = condsMatch(t, newIMI);
}
// }
if (totalMatch) {
matches.push_back(id); // complete match
// cout << "MATCH for id " << id << endl;
toRemove.push_back(id);
// cout << id << " removed (wild match) " << activeTuples
// << " active tuples" << endl;
i = numOfIMIs; // stop processing this tuple id
active[id] = false;
}
else if (!newIMI.exhausted((*firstEnd)[id])) { // continue
newMatchInfo2[trans.second][id]->imis.push_back(newIMI);
// cout << "Pushed back imi for id " << id << ", range="
// << (newIMI.range ? "TRUE" : "FALSE") << endl;
}
if (newIMI.inst < minInst) {
minInst = newIMI.inst;
}
}
else {
if (canBeDeactivated2(id, state, trans.first)) {
// cout << "*Deactivate id " << id << endl;
toRemove.push_back(id);
}
}
t->DeleteIfAllowed();
}
}
}
TupleId oldId = id;
id = indexResult2[trans.first][id]->succ;
if (canBeDeactivated2(oldId, state, trans.first)) {
// cout << "#### deactivate " << oldId << endl;
toRemove.push_back(oldId);
}
remove(toRemove, false);
}
if (minInst.millisecondsToNull() > (*firstEnd)[0] && !minInst.IsMaximum()) {
(*firstEnd)[0] = minInst.millisecondsToNull();
} // set global limit to minimum of index results
// }
// else { // consider all existing imi instances
// TupleId id = matchInfo2[state][0]->succ; // first active tuple id
// while (id > 0) {
// // cout << ": " << matchInfo[state][id]->imis.size()
// // << " IMIs, state=" << state << ", id=" << id << endl;
// unsigned int numOfIMIs = (matchInfo2[state][id] != 0 ?
// matchInfo2[state][id]->imis.size() : 0);
// unsigned int i = 0;
// while (active[id] && i < numOfIMIs) {
// bool totalMatch = false;
// imiPtr = &(matchInfo2[state][id]->imis[i]);
// Tuple *t = rel->GetTuple(id, false);
// // TODO: check symbolic time specs and easy conditions
// // TMatch tmatch(p, t, ttList, attrNo, relevantAttrs, valueNo);
// bool match = true;
// // match = tmatch.valuesMatch(imiPtr->next, trans.first, false) &&
// // Tools::timesMatch(iv, ivs) &&
// // tmatch.easyCondsMatch(imiPtr->next, trans.first);
// if (match) {
// transition = true;
// IndexMatchInfo2 newIMI(imiPtr);
// totalMatch = p->isFinalState(trans.second);
// if (p->hasConds()) {
// extendBinding2(per, p->getElemFromAtom(trans.first), totalMatch,
// newIMI);
// if (totalMatch && p->hasConds()) {
// totalMatch = condsMatch(t, newIMI);
// }
// }
// if (totalMatch) {
// matches.push_back(id); // complete match
// toRemove.push_back(id);
// // cout << id << " removed (wild match) " << activeTuples
// // << " active tuples" << endl;
// i = numOfIMIs; // stop processing this tuple id
// active[id] = false;
// }
// else if (!newIMI.exhausted((*firstEnd)[id])) { // continue
// newMatchInfo2[trans.second][id]->imis.push_back(newIMI);
// }
// }
// else {
// if (canBeDeactivated2(id, state, trans.first)) {
// // cout << "*Deactivate id " << id << endl;
// toRemove.push_back(id);
// }
// }
// t->DeleteIfAllowed();
// i++;
// }
// if (active[id]) {
// if (!hasIdIMIs(id, false, state)) { // no IMIs for id and state
// if (!hasIdIMIs(id, false)) { // no IMIs at all for id
// toRemove.push_back(id);
// // cout << id << " removed (wild mismatch) " << activeTuples
// // << " active tuples" << endl;
// }
// }
// }
// id = matchInfo2[state][id]->succ;
// remove(toRemove, false);
// }
// }
// cout << "........ return " << (transition ? "TRUE" : "FALSE") << endl;
return transition;
}
/*
\subsection{Function ~applyNFA~}
*/
void TMatchIndexLI::applyNFA(const bool mainAttr,
const bool rewrite /* = false */) {
set<int> states, newStates;
states.insert(0);
set<int>::reverse_iterator is;
map<int, int>::reverse_iterator im;
if (mainAttr) {
while ((activeTuples > 0) && !states.empty()) {
// cout << "WHILE loop: activeTuples=" << activeTuples << "; "
// << matches.size() - 1 << " matches" << endl;
for (is = states.rbegin(); is != states.rend(); is++) {
map<int, int> trans = p->getTransitions(*is);
for (im = trans.rbegin(); im != trans.rend() && activeTuples > 0; im++){
if (atomMatch(*is, *im, rewrite)) {
newStates.insert(im->second);
}
}
}
states.clear();
states.swap(newStates);
// cout << "Current states: ";
clearMatchInfo();
unitCtr++;
// for (set<int>::iterator it = states.begin(); it != states.end(); it++){
// cout << *it << ",";
// }
// cout << "unitCtr set to " << unitCtr << "; activeTuples: "
// << activeTuples << endl;
}
}
else {
while ((activeTuples > 0) && !states.empty()) {
// cout << "WHILE loop: activeTuples=" << activeTuples << "; "
// << matches.size() - 1 << " matches" << endl;
for (is = states.rbegin(); is != states.rend(); is++) {
map<int, int> trans = p->getTransitions(*is);
for (im = trans.rbegin(); im != trans.rend() && activeTuples > 0; im++){
if (atomMatch2(*is, *im)) {
newStates.insert(im->second);
}
}
}
states.clear();
states.swap(newStates);
// cout << "Current states: ";
clearMatchInfo2();
unitCtr++;
// for (set<int>::iterator it = states.begin(); it != states.end(); it++){
// cout << *it << ",";
// }
// cout << "unitCtr set to " << unitCtr << "; activeTuples: "
// << activeTuples << endl;
}
}
}
/*
\subsection{Function ~initialize~}
In the version with main attribute, index results are stored as sets of unit
positions. Otherwise, we apply periods.
*/
bool TMatchIndexLI::initialize(const bool mainAttr,
const bool rewrite /* = false */) {
if (!tiCompatibleToRel()) {
cout << "Error: tuple index is not compatible with relation" << endl;
return false;
}
vector<map<int, int> > simpleNFA;
p->simplifyNFA(simpleNFA);
set<pair<set<int>, int> > paths;
p->findNFApaths(simpleNFA, paths);
set<int> cruElems;
p->getCrucialElems(paths, crucialAtoms);
for (int state = 0; state < p->getNFAsize(); state++) {
if (p->nfaHasLoop(state)) {
loopStates.insert(state);
}
}
if (mainAttr) {
indexResult = new IndexRetrieval**[p->getSize()];
memset(indexResult, 0, p->getSize() * sizeof(void*));
trajSize = new int[rel->GetNoTuples() + 1];
memset(trajSize, 0, (rel->GetNoTuples() + 1) * sizeof(int));
matchRecord = new DoubleUnitSet**[p->getSize()];
memset(matchRecord, 0, p->getSize() * sizeof(void*));
for (int i = 0; i < p->getSize(); i++) {
matchRecord[i] = new DoubleUnitSet*[rel->GetNoTuples() + 1];
memset(matchRecord[i], 0, (rel->GetNoTuples() + 1) * sizeof(void*));
}
if (p->hasConds()) {
condRecord = new DoubleBindingSet*[rel->GetNoTuples() + 1];
memset(condRecord, 0, (rel->GetNoTuples() + 1) * sizeof(void*));
}
}
else {
indexResult2 = new IndexRetrieval2**[p->getSize()];
memset(indexResult2, 0, p->getSize() * sizeof(void*));
// firstEnd = new Instant*[rel->GetNoTuples() + 1];
// memset(firstEnd, 0, (rel->GetNoTuples() + 1) * sizeof(void*));
// for (int id = 1; id <= rel->GetNoTuples(); id++) {
// firstEnd[id] = new Instant(getFirstEnd(id));
// }
firstEnd = &(ti2->firstEnd);
(*firstEnd)[0] = 0;
}
active = new bool[rel->GetNoTuples() + 1];
memset(active, 1, (rel->GetNoTuples() + 1) * sizeof(bool));
if (rewrite) {
NewPair<TupleId, IndexMatchInfo> firstEntry(1, IndexMatchInfo());
matchesR.push_back(firstEntry);
}
else {
matches.push_back(1);
}
int minResultPos = -1;
int minResults(INT_MAX), curResults(0), lastCrucialRelevant(-1);
PatElem atom;
set<int> relevantForTupleIndex;
for (int i = 0; i < p->getSize(); i++) {
p->getElem(i, atom);
if (atom.isRelevantForTupleIndex()) {
relevantForTupleIndex.insert(i);
}
}
for (set<int>::iterator it = crucialAtoms.begin(); it != crucialAtoms.end();
it++) {
storeIndexResult(*it, lastCrucialRelevant, mainAttr, curResults);
if (curResults < minResults) {
minResults = curResults;
minResultPos = *it;
}
if (relevantForTupleIndex.find(*it) != relevantForTupleIndex.end()) {//found
lastCrucialRelevant = *it;
}
else {
lastCrucialRelevant = -1;
}
// int successor = indexResult[*it][0]->succ;
// int noResults = 0;
// while (successor != 0) {
// noResults++;
// cout << "[" << successor << ": (";
// for (set<int>::iterator t = indexResult[*it][successor]->units.begin();
// t != indexResult[*it][successor]->units.end(); t++) {
// cout << *t << " ";
// }
// cout << ")] ";
// successor = indexResult[*it][successor]->succ;
// }
// cout << endl << endl;
}
if (minResultPos > -1) { // atom with smallest number of index result tuples
int removed = 0;
for (set<int>::iterator it = crucialAtoms.begin(); it != crucialAtoms.end();
it++) {
PatElem atom;
p->getElem(*it, atom);
if (*it != minResultPos && atom.isRelevantForTupleIndex()) {
TupleId oldId = 0;
if (mainAttr) {
TupleId id = indexResult[*it][0]->succ;
while (id != 0) {
if (indexResult[minResultPos][id] == 0) {
oldId = id;
id = indexResult[*it][id]->succ;
removeIdFromIndexResult(oldId, mainAttr);
active[oldId] = false;
removed++;
}
else {
id = indexResult[*it][id]->succ;
}
}
}
else {
TupleId id = indexResult2[*it][0]->succ;
while (id != 0) {
if (indexResult2[minResultPos][id] == 0) {
oldId = id;
id = indexResult2[*it][id]->succ;
removeIdFromIndexResult(oldId, mainAttr);
active[oldId] = false;
removed++;
}
else {
id = indexResult2[*it][id]->succ;
}
}
}
}
}
// cout << removed << " tuples removed due to crucial atom "
// << minResultPos << endl;
}
Tuple *firstTuple = rel->GetTuple(1, false);
if (!p->initEasyCondOpTrees(mainAttr, firstTuple, ttList)) {
return false;
}
if (!p->initCondOpTrees(firstTuple, ttList, mainAttr)) {
return false;
}
firstTuple->DeleteIfAllowed();
initMatchInfo(mainAttr);
applyNFA(mainAttr, rewrite);
return true;
}
/*
\subsection{Function ~nextTuple~}
*/
Tuple* TMatchIndexLI::nextTuple() {
if (matches[0] == 0 || matches[0] >= matches.size() || matches.size() <= 1) {
return 0;
}
// cout << "size: " << matches.size() << "; elem 0: " << matches[0] << " : "
// << matches[matches[0]] << endl;
Tuple *result = rel->GetTuple(matches[matches[0]], false);
matches[0]++;
return result;
}
/*
\section{Functions for class ~ClassifyLI~}
\subsection{Destructor}
*/
ClassifyLI::~ClassifyLI() {
if (classifyTT) {
delete classifyTT;
classifyTT = 0;
}
vector<Pattern*>::iterator it;
for (it = pats.begin(); it != pats.end(); it++) {
delete (*it);
}
pats.clear();
}
/*
\subsection{Function ~getTupleType~}
*/
TupleType* ClassifyLI::getTupleType() {
SecondoCatalog* sc = SecondoSystem::GetCatalog();
ListExpr resultTupleType = nl->TwoElemList(
nl->SymbolAtom(Tuple::BasicType()),
nl->TwoElemList(nl->TwoElemList(nl->SymbolAtom("Description"),
nl->SymbolAtom(FText::BasicType())),
nl->TwoElemList(nl->SymbolAtom("Trajectory"),
nl->SymbolAtom(MLabel::BasicType()))));
ListExpr numResultTupleType = sc->NumericType(resultTupleType);
return new TupleType(numResultTupleType);
}
/*
\subsection{Function ~nextResultText~}
This function is used for the operator ~classify~.
*/
FText* ClassifyLI::nextResultText() {
if (!pats.size()) {
return 0;
}
if (!matchingPats.empty()) {
set<int>::iterator it = matchingPats.begin();
FText* result = new FText(true, pats[*it]->getDescr());
matchingPats.erase(it);
return result;
}
return 0;
}
/*
\section{Functions for class ~Classifier~}
\subsection{List Representation}
The list representation of a classifier is
---- ((desc_1 pat_1) (desc_2 pat_2) ...)
----
\subsection{Constructors}
*/
Classifier::Classifier(const Classifier& src) {
charpos = src.charpos;
chars = src.chars;
delta = src.delta;
s2p = src.s2p;
defined = src.defined;
}
string Classifier::getDesc(int pos) {
int chpos = -1;
int chposnext = -1;
charpos.Get(pos * 2, chpos);
charpos.Get(pos * 2 + 1, chposnext);
string result = "";
char ch;
for (int i = chpos; i < chposnext; i++) {
chars.Get(i, ch);
result += ch;
}
return result;
}
string Classifier::getPatText(int pos) {
int chpos = -1;
int chposnext = -1;
charpos.Get(pos * 2 + 1, chpos);
charpos.Get(pos * 2 + 2, chposnext);
string result = "";
char ch;
for (int i = chpos; i < chposnext; i++) {
chars.Get(i, ch);
result += ch;
}
return result;
}
void Classifier::getStartStates(set<int> &startStates) {
startStates.clear();
int pat = 0;
startStates.insert(0);
for (int i = 1; i < s2p.Size(); i++) {
s2p.Get(i, pat);
if (pat < 0) {
startStates.insert(startStates.end(), - pat);
}
}
}
/*
\subsection{Function Describing the Signature of the Type Constructor}
*/
ListExpr Classifier::Property() {
return (nl->TwoElemList(
nl->FiveElemList(nl->StringAtom("Signature"),
nl->StringAtom("Example Type List"),
nl->StringAtom("List Rep"),
nl->StringAtom("Example List"),
nl->StringAtom("Remarks")),
nl->FiveElemList(nl->StringAtom("->" + Kind::DATA() ),
nl->StringAtom(Classifier::BasicType()),
nl->StringAtom("((d1:text, p1:text) ((d2:text) (p2:text)) ...)"),
nl->StringAtom("((home (_ at_home) *))"),
nl->StringAtom("a collection of pairs (description, pattern)"))));
}
/*
\subsection{~In~ Function}
*/
Word Classifier::In(const ListExpr typeInfo, const ListExpr instance,
const int errorPos, ListExpr& errorInfo, bool& correct) {
Word result = SetWord(Address(0));
if (nl->IsEmpty(instance)) {
cmsg.inFunError("Empty list");
return SetWord(Address(0));
}
NList list(instance);
Classifier* c = new Classifier(0);
Pattern* p = 0;
map<int, int> state2Pat; // maps start and final states to their pattern id
c->SetDefined(true);
c->appendCharPos(0);
vector<Pattern*> patterns;
while (!list.isEmpty()) {
if ((list.length() % 2 == 0) && !list.isAtom() && list.first().isAtom() &&
list.first().isText() && list.second().isAtom() && list.second().isText()){
for (unsigned int i = 0; i < list.first().str().length(); i++) { //descr
c->appendChar(list.first().str()[i]);
}
c->appendCharPos(c->getCharSize());
for (unsigned int i = 0; i < list.second().str().length(); i++) {//pattern
c->appendChar(list.second().str()[i]);
}
c->appendCharPos(c->getCharSize());
p = Pattern::getPattern(list.second().str(), true);
patterns.push_back(p);
}
else {
cmsg.inFunError("Expecting a list of an even number of text atoms!");
delete c;
return SetWord(Address(0));
}
list.rest();
list.rest();
}
vector<map<int, int> > nfa;
set<int> finalStates;
c->buildMultiNFA(patterns, nfa, finalStates, state2Pat);
for (unsigned int i = 0; i < patterns.size(); i++) {
delete patterns[i];
}
c->setPersistentNFA(nfa, finalStates, state2Pat);
result.addr = c;
return result;
}
/*
\subsection{~Out~ Function}
*/
ListExpr Classifier::Out(ListExpr typeInfo, Word value) {
Classifier* c = static_cast<Classifier*>(value.addr);
if (!c->IsDefined()) {
return (NList(Symbol::UNDEFINED())).listExpr();
}
if (c->IsEmpty()) {
return (NList()).listExpr();
}
else {
NList list(c->getDesc(0), true, true);
list.append(NList(c->getPatText(0), true, true));
for (int i = 1; i < (c->getCharPosSize() / 2); i++) {
list.append(NList(c->getDesc(i), true, true));
list.append(NList(c->getPatText(i), true, true));
}
return list.listExpr();
}
}
/*
\subsection{Kind Checking Function}
This function checks whether the type constructor is applied correctly. Since
type constructor ~classifier~ does not have arguments, this is trivial.
*/
bool Classifier::KindCheck(ListExpr type, ListExpr& errorInfo) {
return (nl->IsEqual(type, Classifier::BasicType()));
}
/*
\subsection{~Create~-function}
*/
Word Classifier::Create(const ListExpr typeInfo) {
Classifier* c = new Classifier(0);
return (SetWord(c));
}
/*
\subsection{~Delete~-function}
*/
void Classifier::Delete(const ListExpr typeInfo, Word& w) {
Classifier* c = (Classifier*)w.addr;
delete c;
}
/*
\subsection{~Open~-function}
*/
bool Classifier::Open(SmiRecord& valueRecord, size_t& offset,
const ListExpr typeInfo, Word& value) {
Classifier *c = (Classifier*)Attribute::Open(valueRecord, offset, typeInfo);
value.setAddr(c);
return true;
}
/*
\subsection{~Save~-function}
*/
bool Classifier::Save(SmiRecord& valueRecord, size_t& offset,
const ListExpr typeInfo, Word& value) {
Classifier *c = (Classifier*)value.addr;
Attribute::Save(valueRecord, offset, typeInfo, c);
return true;
}
/*
\subsection{~Close~-function}
*/
void Classifier::Close(const ListExpr typeInfo, Word& w) {
Classifier* c = (Classifier*)w.addr;
delete c;
}
/*
\subsection{~Clone~-function}
*/
Word Classifier::Clone(const ListExpr typeInfo, const Word& w) {
return SetWord(((Classifier*)w.addr)->Clone());
}
/*
\subsection{~SizeOf~-function}
*/
int Classifier::SizeOfObj() {
return sizeof(Classifier);
}
/*
\subsection{~Cast~-function}
*/
void* Classifier::Cast(void* addr) {
return (new (addr)Classifier);
}
/*
\subsection{Compare}
*/
int Classifier::Compare(const Attribute* arg) const {
if (getCharPosSize() > ((Classifier*)arg)->getCharPosSize()) {
return 1;
}
else if (getCharPosSize() < ((Classifier*)arg)->getCharPosSize()) {
return -1;
}
else {
if (getCharSize() > ((Classifier*)arg)->getCharPosSize()) {
return 1;
}
else if (getCharSize() < ((Classifier*)arg)->getCharPosSize()) {
return -1;
}
else {
return 0;
}
}
}
/*
\subsection{HashValue}
*/
size_t Classifier::HashValue() const {
return getCharPosSize() * getCharSize();
}
/*
\subsection{Adjacent}
Not implemented.
*/
bool Classifier::Adjacent(const Attribute* arg) const {
return 0;
}
/*
\subsection{Clone}
Returns a new created element labels (clone) which is a copy of ~this~.
*/
Classifier* Classifier::Clone() const {
assert(defined);
Classifier *c = new Classifier(*this);
return c;
}
/*
\subsection{CopyFrom}
*/
void Classifier::CopyFrom(const Attribute* right) {
*this = *((Classifier*)right);
}
/*
\subsection{Sizeof}
*/
size_t Classifier::Sizeof() const {
return sizeof(*this);
}
/*
\subsection{Creation of the Type Constructor Instance}
*/
TypeConstructor classifierTC(
Classifier::BasicType(), // name of the type in SECONDO
Classifier::Property, // property function describing signature
Classifier::Out, Classifier::In, // Out and In functions
0, 0, // SaveToList, RestoreFromList functions
Classifier::Create, Classifier::Delete, // object creation and deletion
0, 0, // object open, save
Classifier::Close, Classifier::Clone,// close, and clone
0, // cast function
Classifier::SizeOfObj, // sizeof function
Classifier::KindCheck ); // kind checking function
/*
\subsection{Function ~buildMultiNFA~}
*/
void Classifier::buildMultiNFA(vector<Pattern*> patterns,
vector<map<int, int> > &nfa, set<int> &finalStates, map<int, int> &state2Pat) {
map<int, set<int> >::iterator it;
unsigned int elemShift = 0;
for (unsigned int i = 0; i < patterns.size(); i++) {
unsigned int stateShift = nfa.size();
IntNfa* intNfa = 0;
state2Pat[stateShift] = -i;
if (parsePatternRegEx(patterns[i]->getRegEx().c_str(), &intNfa) != 0) {
cout << "error while parsing " << patterns[i]->getRegEx() << endl;
return;
}
intNfa->nfa.makeDeterministic();
intNfa->nfa.minimize();
intNfa->nfa.bringStartStateToTop();
map<int, set<int> >::iterator it;
for (unsigned int j = 0; j < intNfa->nfa.numOfStates(); j++) {
map<int, set<int> > trans = intNfa->nfa.getState(j).getTransitions();
map<int, int> newTrans;
for (it = trans.begin(); it != trans.end(); it++) {
newTrans[it->first + elemShift] = *(it->second.begin()) + stateShift;
}
nfa.push_back(newTrans);
if (intNfa->nfa.isFinalState(j)) {
finalStates.insert(j + stateShift);
state2Pat[j + stateShift] = i;
}
else if (j > 0) {
state2Pat[j + stateShift] = INT_MAX;
}
}
elemShift += patterns[i]->getSize();
delete intNfa;
}
}
/*
\subsection{Constructor for class ~IndexMatchesLI~}
*/
IndexMatchesLI::IndexMatchesLI(Relation *_rel, InvertedFile *inv,
R_Tree<1, NewPair<TupleId, UnitPos> > *rt, int _attrNr, Pattern *_p,
DataType _t)
: IndexMatchSuper(_rel, _p, _attrNr, _t), invFile(inv), rtree(rt) {
unitCtr = 0;
if (p) {
if (rel->GetNoTuples() > 0) {
initialize();
applyNFA();
p->deleteEasyCondOpTrees();
p->deleteCondOpTrees();
}
}
}
/*
\subsection{Destructor}
*/
IndexMatchesLI::~IndexMatchesLI() {
rel = 0;
if (p) {
delete p;
}
}
/*
\subsection{Function ~nextResultTuple~}
*/
Tuple* IndexMatchesLI::nextTuple() {
if (!matches.empty()) {
TupleId result = matches.back();
matches.pop_back();
return rel->GetTuple(result, false);
}
return 0;
}
/*
\subsection{Function ~applyNFA~}
*/
void IndexMatchesLI::applyNFA() {
set<int> states, newStates;
PatElem elem;
states.insert(0);
set<int>::reverse_iterator is;
map<int, int>::reverse_iterator im;
while ((activeTuples > 0) && !states.empty()) {
unitCtr++;
// cout << "WHILE loop: activeTuples=" << activeTuples << "; "
// << matches.size() << " matches; states:";
for (is = states.rbegin(); is != states.rend(); is++) {
map<int, int> trans = p->getTransitions(*is);
for (im = trans.rbegin(); im != trans.rend() && activeTuples > 0; im++) {
p->getElem(im->first, elem);
if (elem.getW() == NO) { // no wildcard
// cout << "call simpleMatch for transition " << *is << " --"
// << im->first << "--> " << im->second << endl;
if (simpleMatch(im->first, *is, im->second)) {
newStates.insert(im->second);
}
}
else { // + or *
// cout << "call wildcardMatch for transition " << *is << " --"
// << im->first << "--> " << im->second << endl;
if (wildcardMatch(*is, *im)) {
newStates.insert(im->second);
}
}
}
}
states.clear();
states.swap(newStates);
clearMatchInfo();
}
}
/*
\subsection{Function ~initOpTrees~}
Necessary for the operator ~rewrite~
*/
bool Assign::initOpTrees() {
if (treesOk && opTree[0].second) {
return true;
}
for (int i = 0; i <= 9; i++) {
if (pointers[i].size() > 0) { // pointers already initialized
return true;
}
}
if (!occurs() && (!hasValue() || !hasTime())) {
cout << "not enough data for variable " << var << endl;
return false;
}
string q(""), part, toReplace("");
pair<string, Attribute*> strAttr;
for (int i = 0; i <= 9; i++) {
if (!text[i].empty()) {
q = "query " + text[i];
for (unsigned int j = 0; j < right[i].size(); j++) { // loop through keys
if (right[i][j].second == 2) { // interval instead of periods
deleteIfAllowed(strAttr.second);
strAttr.second = new SecInterval(true);
strAttr.first = "[const interval pointer "
+ nl->ToString(listutils::getPtrList(strAttr.second)) + "]";
}
else {
strAttr = Pattern::getPointer(right[i][j].second, true);
}
pointers[i].push_back(strAttr.second);
toReplace = right[i][j].first
+ Condition::getType(right[i][j].second, right[i][j].first);
q.replace(q.find(toReplace), toReplace.length(), strAttr.first);
}
opTree[i] = Tools::processQueryStr(q, i);
if (!opTree[i].first) {
cout << "pointer not initialized" << endl;
return false;
}
if (!opTree[i].second) {
cout << "opTree not initialized" << endl;
return false;
}
}
}
treesOk = true;
return true;
}
void Assign::clear() {
resultPos = -1;
for (int i = 0; i < 6; i++) {
text[i].clear();
right[i].clear();
}
right[6].clear();
deleteOpTrees();
}
void Assign::deleteOpTrees() {
if (treesOk) {
for (int i = 0; i < 6; i++) {
if (opTree[i].first) {
opTree[i].first->Destroy(opTree[i].second, true);
delete opTree[i].first;
}
for (unsigned int j = 0; j < pointers[i].size(); j++) {
if (pointers[i][j]) {
deleteIfAllowed(pointers[i][j]);
pointers[i][j] = 0;
}
}
pointers[i].clear();
}
}
treesOk = false;
}
void Condition::deleteOpTree() {
if (treeOk) {
if (opTree.first) {
// cout << "destroy second" << endl;
opTree.first->Destroy(opTree.second, true);
// cout << "delete first" << endl;
delete opTree.first;
for (unsigned int i = 0; i < pointers.size(); i++) {
// cout << "delete ptr " << i;
deleteIfAllowed(pointers[i]);
// cout << " ...........ok" << endl;
}
}
treeOk = false;
}
}
/*
\subsection{Function ~initAssignOpTrees~}
Invoked by the value mapping of the operator ~rewrite~.
*/
bool Pattern::initAssignOpTrees() {
for (unsigned int i = 0; i < assigns.size(); i++) {
if (!assigns[i].initOpTrees()) {
cout << "Error at assignment #" << i << endl;
return false;
}
}
return true;
}
void Pattern::deleteAssignOpTrees(bool deleteConds) {
for (unsigned int i = 0; i < assigns.size(); i++) {
assigns[i].deleteOpTrees();
}
if (deleteConds) {
for (unsigned int i = 0; i < conds.size(); i++) {
conds[i].deleteOpTree();
}
}
}
/*
\subsection{Function ~deleteAtomValues~}
*/
void Pattern::deleteAtomValues(vector<pair<int, string> > &relevantAttrs) {
for (int i = 0; i < getSize(); i++) {
elems[i].deleteValues(relevantAttrs);
}
}
bool Pattern::startsWithAsterisk() const {
if (getSize() == 0) {
return false;
}
PatElem atom;
getElem(0, atom);
if (atom.getW() == STAR) {
if (!regEx.empty()) {
return (regEx[0] != '(');
}
}
return false;
}
bool Pattern::startsWithPlus() const {
if (getSize() == 0) {
return false;
}
PatElem atom;
getElem(0, atom);
if (atom.getW() == PLUS) {
if (!regEx.empty()) {
return (regEx[0] != '(');
}
}
return false;
}
bool Pattern::nfaHasLoop(const int state) const {
if ((int)(nfa.size()) <= state) {
return false;
}
for (map<int, int>::const_iterator it = nfa[state].begin();
it != nfa[state].end(); it++) {
if (it->second == state) {
return true;
}
}
return false;
}
bool PatElem::hasValuesWithContent() const {
for (unsigned int i = 0; i < values.size(); i++) {
if (values[i].first.addr != 0) {
return true;
}
}
return false;
}
bool PatElem::isRelevantForTupleIndex() const {
if (hasRealInterval()) {
return true;
}
if (!hasValuesWithContent()) {
return false;
}
for (int i = 0; i < getNoValues(); i++) {
if (values[i].second != DISJOINT) {
return true;
}
}
return false;
}
void PatElem::getInterval(SecInterval& result) const {
if (!hasInterval()) {
result.SetDefined(false);
return;
}
result.SetDefined(true);
std::set<std::string> ivsAtom;
getI(ivsAtom);
SecInterval ivtmp1(true), ivtmp2(true);
std::set<std::string>::iterator it = ivsAtom.begin();
bool first = true;
while (it != ivsAtom.end()) {
Tools::stringToInterval(*it, ivtmp1);
if (ivtmp1.IsDefined()) {
if (first) {
ivtmp2 = ivtmp1;
first = false;
}
else {
ivtmp1.Intersection(ivtmp2, result);
ivtmp2 = result;
}
}
it++;
}
}
void PatElem::deleteValues(vector<pair<int, string> > &relevantAttrs) {
if (wc != NO) {
return;
}
for (unsigned int i = 0; i < values.size(); i++) {
Tools::deleteValue(values[i].first, relevantAttrs[i].second);
}
}
/*
\subsection{Constructor for class ~IndexClassifyLI~}
This constructor is used for the operator ~indexclassify~.
*/
IndexClassifyLI::IndexClassifyLI(Relation *rel, InvertedFile *inv,
R_Tree<1, NewPair<TupleId, UnitPos> > *rt, Word _classifier, int _attrNr,
DataType type) :
IndexMatchesLI::IndexMatchesLI(rel, inv, rt, _attrNr, 0, type),
classifyTT(0), c(0) {
if (rel->GetNoTuples() > 0) {
c = (Classifier*)_classifier.addr;
for (int i = 0; i < c->getNumOfP(); i++) { // check patterns
Pattern *p = Pattern::getPattern(c->getPatText(i), false);
bool ok = false;
if (p) {
switch (type) {
case MLABEL: {
ok = p->isValid("label");
break;
}
case MLABELS: {
ok = p->isValid("labels");
break;
}
case MPLACE: {
ok = p->isValid("place");
break;
}
case MPLACES: {
ok = p->isValid("places");
break;
}
}
delete p;
}
if (!ok) {
c = 0;
return;
}
}
}
classifyTT = ClassifyLI::getTupleType();
currentPat = 0;
}
/*
\subsection{Destructor for class ~IndexClassifyLI~}
*/
IndexClassifyLI::~IndexClassifyLI() {
if (classifyTT) {
classifyTT->DeleteIfAllowed();
classifyTT = 0;
}
}
/*
\subsection{Function ~retrieveValue~}
*/
void IndexMatchesLI::retrieveValue(vector<set<int> >& oldPart,
vector<set<int> >& newPart, SetRel rel, bool first, const string& label,
unsigned int ref /* = UINT_MAX */) {
InvertedFile::exactIterator* eit = 0;
TupleId id;
uint32_t wc, cc;
eit = invFile->getExactIterator(label, 16777216);
if ((mtype == MLABEL) || (mtype == MLABELS)) {
while (eit->next(id, wc, cc)) {
if (!deactivated[id]) {
if (first) { // ignore oldPart
newPart[id].insert(wc);
}
else {
if ((rel == STANDARD) || (rel == EQUAL)) { // intersect sets
set<int>::iterator it = oldPart[id].find(wc);
if (it != oldPart[id].end()) { // found in oldPart
newPart[id].insert(it, wc);
}
}
else { // SUPERSET or INTERSECT => unite sets
oldPart[id].insert(wc);
}
}
}
}
}
else { // ref is used
while (eit->next(id, wc, cc)) {
if (!deactivated[id]) {
if (ref == cc) { // cc represents the reference of the place
if (first) { // ignore oldPart
newPart[id].insert(wc);
}
else {
if ((rel == STANDARD) || (rel == EQUAL)) { // intersect sets
set<int>::iterator it = oldPart[id].find(wc);
if (it != oldPart[id].end()) {
newPart[id].insert(it, wc);
}
}
else { // SUPERSET or INTERSECT => unite sets
oldPart[id].insert(wc);
}
}
}
}
}
}
if (first || (rel == STANDARD) || (rel == EQUAL)) {
oldPart.swap(newPart);
}
// for (int i = 0; i < oldPart.size(); i++) {
// cout << oldPart[i].size() << " ";
// }
// cout << endl;
// for (int i = 0; i < newPart.size(); i++) {
// cout << newPart[i].size() << " ";
// }
// cout << endl;
delete eit;
}
/*
\subsection{Function ~retrieveTime~}
*/
void IndexMatchesLI::retrieveTime(vector<set<int> >& oldPart,
vector<set<int> >& newPart, const string& ivstr) {
bool init = false;
if (oldPart.empty()) {
oldPart.resize(rel->GetNoTuples() + 1);
newPart.resize(rel->GetNoTuples() + 1);
init = true;
}
R_TreeLeafEntry<1, NewPair<TupleId, UnitPos> > leaf;
double min[1], max[1];
SecInterval iv(true);
Tools::stringToInterval(ivstr, iv);
min[0] = iv.start.ToDouble();
max[0] = iv.end.ToDouble();
Rect1 rect1(true, min, max);
if (rtree->First(rect1, leaf)) {
if ((init || !oldPart[leaf.info.first].empty()) &&
!deactivated[leaf.info.first]) {
newPart[leaf.info.first].insert(newPart[leaf.info.first].end(),
leaf.info.second.pos);
}
while (rtree->Next(leaf)) {
if ((init || !oldPart[leaf.info.first].empty()) &&
!deactivated[leaf.info.first]) {
newPart[leaf.info.first].insert(newPart[leaf.info.first].end(),
leaf.info.second.pos);
}
}
}
newPart.swap(oldPart);
}
/*
\subsection{Function ~removeIdFromMatchInfo~}
*/
void IndexMatchesLI::removeIdFromMatchInfo(const TupleId id) {
bool removed = false;
for (int s = 0; s < p->getNFAsize(); s++) {
if (newMatchInfo[s] != 0) {
// cout << "Elem " << i << ", Tuple " << id << ":" << endl;
newMatchInfo[s][newMatchInfo[s][id]->pred]->succ =
newMatchInfo[s][id]->succ;
// cout << " succ of " << matchInfo[i][id].pred << " set to "
// << matchInfo[i][id].succ << endl;
newMatchInfo[s][newMatchInfo[s][id]->succ]->pred =
newMatchInfo[s][id]->pred;
// cout << " pred of " << matchInfo[i][id].succ << " set to "
// << matchInfo[i][id].pred << endl;
// (*newMatchInfoPtr)[s][id].imis.clear();
}
if (matchInfo[s] != 0) {
if (matchInfo[s][matchInfo[s][id]->pred]->succ == id) {
// cout << "Elem " << i << ", Tuple " << id << ":" << endl;
matchInfo[s][matchInfo[s][id]->pred]->succ = matchInfo[s][id]->succ;
// cout << " succ of " << matchInfo[i][id].pred << " set to "
// << matchInfo[i][id].succ << endl;
matchInfo[s][matchInfo[s][id]->succ]->pred = matchInfo[s][id]->pred;
removed = true;
// cout << " pred of " << matchInfo[i][id].succ << " set to "
// << matchInfo[i][id].pred << endl;
// (*matchInfoPtr)[s][id].imis.clear();
}
}
}
deactivated[id] = true;
activeTuples -= (removed ? 1 : 0);
}
/*
\subsection{Function ~storeIndexResult~}
*/
void IndexMatchesLI::storeIndexResult(const int e) {
if (indexResult[e] != 0) {
return;
}
PatElem elem;
p->getElem(e, elem);
if (!elem.hasIndexableContents()) {
return;
}
set<string> ivs, lbs, pls;
vector<set<int> > part, part2;
// vector<bool> time, time2;
// time.resize(mRel->GetNoTuples() + 1, true);
// time2.resize(mRel->GetNoTuples() + 1, true);
if (elem.getSetRel() != DISJOINT) {
if ((mtype == MLABEL) || (mtype == MLABELS)) {
elem.getL(lbs);
set<string>::iterator is = lbs.begin();
if (!lbs.empty()) {
part.resize(rel->GetNoTuples() + 1);
part2.resize(rel->GetNoTuples() + 1);
retrieveValue(part, part2, elem.getSetRel(), true, *is);
is++;
}
while (is != lbs.end()) {
retrieveValue(part, part2, elem.getSetRel(), false, *is);
is++;
}
}
else { // PLACE or PLACES
elem.getL(pls);
set<string>::iterator ip = pls.begin();
if (!pls.empty()) {
part.resize(rel->GetNoTuples() + 1);
part2.resize(rel->GetNoTuples() + 1);
retrieveValue(part, part2, elem.getSetRel(), true, *ip);
ip++;
}
while (ip != pls.end()) {
retrieveValue(part, part2, elem.getSetRel(), false, *ip);
ip++;
}
}
} // continue with time intervals
if (!part.empty() || (elem.getSetRel() == DISJOINT) || !elem.hasLabel()) {
elem.getI(ivs);
set<string>::iterator is = ivs.begin();
while (is != ivs.end()) {
if (Tools::isInterval(*is)) {
retrieveTime(part, part2, *is);
}
is++;
}
}
indexResult[e] = new IndexRetrieval*[rel->GetNoTuples() + 1];
memset(indexResult[e], 0, (rel->GetNoTuples() + 1)*sizeof(void*));
unsigned int pred = 0;
indexResult[e][0] = new IndexRetrieval(pred, 0);
for (unsigned int i = 1; i < part.size(); i++) { // collect results
if (!part[i].empty()) {
indexResult[e][pred]->succ = i; // update successor of predecessor
indexResult[e][i] = new IndexRetrieval(pred, 0, part[i]);
pred = i;
}
}
// if (part.empty() && ((elem.getSetRel() == DISJOINT) ||
// (!elem.hasLabel() && !elem.hasPlace()))) {
// for (unsigned int i = 1; i < time.size(); i++) {
// if (time[i]) {
// indexResult[e][pred].succ = i; // update successor of predecessor
// IndexRetrieval ir(pred);
// indexResult[e][i] = ir;
// pred = i;
// }
// }
// }
if ((indexResult[e][0]->succ == 0) && elem.hasIndexableContents() &&
(elem.getSetRel() != DISJOINT)) {
indexMismatch.insert(e);
}
}
/*
\subsection{Function ~initMatchInfo~}
*/
void IndexMatchesLI::initMatchInfo(const set<int>& cruElems) {
matchInfo = new IndexMatchSlot**[p->getNFAsize()];
memset(matchInfo, 0, p->getNFAsize() * sizeof(void*));
newMatchInfo = new IndexMatchSlot**[p->getNFAsize()];
memset(newMatchInfo, 0, p->getNFAsize() * sizeof(void*));
trajSize = new int[rel->GetNoTuples() + 1];
memset(trajSize, 0, (rel->GetNoTuples() + 1 * sizeof(int)));
vector<bool> trajInfo, newTrajInfo;
trajInfo.assign(rel->GetNoTuples() + 1, true);
PatElem elem;
for (set<int>::iterator it = cruElems.begin(); it != cruElems.end(); it++) {
p->getElem(*it, elem);
if (elem.hasIndexableContents()) {
if (indexMismatch.find(*it) != indexMismatch.end()) {
cout << "index mismatch at crucial element " << *it << endl;
return;
}
newTrajInfo.assign(rel->GetNoTuples() + 1, false);
TupleId id = indexResult[*it][0]->succ; // first active tuple id
while (id > 0) {
if (trajInfo[id]) {
newTrajInfo[id] = true;
}
else {
removeIdFromIndexResult(id, true);
}
id = indexResult[*it][id]->succ;
}
trajInfo.swap(newTrajInfo);
}
}
for (int i = 0; i < p->getNFAsize(); i++) {
matchInfo[i] = new IndexMatchSlot*[rel->GetNoTuples() + 1];
memset(matchInfo[i], 0, (rel->GetNoTuples() + 1) * sizeof(void*));
newMatchInfo[i] = new IndexMatchSlot*[rel->GetNoTuples() + 1];
memset(newMatchInfo[i], 0, (rel->GetNoTuples() + 1) * sizeof(void*));
}
unsigned int pred = 0;
for (unsigned int id = 1; id < trajInfo.size(); id++) {
if (trajInfo[id]) {
trajSize[id] = getTrajSize(id, mtype);
IndexMatchInfo imi(false);
deactivated[id] = false;
for (int s = 0; s < p->getNFAsize(); s++) {
matchInfo[s][id] = new IndexMatchSlot();
matchInfo[s][pred]->succ = id;
matchInfo[s][id]->pred = pred;
newMatchInfo[s][id] = new IndexMatchSlot();
newMatchInfo[s][pred]->succ = id;
newMatchInfo[s][id]->pred = pred;
if (indexResult[s] != 0) {
for (unsigned int i = pred + 1; i < id; i++) { // deactivate indexRes.
indexResult[s][i]->pred = 0;
indexResult[s][i]->succ = 0;
}
indexResult[s][pred]->succ = id;
}
}
matchInfo[0][id]->imis.push_back(imi);
activeTuples++;
pred = id;
}
}
matchInfo[0][pred]->succ = 0;
newMatchInfo[0][pred]->succ = 0;
for (int s = 0; s < p->getSize(); s++) {
if (indexResult[s] != 0) {
indexResult[s][pred]->succ = 0;
}
}
}
/*
\subsection{Function ~initialize~}
Collects the tuple ids of the trajectories that could match the pattern
according to the index information.
*/
void IndexMatchesLI::initialize() {
vector<map<int, int> > simpleNFA;
p->simplifyNFA(simpleNFA);
set<pair<set<int>, int> > paths;
p->findNFApaths(simpleNFA, paths);
set<int> cruElems;
p->getCrucialElems(paths, cruElems);
indexResult = new IndexRetrieval**[p->getSize()];
memset(indexResult, 0, p->getSize() * sizeof(void*));
deactivated.resize(rel->GetNoTuples() + 1, false);
for (set<int>::iterator it = cruElems.begin(); it != cruElems.end(); it++) {
storeIndexResult(*it);
}
deactivated.resize(rel->GetNoTuples() + 1, true);
p->initEasyCondOpTrees(true);
p->initCondOpTrees();
activeTuples = 0;
initMatchInfo(cruElems);
}
/*
\subsection{Destructor}
*/
IndexMatchSuper::~IndexMatchSuper() {
if (p) {
int pred(0), id(0);
if (indexResult && matchInfo) { // for indextmatches
for (int i = 0; i < p->getSize(); i++) {
if (indexResult[i] != 0) {
id = indexResult[i][0]->succ;
while (id != 0 && indexResult[i][id] != 0) {
pred = id;
id = indexResult[i][id]->succ;
delete indexResult[i][pred];
}
delete indexResult[i][0];
delete[] indexResult[i];
}
if (matchRecord[i] != 0) {
for (int j = 0; j <= rel->GetNoTuples(); j++) {
if (matchRecord[i][j] != 0) {
delete matchRecord[i][j];
}
}
delete[] matchRecord[i];
}
}
for (int i = 0; i < p->getNFAsize(); i++) {
if (matchInfo != 0) {
if (matchInfo[i] != 0) {
id = matchInfo[i][0]->succ;
while (id != 0 && matchInfo[i][id] != 0) {
pred = id;
id = matchInfo[i][id]->succ;
delete matchInfo[i][pred];
}
delete matchInfo[i][0];
delete[] matchInfo[i];
}
}
if (newMatchInfo != 0) {
if (newMatchInfo[i] != 0) {
id = newMatchInfo[i][0]->succ;
while (id != 0 && newMatchInfo[i][id] != 0) {
pred = id;
id = newMatchInfo[i][id]->succ;
delete newMatchInfo[i][pred];
}
delete newMatchInfo[i][0];
delete[] newMatchInfo[i];
}
}
}
delete[] indexResult;
delete[] matchRecord;
delete[] matchInfo;
delete[] newMatchInfo;
delete[] trajSize;
}
if (condRecord != 0) {
for (int i = 0; i <= rel->GetNoTuples(); i++) {
if (condRecord[i]) {
delete condRecord[i];
}
}
delete[] condRecord;
}
if (indexResult2 && matchInfo2) { // for indextmatches2
for (int i = 0; i < p->getSize(); i++) {
if (indexResult2[i] != 0) {
id = indexResult2[i][0]->succ;
while (id != 0 && indexResult2[i][id] != 0) {
pred = id;
id = indexResult2[i][id]->succ;
delete indexResult2[i][pred];
indexResult2[i][pred] = 0;
}
delete indexResult2[i][0];
delete[] indexResult2[i];
}
}
for (int i = 0; i < p->getNFAsize(); i++) {
if (matchInfo2 != 0) {
if (matchInfo2[i] != 0) {
id = matchInfo2[i][0]->succ;
while (id != 0 && matchInfo2[i][id] != 0) {
pred = id;
id = matchInfo2[i][id]->succ;
delete matchInfo2[i][pred];
}
delete matchInfo2[i][0];
delete[] matchInfo2[i];
}
}
if (newMatchInfo2 != 0) {
if (newMatchInfo2[i] != 0) {
id = newMatchInfo2[i][0]->succ;
while (id != 0 && newMatchInfo2[i][id] != 0) {
pred = id;
id = newMatchInfo2[i][id]->succ;
delete newMatchInfo2[i][pred];
}
delete newMatchInfo2[i][0];
delete[] newMatchInfo2[i];
}
}
}
delete[] indexResult2;
delete[] matchInfo2;
delete[] newMatchInfo2;
}
delete[] active;
deletePattern();
}
}
/*
\subsection{Function ~getMsize~}
*/
int IndexMatchSuper::getTrajSize(const TupleId tId, const DataType type) {
Tuple* tuple = rel->GetTuple(tId, false);
int result = -1;
switch (type) {
case MLABEL: {
result = ((MLabel*)tuple->GetAttribute(attrNo))->GetNoComponents();
break;
}
case MLABELS: {
result = ((MLabels*)tuple->GetAttribute(attrNo))->GetNoComponents();
break;
}
case MPLACE: {
result = ((MPlace*)tuple->GetAttribute(attrNo))->GetNoComponents();
break;
}
default: { // places
result = ((MPlaces*)tuple->GetAttribute(attrNo))->GetNoComponents();
break;
}
}
deleteIfAllowed(tuple);
return result;
}
/*
\subsection{Function ~getInterval~}
*/
void IndexMatchSuper::getInterval(const TupleId tId, const int pos,
SecInterval& iv) {
Tuple *tuple = rel->GetTuple(tId, false);
switch (mtype) {
case MLABEL: {
((MLabel*)tuple->GetAttribute(attrNo))->GetInterval(pos, iv);
break;
}
case MLABELS: {
((MLabels*)tuple->GetAttribute(attrNo))->GetInterval(pos, iv);
break;
}
case MPLACE: {
((MPlace*)tuple->GetAttribute(attrNo))->GetInterval(pos, iv);
break;
}
case MPLACES: {
((MPlaces*)tuple->GetAttribute(attrNo))->GetInterval(pos, iv);
break;
}
default: {
break;
}
}
tuple->DeleteIfAllowed();
}
/*
\subsection{Function ~periodsToUnits~}
*/
void IndexMatchSuper::periodsToUnits(const Periods *per, const TupleId tId,
set<int> &units) {
if (!per) {
return;
}
if (!per->IsDefined()) {
cout << "undefined periods!" << endl;
return;
}
switch (mtype) {
case MLABEL: {
periodsToUnits<MLabel>(per, tId, units);
break;
}
case MLABELS: {
periodsToUnits<MLabels>(per, tId, units);
break;
}
case MPLACE: {
periodsToUnits<MPlace>(per, tId, units);
break;
}
case MPLACES: {
periodsToUnits<MPlaces>(per, tId, units);
break;
}
}
}
/*
\subsection{Function ~unitsToPeriods~}
*/
void TMatchIndexLI::unitsToPeriods(const set<int> &units, const TupleId tId,
const int attr, Periods *per) {
per->SetDefined(true);
Tuple *t = rel->GetTuple(tId, false);
Attribute *traj = t->GetAttribute(attr);
ListExpr attrList = nl->Second(nl->Nth(attr + 1, nl->Second(ttList)));
if (MLabel::checkType(attrList)) {
unitsToPeriods<MLabel, ULabel>(traj, units, per);
}
else if (MLabels::checkType(attrList)) {
unitsToPeriods<MLabels, ULabels>(traj, units, per);
}
else if (MPlace::checkType(attrList)) {
unitsToPeriods<MPlace, UPlace>(traj, units, per);
}
else if (MPlaces::checkType(attrList)) {
unitsToPeriods<MPlaces, UPlaces>(traj, units, per);
}
else if (MPoint::checkType(attrList)) {
unitsToPeriods<MPoint, UPoint>(traj, units, per);
}
else if (MRegion::checkType(attrList)) {
unitsToPeriods<MRegion, URegionEmb>(traj, units, per);
}
else if (MBool::checkType(attrList)) {
unitsToPeriods<MBool, UBool>(traj, units, per);
}
else if (MInt::checkType(attrList)) {
unitsToPeriods<MInt, UInt>(traj, units, per);
}
else if (MReal::checkType(attrList)) {
unitsToPeriods<MReal, UReal>(traj, units, per);
}
else if (MString::checkType(attrList)) {
unitsToPeriods<MString, UString>(traj, units, per);
}
t->DeleteIfAllowed();
}
/*
\subsection{Function ~remove~}
*/
void IndexMatchSuper::remove(std::vector<TupleId> &toRemove,
const bool mainAttr) {
for (unsigned int i = 0; i < toRemove.size(); i++) {
if (active[toRemove[i]]) {
removeIdFromMatchInfo(toRemove[i], mainAttr);
removeIdFromIndexResult(toRemove[i], mainAttr);
}
}
toRemove.clear();
}
/*
\subsection{Function ~removeIdFromIndexResult~}
*/
void IndexMatchSuper::removeIdFromIndexResult(const TupleId id,
const bool mainAttr) {
if (mainAttr) {
for (int i = 0; i < p->getSize(); i++) {
if (indexResult[i] != 0) {
if (indexResult[i][id] != 0) {
if (indexResult[i][indexResult[i][id]->pred]->succ == id) {
indexResult[i][indexResult[i][id]->pred]->succ =
indexResult[i][id]->succ;
indexResult[i][indexResult[i][id]->succ]->pred =
indexResult[i][id]->pred;
delete indexResult[i][id];
indexResult[i][id] = 0;
}
}
}
}
}
else {
for (int i = 0; i < p->getSize(); i++) {
if (indexResult2[i] != 0) {
if (indexResult2[i][id] != 0) {
if (indexResult2[i][indexResult2[i][id]->pred]->succ == id) {
indexResult2[i][indexResult2[i][id]->pred]->succ =
indexResult2[i][id]->succ;
indexResult2[i][indexResult2[i][id]->succ]->pred =
indexResult2[i][id]->pred;
delete indexResult2[i][id];
indexResult2[i][id] = 0;
}
}
}
}
}
}
/*
\subsection{Function ~removeIdFromMatchInfo~}
*/
void IndexMatchSuper::removeIdFromMatchInfo(const TupleId id,
const bool mainAttr) {
bool removed = false;
if (mainAttr) {
for (int s = 0; s < p->getNFAsize(); s++) {
if (newMatchInfo[s] != 0) {
if (newMatchInfo[s][id]) {
// cout << "Elem " << i << ", Tuple " << id << ":" << endl;
newMatchInfo[s][newMatchInfo[s][id]->pred]->succ =
newMatchInfo[s][id]->succ;
// cout << " succ of " << matchInfo[i][id].pred << " set to "
// << matchInfo[i][id].succ << endl;
newMatchInfo[s][newMatchInfo[s][id]->succ]->pred =
newMatchInfo[s][id]->pred;
// cout << " pred of " << matchInfo[i][id].succ << " set to "
// << matchInfo[i][id].pred << endl;
delete newMatchInfo[s][id];
newMatchInfo[s][id] = 0;
removed = true;
}
}
}
}
// if (matchInfo[s] != 0) {
// if (matchInfo[s][id] != 0) {
// if (matchInfo[s][matchInfo[s][id]->pred]->succ == id) {
// // cout << "Elem " << i << ", Tuple " << id << ":" << endl;
// matchInfo[s][matchInfo[s][id]->pred]->succ = matchInfo[s][id]->succ;
// // cout << " succ of " << matchInfo[i][id].pred << " set to "
// // << matchInfo[i][id].succ << endl;
// matchInfo[s][matchInfo[s][id]->succ]->pred = matchInfo[s][id]->pred;
// removed = true;
// // cout << " pred of " << matchInfo[i][id].succ << " set to "
// // << matchInfo[i][id].pred << endl;
// delete matchInfo[s][id];
// matchInfo[s][id] = 0;
// }
// }
// }
else {
for (int s = 0; s < p->getNFAsize(); s++) {
if (newMatchInfo2[s] != 0) {
if (newMatchInfo2[s][id]) {
// cout << "Elem " << i << ", Tuple " << id << ":" << endl;
newMatchInfo2[s][newMatchInfo2[s][id]->pred]->succ =
newMatchInfo2[s][id]->succ;
// cout << " succ of " << matchInfo[i][id].pred << " set to "
// << matchInfo[i][id].succ << endl;
newMatchInfo2[s][newMatchInfo2[s][id]->succ]->pred =
newMatchInfo2[s][id]->pred;
// cout << " pred of " << matchInfo[i][id].succ << " set to "
// << matchInfo[i][id].pred << endl;
delete newMatchInfo2[s][id];
newMatchInfo2[s][id] = 0;
removed = true;
}
}
}
}
active[id] = false;
activeTuples -= (removed ? 1 : 0);
// cout << "ID " << id << " removed; activeTuples=" << activeTuples << endl;
}
/*
\subsection{Function ~canBeDeactivated~}
*/
bool IndexMatchSuper::canBeDeactivated(const TupleId id, const int state,
const int atom, const bool checkRange /* = false */) const {
if (crucialAtoms.find(atom) != crucialAtoms.end()) {
for (int i = state + 1; i < p->getNFAsize(); i++) {
if (matchInfo[i] != 0) {
if (matchInfo[i][id] != 0) {
if (!matchInfo[i][id]->imis.empty()) {
// cout << "------------DO NOT deactivate id " << id
// << ", has mI[" << i << "]" << endl;
return false;
}
}
}
if (newMatchInfo[i] != 0) {
if (newMatchInfo[i][id] != 0) {
if (!newMatchInfo[i][id]->imis.empty()) {
// cout << "-----------DO NOT deactivate id " << id
// << ", has nMI[" << i << "]" << endl;
return false;
}
}
}
}
}
if (checkRange) {
if (matchInfo[state][id] != 0) {
for (unsigned int i = 0; i < matchInfo[state][id]->imis.size(); i++) {
if (!matchInfo[state][id]->imis[i].range) {
// cout << "-----------DO NOT deactivate id " << id
// << ", range=FALSE" << endl;
return false;
}
}
}
}
return true;
}
/*
\subsection{Function ~clearMatchInfo~}
Copy the contents of newMatchInfo into matchInfo, and clear newMatchInfo.
*/
void IndexMatchSuper::clearMatchInfo() {
TupleId pred(0), pred2(0);
for (int i = 0; i < p->getNFAsize(); i++) {
if (newMatchInfo[i] == 0) { // nothing found, clear matchInfo
if (matchInfo[i] != 0) {
TupleId id = matchInfo[i][0]->succ;
while (id > 0) {
pred = id;
id = matchInfo[i][id]->succ;
if (matchInfo[i][pred] != 0) {
matchInfo[i][pred]->imis.clear();
}
}
}
}
else { // copy
TupleId id2 = matchInfo[i][0]->succ;
TupleId id = newMatchInfo[i][0]->succ;
while (id2 < id) {
pred2 = id2;
id2 = matchInfo[i][id2]->succ;
matchInfo[i][matchInfo[i][pred2]->pred]->succ = id2;
matchInfo[i][id2]->pred = matchInfo[i][pred2]->pred;
delete matchInfo[i][pred2];
matchInfo[i][pred2] = 0;
}
while (id > 0) {
matchInfo[i][id]->imis = newMatchInfo[i][id]->imis;
pred = id;
id = newMatchInfo[i][id]->succ;
newMatchInfo[i][pred]->imis.clear();
}
}
if (pred > 0 && newMatchInfo[i][pred] != 0) {
newMatchInfo[i][pred]->imis.clear();
}
}
// cout << "after clearMatchInfo: " << (*matchInfoPtr)[0][0].succ << " "
// << (*matchInfoPtr)[1][0].succ << " " << (*newMatchInfoPtr)[0][0].succ
// << " " << (*newMatchInfoPtr)[1][0].succ << endl;
}
/*
\subsection{Function ~clearMatchInfo2~}
Copy the contents of newMatchInfo2 into matchInfo2, and clear newMatchInfo2.
*/
void IndexMatchSuper::clearMatchInfo2() {
TupleId pred(0), pred2(0);
for (int i = 0; i < p->getNFAsize(); i++) {
if (newMatchInfo2[i] == 0) { // nothing found, clear matchInfo
if (matchInfo2[i] != 0) {
TupleId id = matchInfo2[i][0]->succ;
while (id > 0) {
pred = id;
id = matchInfo2[i][id]->succ;
if (matchInfo2[i][pred] != 0) {
matchInfo2[i][pred]->imis.clear();
}
}
}
}
else { // copy
TupleId id2 = matchInfo2[i][0]->succ;
TupleId id = newMatchInfo2[i][0]->succ;
while (id2 < id) {
pred2 = id2;
id2 = matchInfo2[i][id2]->succ;
matchInfo2[i][matchInfo2[i][pred2]->pred]->succ = id2;
matchInfo2[i][id2]->pred = matchInfo2[i][pred2]->pred;
delete matchInfo2[i][pred2];
matchInfo2[i][pred2] = 0;
}
while (id > 0) {
matchInfo2[i][id]->imis = newMatchInfo2[i][id]->imis;
pred = id;
id = newMatchInfo2[i][id]->succ;
newMatchInfo2[i][pred]->imis.clear();
}
}
if (pred > 0 && newMatchInfo2[i][pred] != 0) {
newMatchInfo2[i][pred]->imis.clear();
}
}
// cout << "after clearMatchInfo: " << (*matchInfoPtr)[0][0].succ << " "
// << (*matchInfoPtr)[1][0].succ << " " << (*newMatchInfoPtr)[0][0].succ
// << " " << (*newMatchInfoPtr)[1][0].succ << endl;
}
/*
\subsection{Function ~hasIdIMIs~}
*/
bool IndexMatchSuper::hasIdIMIs(const TupleId id, const bool mainAttr,
const int state /* = -1 */) {
if (mainAttr) {
if (state == -1) { // check all states
for (int s = 0; s < p->getNFAsize(); s++) {
if (matchInfo[s][id] != 0) {
if (!matchInfo[s][id]->imis.empty()) {
return true;
}
}
if (newMatchInfo[s][id] != 0) {
if (!newMatchInfo[s][id]->imis.empty()) {
return true;
}
}
}
return false;
}
else {
if (matchInfo[state][id] != 0) {
if (!matchInfo[state][id]->imis.empty()) {
return true;
}
}
if (newMatchInfo[state][id] != 0) {
if (!newMatchInfo[state][id]->imis.empty()) {
return true;
}
}
return false;
}
}
else {
if (state == -1) { // check all states
for (int s = 0; s < p->getNFAsize(); s++) {
if (matchInfo2[s][id] != 0) {
if (!matchInfo2[s][id]->imis.empty()) {
return true;
}
}
if (newMatchInfo2[s][id] != 0) {
if (!newMatchInfo2[s][id]->imis.empty()) {
return true;
}
}
}
return false;
}
else {
if (matchInfo2[state][id] != 0) {
if (!matchInfo2[state][id]->imis.empty()) {
return true;
}
}
if (newMatchInfo2[state][id] != 0) {
if (!newMatchInfo2[state][id]->imis.empty()) {
return true;
}
}
return false;
}
}
}
/*
\subsection{Function ~extendBinding~}
*/
void IndexMatchSuper::extendBinding(IndexMatchInfo& imi, const int atom,
const bool wc, const TupleId id /* = 0 */) {
if (!p->hasConds() && !p->hasAssigns()) {
return;
}
int elem = p->getElemFromAtom(atom);
imi.set(elem, imi.next - 1);
// cout << elem << " set! to " << imi.next - 1 << endl;
PatElem prevE;
bool prevW = false;
if (elem > 0) {
p->getElem(elem - 1, prevE);
prevW = (prevE.getW() != NO);
}
if (!wc && prevW) {
imi.set(elem - 1, imi.next - 2);
// cout << elem - 1 << " set* to " << imi.next - 2 << endl;
}
if (id > 0) { // totalMatch
int lastElem = p->getElemFromAtom(p->getSize() - 1);
for (int i = elem + 1; i < lastElem; i++) {
imi.set(i, -1);
// cout << i << " set% to " << -1 << endl;
}
imi.set(lastElem, trajSize[id] - 1);
if (lastElem > 0) {
if (imi.binding[lastElem - 1] == trajSize[id] - 1) {
imi.set(lastElem, -1);
}
}
}
imi.prevElem = p->getElemFromAtom(atom);
// imi.print(true);
}
/*
\subsection{Function ~deletePattern~}
*/
void IndexMatchSuper::deletePattern() {
if (p) {
p->deleteAtomValues(relevantAttrs);
delete p;
p = 0;
}
}
/*
\subsection{Function ~wildcardMatch~}
*/
bool IndexMatchesLI::wildcardMatch(const int state, pair<int, int> trans) {
IndexMatchInfo *imiPtr;
bool ok = false;
int oldEnd = -1;
TupleId id = matchInfo[state][0]->succ; // first active tuple id
while (id > 0) {
// cout << "wildcardMatch: " << (*matchInfoPtr)[state][id].imis.size()
// << " IMIs, state=" << state << ", id=" << id << endl;
unsigned int numOfIMIs = (matchInfo[state][id] != 0 ?
matchInfo[state][id]->imis.size() : 0);
unsigned int i = 0;
while (!deactivated[id] && (i < numOfIMIs)) {
imiPtr = &(matchInfo[state][id]->imis[i]);
// cout << imiPtr->next + 1 << " | " << unitCtr << endl;
if (imiPtr->next + 1 >= unitCtr) {
bool match = false;
IndexMatchInfo newIMI(true, imiPtr->next + 1, imiPtr->binding,
imiPtr->prevElem);
if (p->hasConds()) { // extend binding for a complete match
extendBinding(newIMI, trans.first, true);
if (p->isFinalState(trans.second) && imiPtr->finished(trajSize[id])) {
oldEnd = newIMI.getTo(p->getElemFromAtom(trans.first));
match = checkConditions(id, newIMI);
if (!match) { // reset unsuccessful binding
newIMI.reset(oldEnd);
}
}
}
else { // no conditions
// cout << " " << p.isFinalState(trans.second) << " *** "
// << newIMI.finished(trajSize[id]) << endl;
match = p->isFinalState(trans.second) &&newIMI.finished(trajSize[id]);
}
if (match) {
matches.push_back(id); // complete match
ok = true;
removeIdFromMatchInfo(id);
removeIdFromIndexResult(id, true);
// cout << id << " removed (wild match) " << activeTuples
// << " active tuples" << endl;
i = UINT_MAX - 1;
}
else if (!newIMI.exhausted(trajSize[id])) { // continue
newMatchInfo[trans.second][id]->imis.push_back(newIMI);
// cout << " imi pushed back from wildcardMatch, id " << id << endl;
ok = true;
}
}
i++;
}
if (!ok && !hasIdIMIs(id, state)) { // no IMIs for id and state
if (!hasIdIMIs(id, true)) { // no IMIs at all for id
removeIdFromMatchInfo(id);
removeIdFromIndexResult(id, true);
// cout << id << " removed (wild mismatch) " << activeTuples
// << " active tuples" << endl;
}
}
id = matchInfo[state][id]->succ;
}
return ok;
cout << "return ok" << endl;
}
/*
\subsection{Function ~valuesMatch~}
*/
bool IndexMatchesLI::valuesMatch(const int e, const TupleId id,
IndexMatchInfo& imi, const int newState, const int unit) {
if (imi.next >= trajSize[id]) {
return false;
}
Tuple *tuple = rel->GetTuple(id, false);
bool result = false;
switch (mtype) {
case MLABEL: {
MLabel *ml = (MLabel*)(tuple->GetAttribute(attrNo));
Match<MLabel> match(0, ml);
result = imiMatch(match, e, id, imi, unit, newState);
break;
}
case MLABELS: {
MLabels *mls = (MLabels*)(tuple->GetAttribute(attrNo));
Match<MLabels> match(0, mls);
result = imiMatch(match, e, id, imi, unit, newState);
break;
}
case MPLACE: {
MPlace *mp = (MPlace*)(tuple->GetAttribute(attrNo));
Match<MPlace> match(0, mp);
result = imiMatch(match, e, id, imi, unit, newState);
break;
}
default: { // PLACES
MPlaces *mps = (MPlaces*)(tuple->GetAttribute(attrNo));
Match<MPlaces> match(0, mps);
result = imiMatch(match, e, id, imi, unit, newState);
break;
}
}
tuple->DeleteIfAllowed();
return result;
}
/*
\subsection{Function ~applySetRel~}
*/
void IndexMatchesLI::applySetRel(const SetRel setRel,
vector<set<pair<TupleId, int> > >& valuePosVec,
set<pair<TupleId, int> >*& result) {
switch (setRel) {
case STANDARD: {
Tools::uniteLastPairs(valuePosVec.size(), valuePosVec);
result = &(valuePosVec[0]);
break;
}
case DISJOINT: { // will not happen
break;
}
case SUPERSET: {}
case EQUAL: {
Tools::intersectPairs(valuePosVec, result);
break;
}
default: { // INTERSECT
Tools::uniteLastPairs(valuePosVec.size(), valuePosVec);
result = &(valuePosVec[0]);
break;
}
}
}
/*
\subsection{Function ~simpleMatch~}
*/
bool IndexMatchesLI::simpleMatch(const int e, const int state,
const int newState) {
bool transition = false;
storeIndexResult(e);
// cout << e << " " << indexResult[e].size() << " " << indexResult[e][0].succ
// << endl;
if (indexResult[e] != 0) { // contents found in at least one index
TupleId id = indexResult[e][0]->succ;
while (id > 0) {
if (!deactivated[id]) {
// cout << "state " << state << "; elem " << e << "; next id is " << id
// << endl;
// cout << "simpleMatch: " << (*matchInfoPtr)[state][id].imis.size()
// << " IMIs, state=" << state << ", id=" << id << endl;
if ((indexResult[e][indexResult[e][id]->pred]->succ == id) &&
!indexResult[e][id]->units.empty()) {
unsigned int numOfIMIs = (matchInfo[state][id] != 0 ?
matchInfo[state][id]->imis.size() : 0);
for (unsigned int i = 0; i < numOfIMIs; i++) {
set<int>::iterator it = indexResult[e][id]->units.begin();
while (!deactivated[id] && (it != indexResult[e][id]->units.end())){
if (valuesMatch(e, id, matchInfo[state][id]->imis[i],
newState, *it)) {
transition = true;
if (deactivated[id]) {
i = numOfIMIs;
}
}
it++;
}
}
}
if (!hasIdIMIs(id, true, state)) { // no IMIs
if (!hasIdIMIs(id, true)) { // no IMIs at all for id
removeIdFromMatchInfo(id);
removeIdFromIndexResult(id, true);
// cout << id << " removed (index) " << activeTuples
// << " active tuples" << endl;
}
}
}
id = indexResult[e][id]->succ;
}
}
else { // no result from index
if (indexMismatch.find(e) != indexMismatch.end()) { // mismatch
return false;
}
else { // disjoint or () or only semantic time information
PatElem elem;
TupleId id = matchInfo[e][0]->succ; // first active tuple id
while (id > 0) {
if (!deactivated[id]) {
unsigned int numOfIMIs = (matchInfo[state][id] != 0 ?
matchInfo[state][id]->imis.size() : 0);
for (unsigned int i = 0; i < numOfIMIs; i++) {
if (valuesMatch(e, id, matchInfo[state][id]->imis[i], newState,-1)){
transition = true;
if (deactivated[id]) {
i = numOfIMIs;
}
}
}
if (!hasIdIMIs(id, true, state)) { // no IMIs for id and state
if (!hasIdIMIs(id, true)) { // no IMIs at all for id
removeIdFromMatchInfo(id);
removeIdFromIndexResult(id, true);
// cout << id << " removed (no index) " << activeTuples #
// << " active tuples" << endl;
}
}
}
id = matchInfo[e][id]->succ;
}
}
}
return transition;
}
/*
\subsection{Function ~timesMatch~}
*/
bool IndexMatchesLI::timesMatch(const TupleId id, const unsigned int unit,
const PatElem& elem) {
set<string> ivs;
elem.getI(ivs);
SecInterval iv(true);
getInterval(id, unit, iv);
return Tools::timesMatch(iv, ivs);
}
/*
\subsection{Function ~checkConditions~}
*/
bool IndexMatchesLI::checkConditions(const TupleId id, IndexMatchInfo& imi) {
if (!p->hasConds()) {
return true;
}
Tuple *tuple = rel->GetTuple(id, false);
// cout << "checkConditions: size = " << getMsize(id)
// << "; binding(lastVar) = (" << imi.binding[imi.prevVar].first << ", "
// << imi.binding[imi.prevVar].second << ")" << endl;
bool result = false;
switch (mtype) {
case MLABEL: {
MLabel *ml = (MLabel*)(tuple->GetAttribute(attrNo));
Match<MLabel> match(p, ml);
result = match.conditionsMatch(*(p->getConds()), imi);
break;
}
case MLABELS: {
MLabels *mls = (MLabels*)(tuple->GetAttribute(attrNo));
Match<MLabels> match(p, mls);
result = match.conditionsMatch(*(p->getConds()), imi);
break;
}
case MPLACE: {
MPlace *mp = (MPlace*)(tuple->GetAttribute(attrNo));
Match<MPlace> match(p, mp);
result = match.conditionsMatch(*(p->getConds()), imi);
break;
}
default: { // PLACES
MPlaces *mps = (MPlaces*)(tuple->GetAttribute(attrNo));
Match<MPlaces> match(p, mps);
result = match.conditionsMatch(*(p->getConds()), imi);
break;
}
}
tuple->DeleteIfAllowed();
return result;
}
void IndexMatchInfo::print(const bool printBinding) {
if (range) {
cout << "range from " << next << endl;
}
else {
cout << "next: {" << next << "}" << endl;
}
if (printBinding) {
cout << binding.size() << ": ";
for (unsigned int i = 0; i < binding.size(); i++) {
cout << i << " ---> [" << getFrom(i) << ", " << getTo(i) << "], ";
}
cout << endl;
}
}
}
Reference in New Issue View Git Blame Copy Permalink