snapshot

arangod/Aql/OptimizerRules.cpp

@@ -778,7 +778,7 @@ int triagens::aql::removeUnnecessaryCalculationsRule (Optimizer* opt,
 ////////////////////////////////////////////////////////////////////////////////
 
 class FilterToEnumCollFinder : public WalkerWorker<ExecutionNode> {
-  RangeInfoMap* _ranges;
+  RangeInfoMapVec* _rangeInfoMapVec;
   Optimizer* _opt;
   ExecutionPlan* _plan;
   std::unordered_set<VariableId> _varIds;
@@ -795,12 +795,12 @@ class FilterToEnumCollFinder : public WalkerWorker<ExecutionNode> {
         _plan(plan), 
         _canThrow(false),
         _level(level) {
-      _ranges = new RangeInfoMap();
+      _rangeInfoMapVec = new RangeInfoMap();
       _varIds.insert(var->id);
     };
 
     ~FilterToEnumCollFinder () {
-      delete _ranges;
+      delete _rangeInfoMapVec;
     }
 
     bool before (ExecutionNode* en) override final {
@@ -858,7 +858,7 @@ class FilterToEnumCollFinder : public WalkerWorker<ExecutionNode> {
           auto node = static_cast<EnumerateCollectionNode*>(en);
           auto var = node->getVariablesSetHere()[0];  // should only be 1
           std::unordered_map<std::string, RangeInfo>* map
-              = _ranges->find(var->name);        
+              = _rangeInfoMapVec->find(var->name);        
               // check if we have any ranges with this var
 
           if (map != nullptr) {

arangod/Aql/RangeInfo.cpp

@@ -285,6 +285,28 @@ void RangeInfo::fuse (RangeInfo const& that) {
   }
 }
 
+RangeInfoMap* RangeInfoMap::clone () {
+  auto rim = new RangeInfoMap();
+  for (auto x: _ranges) {
+    for (auto y: x.second) {
+      rim->insert(y.second.clone());
+    }
+  }
+  return rim;
+}
+
+RangeInfoMap* RangeInfoMap::cloneExcluding (std::string const& var) {
+  auto rim = new RangeInfoMap();
+  for (auto x: _ranges) {
+    if (x.first.compare(var) != 0) {
+      for (auto y: x.second) {
+        rim->insert(y.second.clone());
+      }
+    }
+  }
+  return rim;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief  insert if there is no range corresponding to variable name <var>,
 /// and attribute <name>, and otherwise intersection with existing range
@@ -308,22 +330,52 @@ void RangeInfoMapVec::insertAnd (std::string const& var,
   insertAnd(RangeInfo(var, name, low, high, equality));
 }
 
+// var.attr > 1 and var.attr < 10
+
 void RangeInfoMapVec::insertAnd (RangeInfo range) {
 
-  for (size_t i = 0; i < _rangeInfoMaps.size(); i++) {
-    _rangeInfoMaps[i]->insert(range);
+  for (size_t i = 0; i < _rangeInfoMapVec.size(); i++) {
+    _rangeInfoMapVec[i]->insert(range);
   }
 
 }
 
+// var.attr = 1 or var.attr = 2, all for the same var and attr
+
 void RangeInfoMapVec::insertOr (std::vector<RangeInfo> ranges) {
   
+  RangeInfoMap* sample;
+  if (! _rangeInfoMapVec.empty()) {
+    sample = _rangeInfoMapVec[0];
+  } else {
+    sample = new RangeInfoMap();
+  }
+
   for (auto x: ranges) {
-    auto rangeInfoMap = new RangeInfoMap();
-    rangeInfoMap->insert(x);
-    _rangeInfoMaps.emplace_back(rangeInfoMap);
+    RangeInfoMap* rim = sample->cloneExcluding(x._var); 
+    rim->insert(x);
+    _rangeInfoMapVec.push_back(rim);
   }
 
 }
 
+// var.attr > 1 and (var.attr = 1 or var.attr = 2) = (var.attr > 1 and var.attr = 1) 
+// or (var.attr > 1 and var.attr = 2)
+
+void RangeInfoMapVec::insertDistributeAndIntoOr (std::vector<RangeInfo> ranges) {
+  
+  RangeInfoMap* sample;
+  if (! _rangeInfoMapVec.empty()) {
+    sample = _rangeInfoMapVec[0];
+  } else {
+    sample = new RangeInfoMap();
+  }
+
+  for (auto x: ranges) {
+    RangeInfoMap* rim = sample->clone(); 
+    rim->insert(x); // here we intersect with any existing values
+    _rangeInfoMapVec.push_back(rim);
+  }
+
+}
 

arangod/Aql/RangeInfo.h

@@ -528,6 +528,11 @@ namespace triagens {
           _equality = false;
         }
 
+        RangeInfo clone () {
+          //TODO improve this
+          return RangeInfo(this->toJson());
+        }
+
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief _valid, this is set to true iff the range is known to be non-empty
 ////////////////////////////////////////////////////////////////////////////////
@@ -641,6 +646,9 @@ namespace triagens {
           return list;
         }
         
+        RangeInfoMap* clone ();
+        RangeInfoMap* cloneExcluding (std::string const&);
+
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief private data
 ////////////////////////////////////////////////////////////////////////////////
@@ -651,7 +659,7 @@ namespace triagens {
     };
 
 ////////////////////////////////////////////////////////////////////////////////
-/// @brief class to keep a vector of RangeInfoMaps associated to variable and
+/// @brief class to keep a vector of rangeInfoMapVec associated to variable and
 /// attribute names, which will be or-combined 
 ////////////////////////////////////////////////////////////////////////////////
     
@@ -666,7 +674,7 @@ namespace triagens {
 /// @brief default constructor
 ////////////////////////////////////////////////////////////////////////////////
     
-        RangeInfoMapVec () : _rangeInfoMaps() {
+        RangeInfoMapVec () : _rangeInfoMapVec() {
         }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -690,8 +698,8 @@ namespace triagens {
     
         triagens::basics::Json toJson() const {
           triagens::basics::Json list(triagens::basics::Json::List);
-          for (size_t i = 0; i < _rangeInfoMaps.size(); i++) {
-            list(_rangeInfoMaps[i]->toJson());
+          for (size_t i = 0; i < _rangeInfoMapVec.size(); i++) {
+            list(_rangeInfoMapVec[i]->toJson());
           }
           return list;
         }
@@ -707,12 +715,14 @@ namespace triagens {
         
         void insertOr (std::vector<RangeInfo> ranges);
 
+        void insertDistributeAndIntoOr (std::vector<RangeInfo> ranges);
+
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief private data
 ////////////////////////////////////////////////////////////////////////////////
     
       private: 
-        std::vector<RangeInfoMap*> _rangeInfoMaps; 
+        std::vector<RangeInfoMap*> _rangeInfoMapVec; 
         
     };