From b10ae65d58e351ecfd0947a204e337e8ce0857f6 Mon Sep 17 00:00:00 2001
From: Jan Steemann <jan@arangodb.com>
Date: Wed, 27 Aug 2014 23:53:53 +0200
Subject: [PATCH] rules have names

---
 arangod/Aql/Optimizer.cpp | 18 ++++++++----------
 arangod/Aql/Optimizer.h   |  9 +++++----
 2 files changed, 13 insertions(+), 14 deletions(-)

diff --git a/arangod/Aql/Optimizer.cpp b/arangod/Aql/Optimizer.cpp
index 548ca08ddb..fd2a4ec1b6 100644
--- a/arangod/Aql/Optimizer.cpp
+++ b/arangod/Aql/Optimizer.cpp
@@ -42,26 +42,26 @@ Optimizer::Optimizer () {
   // List all the rules in the system here:
 
   // try to find sort blocks which are superseeded by indexes
-  registerRule (useIndexForSort, 2000);
+  registerRule("use-index-for-sort", useIndexForSort, 2000);
 
 
   // try to find a filter after an enumerate collection and find an index . . . 
-  registerRule(useIndexRange, 999);
+  registerRule("use-index-range", useIndexRange, 999);
 
   // remove filters from the query that are not necessary at all
   // filters that are always true will be removed entirely
   // filters that are always false will be replaced with a NoResults node
-  registerRule(removeUnnecessaryFiltersRule, 100);
+  registerRule("remove-unnecessary-filters", removeUnnecessaryFiltersRule, 100);
   
   // move calculations up the dependency chain (to pull them out of inner loops etc.)
-  registerRule(moveCalculationsUpRule, 1000);
+  registerRule("move-calculations-up", moveCalculationsUpRule, 1000);
 
   // move filters up the dependency chain (to make result sets as small as possible
   // as early as possible)
-  registerRule(moveFiltersUpRule, 1010);
+  registerRule("move-filters-up", moveFiltersUpRule, 1010);
 
   // remove calculations that are never necessary
-  registerRule(removeUnnecessaryCalculationsRule, 1020);
+  registerRule("remove-unnecessary-calculations", removeUnnecessaryCalculationsRule, 1020);
 
   // Now sort them by level:
   std::stable_sort(_rules.begin(), _rules.end());
@@ -112,15 +112,13 @@ int Optimizer::createPlans (ExecutionPlan* plan) {
         newPlans.push_back(p, level);  // nothing to do, just keep it
       }
       else {   // some rule needs applying
-        Rule r(dummyRule, level);
+        Rule r("dummy", dummyRule, level);
         auto it = std::upper_bound(_rules.begin(), _rules.end(), r);
         TRI_ASSERT(it != _rules.end());
-        std::cout << "Trying rule " << &(it->func) << " with level "
+        std::cout << "Trying rule " << it->name << " (" << &(it->func) << ") with level "
                   << it->level << " on plan " << count++
                   << std::endl;
         try {
-          // keep should have a default value so rules that forget to set it
-          // have a deterministic behavior
           res = it->func(this, p, it->level, newPlans);
         }
         catch (...) {
diff --git a/arangod/Aql/Optimizer.h b/arangod/Aql/Optimizer.h
index a1d3c12d97..81b669bf48 100644
--- a/arangod/Aql/Optimizer.h
+++ b/arangod/Aql/Optimizer.h
@@ -187,11 +187,12 @@ namespace triagens {
 ////////////////////////////////////////////////////////////////////////////////
 
         struct Rule {
+          std::string name;
           RuleFunction func;
           int level;
 
-          Rule (RuleFunction f, int l)
-            : func(f), level(l) {
+          Rule (std::string const& name, RuleFunction f, int l)
+            : name(name), func(f), level(l) {
           }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -298,8 +299,8 @@ namespace triagens {
 /// @brief registerRule
 ////////////////////////////////////////////////////////////////////////////////
 
-        void registerRule (RuleFunction f, int level) {
-          _rules.emplace_back(f, level);
+        void registerRule (std::string const& name, RuleFunction f, int level) {
+          _rules.emplace_back(name, f, level);
         }
 
 ////////////////////////////////////////////////////////////////////////////////