Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

further snapshot

This commit is contained in:
James 2014-11-17 12:58:33 +00:00
parent 0dcffe898c
commit 553c638cfe
3 changed files with 286 additions and 181 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

141
arangod/Aql/OptimizerRules.cpp
View File

@ -795,7 +795,7 @@ class FilterToEnumCollFinder : public WalkerWorker<ExecutionNode> {
_plan(plan), _plan(plan),
_canThrow(false), _canThrow(false),
_level(level) { _level(level) {
_rangeInfoMapVec = new RangeInfoMap(); _rangeInfoMapVec = new RangeInfoMapVec();
_varIds.insert(var->id); _varIds.insert(var->id);
}; };
@ -816,7 +816,7 @@ class FilterToEnumCollFinder : public WalkerWorker<ExecutionNode> {
auto node = static_cast<CalculationNode*>(en); auto node = static_cast<CalculationNode*>(en);
std::string attr; std::string attr;
Variable const* enumCollVar = nullptr; Variable const* enumCollVar = nullptr;
buildRangeInfo(node->expression()->node(), enumCollVar, attr); buildRangeInfoAND(node->expression()->node(), enumCollVar, attr);
} }
break; break;
} }
@ -858,7 +858,7 @@ class FilterToEnumCollFinder : public WalkerWorker<ExecutionNode> {
auto node = static_cast<EnumerateCollectionNode*>(en); auto node = static_cast<EnumerateCollectionNode*>(en);
auto var = node->getVariablesSetHere()[0]; // should only be 1 auto var = node->getVariablesSetHere()[0]; // should only be 1
std::unordered_map<std::string, RangeInfo>* map std::unordered_map<std::string, RangeInfo>* map
= _rangeInfoMapVec->find(var->name); = _rangeInfoMapVec->find(var->name, 0);
// check if we have any ranges with this var // check if we have any ranges with this var
if (map != nullptr) { if (map != nullptr) {
@ -872,6 +872,8 @@ class FilterToEnumCollFinder : public WalkerWorker<ExecutionNode> {
for (auto v : varsSetHere) { for (auto v : varsSetHere) {
varsDefined.erase(v); varsDefined.erase(v);
} }
pos = 0;
do {
for (auto& x : *map) { for (auto& x : *map) {
auto worker = [&] (std::list<RangeInfoBound>& bounds) -> void { auto worker = [&] (std::list<RangeInfoBound>& bounds) -> void {
for (auto it = bounds.begin(); it != bounds.end(); for (auto it = bounds.begin(); it != bounds.end();
@ -898,34 +900,16 @@ class FilterToEnumCollFinder : public WalkerWorker<ExecutionNode> {
worker(x.second._lows); worker(x.second._lows);
worker(x.second._highs); worker(x.second._highs);
} }
map = _rangeInfoMapVec->find(var->name, ++pos);
} while (map !=nullptr);
// Now remove empty conditions: // Now remove empty conditions:
for (auto it = map->begin(); it != map->end(); /* no hoisting */ ) { _rangeInfoMapVec->eraseEmptyOrUndefined(var->name);
if (it->second._lows.empty() &&
it->second._highs.empty() &&
! it->second._lowConst.isDefined() &&
! it->second._highConst.isDefined()) {
it = map->erase(it);
}
else {
it++;
}
}
// check the first components of <map> against indexes of <node>... std::vector<size_t> validPos = _rangeInfoMapVec->validPositions(var->name);
std::unordered_set<std::string> attrs; // are any of the RangeInfoMaps in the vector valid?
bool valid = true; // are all the range infos valid?
for(auto x: *map) {
valid &= x.second.isValid();
if (! valid) {
break;
}
attrs.insert(x.first);
}
if (! _canThrow) { if (! _canThrow) {
if (! valid) { // ranges are not valid . . . if (validPos.empty()) { // ranges are not valid . . .
auto newPlan = _plan->clone(); auto newPlan = _plan->clone();
try { try {
auto parents = newPlan->getNodeById(node->id())->getParents(); auto parents = newPlan->getNodeById(node->id())->getParents();
@ -942,6 +926,7 @@ class FilterToEnumCollFinder : public WalkerWorker<ExecutionNode> {
} }
} }
else { else {
std::vector<Index*> idxs; std::vector<Index*> idxs;
std::vector<size_t> prefixes; std::vector<size_t> prefixes;
// {idxs.at(i)->_fields[0]..idxs.at(i)->_fields[prefixes.at(i)]} // {idxs.at(i)->_fields[0]..idxs.at(i)->_fields[prefixes.at(i)]}
@ -949,14 +934,18 @@ class FilterToEnumCollFinder : public WalkerWorker<ExecutionNode> {
// note: prefixes are only used for skiplist indexes // note: prefixes are only used for skiplist indexes
// for all other index types, the prefix value will always be 0 // for all other index types, the prefix value will always be 0
node->getIndexesForIndexRangeNode(attrs, idxs, prefixes); node->getIndexesForIndexRangeNode(
_rangeInfoMapVec->attributes(var->name, 0), idxs, prefixes);
//TODO remove the 2nd arg from attribute in the line above
// make one new plan for every index in <idxs> that replaces the // make one new plan for every index in <idxs> that replaces the
// enumerate collection node with a IndexRangeNode ... // enumerate collection node with a IndexRangeNode ...
for (size_t i = 0; i < idxs.size(); i++) { for (size_t i = 0; i < idxs.size(); i++) {
std::vector<std::vector<RangeInfo>> rangeInfo; IndexOrCondition indexOrCondition;
rangeInfo.push_back(std::vector<RangeInfo>()); for (size_t k = 0; k < validPos.size(); k++) {
indexOrCondition.push_back(std::vector<RangeInfo>());
}
// ranges must be valid and all comparisons == if hash // ranges must be valid and all comparisons == if hash
// index or == followed by a single <, >, >=, or <= // index or == followed by a single <, >, >=, or <=
@ -966,15 +955,18 @@ class FilterToEnumCollFinder : public WalkerWorker<ExecutionNode> {
TRI_ASSERT(idx != nullptr); TRI_ASSERT(idx != nullptr);
if (idx->type == TRI_IDX_TYPE_PRIMARY_INDEX) { if (idx->type == TRI_IDX_TYPE_PRIMARY_INDEX) {
for (size_t k = 0; k < validPos.size(); k++) {
bool handled = false; bool handled = false;
auto map = _rangeInfoMapVec->find(var->name, validPos[k]);
auto range = map->find(std::string(TRI_VOC_ATTRIBUTE_ID)); auto range = map->find(std::string(TRI_VOC_ATTRIBUTE_ID));
if (range != map->end()) { if (range != map->end()) {
if (! range->second.is1ValueRangeInfo()) { if (! range->second.is1ValueRangeInfo()) {
rangeInfo.at(0).clear(); // not usable indexOrCondition.at(k).clear(); // not usable
} }
else { else {
rangeInfo.at(0).push_back(range->second); indexOrCondition.at(k).push_back(range->second);
handled = true; handled = true;
} }
} }
@ -984,35 +976,40 @@ class FilterToEnumCollFinder : public WalkerWorker<ExecutionNode> {
if (range != map->end()) { if (range != map->end()) {
if (! range->second.is1ValueRangeInfo()) { if (! range->second.is1ValueRangeInfo()) {
rangeInfo.at(0).clear(); // not usable indexOrCondition.at(k).clear(); // not usable
} }
else { else {
rangeInfo.at(0).push_back(range->second); indexOrCondition.at(k).push_back(range->second);
}
} }
} }
} }
} }
else if (idx->type == TRI_IDX_TYPE_HASH_INDEX) { else if (idx->type == TRI_IDX_TYPE_HASH_INDEX) {
for (size_t k = 0; k < validPos.size(); k++) {
auto map = _rangeInfoMapVec->find(var->name, validPos[k]);
for (size_t j = 0; j < idx->fields.size(); j++) { for (size_t j = 0; j < idx->fields.size(); j++) {
auto range = map->find(idx->fields[j]); auto range = map->find(idx->fields[j]);
if (! range->second.is1ValueRangeInfo()) { if (! range->second.is1ValueRangeInfo()) {
rangeInfo.at(0).clear(); // not usable indexOrCondition.at(k).clear(); // not usable
break; break;
} }
rangeInfo.at(0).push_back(range->second); indexOrCondition.at(k).push_back(range->second);
}
} }
} }
else if (idx->type == TRI_IDX_TYPE_EDGE_INDEX) { else if (idx->type == TRI_IDX_TYPE_EDGE_INDEX) {
for (size_t k = 0; k < validPos.size(); k++) {
bool handled = false; bool handled = false;
auto range = map->find(std::string(TRI_VOC_ATTRIBUTE_FROM)); auto range = map->find(std::string(TRI_VOC_ATTRIBUTE_FROM));
auto map = _rangeInfoMapVec->find(var->name, validPos[k]);
if (range != map->end()) { if (range != map->end()) {
if (! range->second.is1ValueRangeInfo()) { if (! range->second.is1ValueRangeInfo()) {
rangeInfo.at(0).clear(); // not usable indexOrCondition.at(k).clear(); // not usable
} }
else { else {
rangeInfo.at(0).push_back(range->second); indexOrCondition.at(k).push_back(range->second);
handled = true; handled = true;
} }
} }
@ -1022,36 +1019,54 @@ class FilterToEnumCollFinder : public WalkerWorker<ExecutionNode> {
if (range != map->end()) { if (range != map->end()) {
if (! range->second.is1ValueRangeInfo()) { if (! range->second.is1ValueRangeInfo()) {
rangeInfo.at(0).clear(); // not usable indexOrCondition.at(k).clear(); // not usable
} }
else { else {
rangeInfo.at(0).push_back(range->second); indexOrCondition.at(k).push_back(range->second);
}
} }
} }
} }
} }
else if (idx->type == TRI_IDX_TYPE_SKIPLIST_INDEX) { else if (idx->type == TRI_IDX_TYPE_SKIPLIST_INDEX) {
for (size_t k = 0; k < validPos.size(); k++) {
auto map = _rangeInfoMapVec->find(var->name, validPos[k]);
size_t j = 0; size_t j = 0;
auto range = map->find(idx->fields[0]); auto range = map->find(idx->fields[0]);
TRI_ASSERT(range != map->end()); TRI_ASSERT(range != map->end());
rangeInfo.at(0).push_back(range->second); indexOrCondition.at(k).push_back(range->second);
bool equality = range->second.is1ValueRangeInfo(); bool equality = range->second.is1ValueRangeInfo();
while (++j < prefixes.at(i) && equality) { while (++j < prefixes.at(i) && equality) {
range = map->find(idx->fields[j]); range = map->find(idx->fields[j]);
rangeInfo.at(0).push_back(range->second); indexOrCondition.at(k).push_back(range->second);
equality = equality && range->second.is1ValueRangeInfo(); equality = equality && range->second.is1ValueRangeInfo();
} }
} }
}
if (! rangeInfo.at(0).empty()) { //TODO remove empty positions in indexOrCondition?
// check if there are any non-empty positions in
// indexOrCondition
bool isEmpty = true;
for (size_t k = 0; k < validPos.size(); k++) {
if (! indexOrCondition.at(k).empty()) {
isEmpty = false;
break;
}
}
if (! isEmpty) {
auto newPlan = _plan->clone(); auto newPlan = _plan->clone();
if (newPlan == nullptr) { if (newPlan == nullptr) {
THROW_ARANGO_EXCEPTION(TRI_ERROR_OUT_OF_MEMORY); THROW_ARANGO_EXCEPTION(TRI_ERROR_OUT_OF_MEMORY);
} }
try { try {
ExecutionNode* newNode = new IndexRangeNode(newPlan, newPlan->nextId(), node->vocbase(), ExecutionNode* newNode = new IndexRangeNode(newPlan,
node->collection(), node->outVariable(), idx, rangeInfo, false); newPlan->nextId(), node->vocbase(),
node->collection(), node->outVariable(), idx,
indexOrCondition, false);
newPlan->registerNode(newNode); newPlan->registerNode(newNode);
newPlan->replaceNode(newPlan->getNodeById(node->id()), newNode); newPlan->replaceNode(newPlan->getNodeById(node->id()), newNode);
_opt->addPlan(newPlan, _level, true); _opt->addPlan(newPlan, _level, true);
@ -1065,6 +1080,7 @@ class FilterToEnumCollFinder : public WalkerWorker<ExecutionNode> {
} }
} }
} }
}
break; break;
} }
} }
@ -1073,7 +1089,7 @@ class FilterToEnumCollFinder : public WalkerWorker<ExecutionNode> {
////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////
void buildRangeInfo (AstNode const* node, void buildRangeInfoAND (AstNode const* node,
Variable const*& enumCollVar, Variable const*& enumCollVar,
std::string& attr) { std::string& attr) {
if (node->type == NODE_TYPE_REFERENCE) { if (node->type == NODE_TYPE_REFERENCE) {
@ -1087,7 +1103,7 @@ class FilterToEnumCollFinder : public WalkerWorker<ExecutionNode> {
} }
if (node->type == NODE_TYPE_ATTRIBUTE_ACCESS) { if (node->type == NODE_TYPE_ATTRIBUTE_ACCESS) {
buildRangeInfo(node->getMember(0), enumCollVar, attr); buildRangeInfoAND(node->getMember(0), enumCollVar, attr);
if (enumCollVar != nullptr) { if (enumCollVar != nullptr) {
char const* attributeName = node->getStringValue(); char const* attributeName = node->getStringValue();
@ -1101,7 +1117,7 @@ class FilterToEnumCollFinder : public WalkerWorker<ExecutionNode> {
auto lhs = node->getMember(0); auto lhs = node->getMember(0);
auto rhs = node->getMember(1); auto rhs = node->getMember(1);
if (rhs->type == NODE_TYPE_ATTRIBUTE_ACCESS) { if (rhs->type == NODE_TYPE_ATTRIBUTE_ACCESS) {
buildRangeInfo(rhs, enumCollVar, attr); buildRangeInfoAND(rhs, enumCollVar, attr);
if (enumCollVar != nullptr) { if (enumCollVar != nullptr) {
std::unordered_set<Variable*> varsUsed std::unordered_set<Variable*> varsUsed
= Ast::getReferencedVariables(lhs); = Ast::getReferencedVariables(lhs);
@ -1109,10 +1125,12 @@ class FilterToEnumCollFinder : public WalkerWorker<ExecutionNode> {
== varsUsed.end()) { == varsUsed.end()) {
// Found a multiple attribute access of a variable and an // Found a multiple attribute access of a variable and an
// expression which does not involve that variable: // expression which does not involve that variable:
_ranges->insert(enumCollVar->name, _rangeInfoMapVec->insertAnd(enumCollVar->name,
attr.substr(0, attr.size() - 1), attr.substr(0, attr.size() - 1),
RangeInfoBound(lhs, true), RangeInfoBound(lhs, true),
RangeInfoBound(lhs, true), true); RangeInfoBound(lhs, true), true);
// FIXME: this is not the right thing in general, how do we know
// this is an AND at this point?
} }
enumCollVar = nullptr; enumCollVar = nullptr;
attr.clear(); attr.clear();
@ -1120,7 +1138,7 @@ class FilterToEnumCollFinder : public WalkerWorker<ExecutionNode> {
} }
if (lhs->type == NODE_TYPE_ATTRIBUTE_ACCESS) { if (lhs->type == NODE_TYPE_ATTRIBUTE_ACCESS) {
buildRangeInfo(lhs, enumCollVar, attr); buildRangeInfoAND(lhs, enumCollVar, attr);
if (enumCollVar != nullptr) { if (enumCollVar != nullptr) {
std::unordered_set<Variable*> varsUsed std::unordered_set<Variable*> varsUsed
= Ast::getReferencedVariables(rhs); = Ast::getReferencedVariables(rhs);
@ -1128,7 +1146,7 @@ class FilterToEnumCollFinder : public WalkerWorker<ExecutionNode> {
== varsUsed.end()) { == varsUsed.end()) {
// Found a multiple attribute access of a variable and an // Found a multiple attribute access of a variable and an
// expression which does not involve that variable: // expression which does not involve that variable:
_ranges->insert(enumCollVar->name, _rangeInfoMapVec->insertAND(enumCollVar->name,
attr.substr(0, attr.size() - 1), attr.substr(0, attr.size() - 1),
RangeInfoBound(rhs, true), RangeInfoBound(rhs, true),
RangeInfoBound(rhs, true), true); RangeInfoBound(rhs, true), true);
@ -1155,7 +1173,7 @@ class FilterToEnumCollFinder : public WalkerWorker<ExecutionNode> {
// Attribute access on the right: // Attribute access on the right:
// First find out whether there is a multiple attribute access // First find out whether there is a multiple attribute access
// of a variable on the right: // of a variable on the right:
buildRangeInfo(rhs, enumCollVar, attr); buildRangeInfoAND(rhs, enumCollVar, attr);
if (enumCollVar != nullptr) { if (enumCollVar != nullptr) {
RangeInfoBound low; RangeInfoBound low;
RangeInfoBound high; RangeInfoBound high;
@ -1168,7 +1186,8 @@ class FilterToEnumCollFinder : public WalkerWorker<ExecutionNode> {
else { else {
low.assign(lhs, include); low.assign(lhs, include);
} }
_ranges->insert(enumCollVar->name, attr.substr(0, attr.size() - 1), _rangeInfoMapVec->insertAND(enumCollVar->name,
attr.substr(0, attr.size() - 1),
low, high, false); low, high, false);
enumCollVar = nullptr; enumCollVar = nullptr;
@ -1180,7 +1199,7 @@ class FilterToEnumCollFinder : public WalkerWorker<ExecutionNode> {
// Attribute access on the left: // Attribute access on the left:
// First find out whether there is a multiple attribute access // First find out whether there is a multiple attribute access
// of a variable on the left: // of a variable on the left:
buildRangeInfo(lhs, enumCollVar, attr); buildRangeInfoAND(lhs, enumCollVar, attr);
if (enumCollVar != nullptr) { if (enumCollVar != nullptr) {
RangeInfoBound low; RangeInfoBound low;
RangeInfoBound high; RangeInfoBound high;
@ -1193,7 +1212,7 @@ class FilterToEnumCollFinder : public WalkerWorker<ExecutionNode> {
else { else {
high.assign(rhs, include); high.assign(rhs, include);
} }
_ranges->insert(enumCollVar->name, attr.substr(0, attr.size() - 1), _rangeInfoMapVec->insertAND(enumCollVar->name, attr.substr(0, attr.size() - 1),
low, high, false); low, high, false);
enumCollVar = nullptr; enumCollVar = nullptr;
@ -1205,10 +1224,10 @@ class FilterToEnumCollFinder : public WalkerWorker<ExecutionNode> {
} }
if (node->type == NODE_TYPE_OPERATOR_BINARY_AND) { if (node->type == NODE_TYPE_OPERATOR_BINARY_AND) {
buildRangeInfo(node->getMember(0), enumCollVar, attr); buildRangeInfoAND(node->getMember(0), enumCollVar, attr);
buildRangeInfo(node->getMember(1), enumCollVar, attr); buildRangeInfoAND(node->getMember(1), enumCollVar, attr);
} }
if (node->type == NODE_TYPE_OPERATOR_BINARY_IN) { /*if (node->type == NODE_TYPE_OPERATOR_BINARY_IN) {
auto lhs = node->getMember(0); // enumCollVar auto lhs = node->getMember(0); // enumCollVar
auto rhs = node->getMember(1); // value auto rhs = node->getMember(1); // value
@ -1220,13 +1239,13 @@ class FilterToEnumCollFinder : public WalkerWorker<ExecutionNode> {
RangeInfoBound low(rhs->getMember(i), true); RangeInfoBound low(rhs->getMember(i), true);
RangeInfoBound high(rhs->getMember(i), true); RangeInfoBound high(rhs->getMember(i), true);
//FIXME don't assume this is constant //FIXME don't assume this is constant
_ranges->insert(enumCollVar->name, attr.substr(0, attr.size() - 1), _rangeInfoMapVec->insert(enumCollVar->name, attr.substr(0, attr.size() - 1),
low, high, true); low, high, true);
} }
enumCollVar = nullptr; enumCollVar = nullptr;
attr.clear(); attr.clear();
} }
} }*/
// default case // default case
attr.clear(); attr.clear();
enumCollVar = nullptr; enumCollVar = nullptr;

81
arangod/Aql/RangeInfo.cpp
View File

@ -285,6 +285,32 @@ void RangeInfo::fuse (RangeInfo const& that) {
} }
} }
bool RangeInfoMap::isValid (std::string const& var) {
// are all the range infos valid?
std::unordered_map<std::string, RangeInfo>* map = find(var);
if (map != nullptr) {
for(auto x: *map) {
if (! x.second.isValid()) {
return false;
}
}
return true;
}
return false;
}
std::unordered_set<std::string> RangeInfoMap::attributes (std::string const& var) {
std::unordered_set<std::string> attrs;
std::unordered_map<std::string, RangeInfo>* map = find(var);
if (map != nullptr) {
for(auto x: *map) {
attrs.insert(x.first);
}
}
return attrs;
}
RangeInfoMap* RangeInfoMap::clone () { RangeInfoMap* RangeInfoMap::clone () {
auto rim = new RangeInfoMap(); auto rim = new RangeInfoMap();
for (auto x: _ranges) { for (auto x: _ranges) {
@ -307,6 +333,7 @@ RangeInfoMap* RangeInfoMap::cloneExcluding (std::string const& var) {
return rim; return rim;
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
/// @brief insert if there is no range corresponding to variable name <var>, /// @brief insert if there is no range corresponding to variable name <var>,
/// and attribute <name>, and otherwise intersection with existing range /// and attribute <name>, and otherwise intersection with existing range
@ -320,8 +347,59 @@ void RangeInfoMap::insert (std::string const& var,
insert(RangeInfo(var, name, low, high, equality)); insert(RangeInfo(var, name, low, high, equality));
} }
void RangeInfoMap::eraseEmptyOrUndefined(std::string const& var) {
std::unordered_map<std::string, RangeInfo>* map = find(var);
if (map != nullptr) {
for (auto it = map->begin(); it != map->end(); /* no hoisting */ ) {
if (it->second._lows.empty() &&
it->second._highs.empty() &&
! it->second._lowConst.isDefined() &&
! it->second._highConst.isDefined()) {
it = map->erase(it);
}
else {
it++;
}
}
}
}
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// FIXME maybe this is unnecessary, it should be that the return value here is
// independent of pos, i.e that every entry in the vec has the same attributes??
std::unordered_set<std::string> RangeInfoMapVec::attributes (std::string const& var, size_t pos) {
TRI_ASSERT(pos < _rangeInfoMapVec.size());
return _rangeInfoMapVec[pos].attributes(var);
}
void RangeInfoMapVec::validPositions(std::string const& var) {
std::vector<size_t> valid;
for (i = 0; i < _rangeInfoMapVec.size(); i++) {
if (_rangeInfoMapVec[i].isValid(var)) {
valid.push_back(i);
}
}
return valid;
}
void RangeInfoMapVec::eraseEmptyOrUndefined(std::string const& var) {
for (RangeInfoMap x: _rangeInfoMapVec) {
x.eraseEmptyOrUndefined(var);
}
}
std::unordered_map<std::string, RangeInfo>* find (std::string const& var, size_t pos) {
if (pos >= _rangeInfoMapVec.size()) {
return nullptr;
}
return _rangeInfoMapVec[pos].find(var);
}
void RangeInfoMapVec::insertAnd (std::string const& var, void RangeInfoMapVec::insertAnd (std::string const& var,
std::string const& name, std::string const& name,
RangeInfoBound low, RangeInfoBound low,
@ -333,7 +411,8 @@ void RangeInfoMapVec::insertAnd (std::string const& var,
// var.attr > 1 and var.attr < 10 // var.attr > 1 and var.attr < 10
void RangeInfoMapVec::insertAnd (RangeInfo range) { void RangeInfoMapVec::insertAnd (RangeInfo range) {
// maybe have to add a new RangeInfoMap if the _rangeInfoMapVec is empty...
// FIXME
for (size_t i = 0; i < _rangeInfoMapVec.size(); i++) { for (size_t i = 0; i < _rangeInfoMapVec.size(); i++) {
_rangeInfoMapVec[i]->insert(range); _rangeInfoMapVec[i]->insert(range);
} }

9
arangod/Aql/RangeInfo.h
View File

@ -648,6 +648,8 @@ namespace triagens {
RangeInfoMap* clone (); RangeInfoMap* clone ();
RangeInfoMap* cloneExcluding (std::string const&); RangeInfoMap* cloneExcluding (std::string const&);
void eraseEmptyOrUndefined (std::string const&);
bool isValid ();
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
/// @brief private data /// @brief private data
@ -704,6 +706,7 @@ namespace triagens {
return list; return list;
} }
void eraseEmptyOrUndefined (std::string const&);
void insertAnd (std::string const& var, void insertAnd (std::string const& var,
std::string const& name, std::string const& name,
RangeInfoBound low, RangeInfoBound low,
@ -717,13 +720,17 @@ namespace triagens {
void insertDistributeAndIntoOr (std::vector<RangeInfo> ranges); void insertDistributeAndIntoOr (std::vector<RangeInfo> ranges);
std::unordered_map<std::string, RangeInfo>* find (std::string const& var, size_t pos);
std::vector<size_t> validPositions ();
// in what positions are the RangeInfoMaps in the vector valid
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
/// @brief private data /// @brief private data
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
private: private:
std::vector<RangeInfoMap*> _rangeInfoMapVec; std::vector<RangeInfoMap*> _rangeInfoMapVec;
}; };
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////