pass queryRegistry into the AQL functions

arangod/Aql/ExecutionEngine.cpp

@@ -531,7 +531,8 @@ void ExecutionEngine::addBlock (ExecutionBlock* block) {
 /// @brief create an execution engine from a plan
 ////////////////////////////////////////////////////////////////////////////////
 
-ExecutionEngine* ExecutionEngine::instanciateFromPlan (AQL_TRANSACTION_V8* trx,
+ExecutionEngine* ExecutionEngine::instanciateFromPlan (QueryRegistry* registry,
+                                                       AQL_TRANSACTION_V8* trx,
                                                        Query* query,
                                                        ExecutionPlan* plan) {
   ExecutionEngine* engine = nullptr;
@@ -543,7 +544,7 @@ ExecutionEngine* ExecutionEngine::instanciateFromPlan (AQL_TRANSACTION_V8* trx,
 
     ExecutionBlock* root = nullptr;
 
-    if (triagens::arango::ServerState::instance()->isCoordinator()) {
+    if (true || triagens::arango::ServerState::instance()->isCoordinator()) {
       // instanciate the engine on the coordinator
       // TODO: must pass an instance of query registry to the coordinator instanciator!
       std::unique_ptr<CoordinatorInstanciator> inst(new CoordinatorInstanciator(trx, query, nullptr));

arangod/Aql/ExecutionEngine.h

@@ -36,6 +36,7 @@
 #include "arangod/Aql/ExecutionBlock.h"
 #include "arangod/Aql/ExecutionPlan.h"
 #include "arangod/Aql/ExecutionStats.h"
+#include "arangod/Aql/QueryRegistry.h"
 #include "Utils/AqlTransaction.h"
 
 namespace triagens {
@@ -76,7 +77,8 @@ namespace triagens {
 // @brief create an execution engine from a plan
 ////////////////////////////////////////////////////////////////////////////////
 
-        static ExecutionEngine* instanciateFromPlan (AQL_TRANSACTION_V8*,
+        static ExecutionEngine* instanciateFromPlan (QueryRegistry*, 
+                                                     AQL_TRANSACTION_V8*,
                                                      Query*,
                                                      ExecutionPlan*);
 

arangod/Aql/Optimizer.cpp

@@ -447,7 +447,7 @@ void Optimizer::setupRules () {
                useIndexForSort_pass6,
                true);
 
-  if (triagens::arango::ServerState::instance()->isCoordinator()) {
+  if (true || triagens::arango::ServerState::instance()->isCoordinator()) {
     // distribute operations in cluster
     registerRule("distribute-in-cluster",
                  distributeInCluster,

arangod/Aql/OptimizerRules.cpp

@@ -1615,7 +1615,7 @@ int triagens::aql::distributeInCluster (Optimizer* opt,
                                         Optimizer::Rule const* rule) {
   bool wasModified = false;
 
-  if (triagens::arango::ServerState::instance()->isCoordinator()) {
+  if (true  ||  triagens::arango::ServerState::instance()->isCoordinator()) {
     // we are a coordinator. now look in the plan for nodes of type
     // EnumerateCollectionNode and IndexRangeNode
     std::vector<ExecutionNode::NodeType> const types = { 

arangod/Aql/Query.cpp

@@ -300,7 +300,7 @@ void Query::registerError (int code,
 /// QueryRegistry.
 ////////////////////////////////////////////////////////////////////////////////
 
-QueryResult Query::prepare () {
+QueryResult Query::prepare (QueryRegistry* registry) {
   enterState(PARSING);
 
   try {
@@ -383,7 +383,7 @@ QueryResult Query::prepare () {
     TRI_ASSERT(otherJsonString == JsonString); */
 
     enterState(EXECUTION);
-    ExecutionEngine* engine(ExecutionEngine::instanciateFromPlan(trx.get(), this, plan.get()));
+    ExecutionEngine* engine(ExecutionEngine::instanciateFromPlan(registry, trx.get(), this, plan.get()));
 
     // If all went well so far, then we keep _plan, _parser and _trx and
     // return:
@@ -415,8 +415,8 @@ QueryResult Query::prepare () {
 /// @brief execute an AQL query 
 ////////////////////////////////////////////////////////////////////////////////
 
-QueryResult Query::execute () {
+QueryResult Query::execute (QueryRegistry* registry) {
-  QueryResult res = prepare();
+  QueryResult res = prepare(registry);
   if (res.code != TRI_ERROR_NO_ERROR) {
     return res;
   }

arangod/Aql/Query.h

@@ -44,14 +44,15 @@ struct TRI_vocbase_s;
 namespace triagens {
   namespace aql {
 
-    class Executor;
-    class Expression;
-    struct Variable;
     struct AstNode;
     class Ast;
-    class ExecutionPlan;
-    class Parser;
     class ExecutionEngine;
+    class ExecutionPlan;
+    class Executor;
+    class Expression;
+    class Parser;
+    class QueryRegistry;
+    struct Variable;
 
 // -----------------------------------------------------------------------------
 // --SECTION--                                                      public types
@@ -245,13 +246,13 @@ namespace triagens {
 /// QueryRegistry.
 ////////////////////////////////////////////////////////////////////////////////
 
-        QueryResult prepare ();
+        QueryResult prepare (QueryRegistry*);
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief execute an AQL query 
 ////////////////////////////////////////////////////////////////////////////////
 
-        QueryResult execute ();
+        QueryResult execute (QueryRegistry*);
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief parse an AQL query

arangod/Aql/RestAqlHandler.cpp

@@ -128,7 +128,7 @@ void RestAqlHandler::createQueryFromJson () {
   options = queryJson.get("options").copy();
 
   auto query = new Query(vocbase, plan, options.steal());
-  QueryResult res = query->prepare();
+  QueryResult res = query->prepare(_queryRegistry);
   if (res.code != TRI_ERROR_NO_ERROR) {
     generateError(HttpResponse::BAD, TRI_ERROR_QUERY_BAD_JSON_PLAN,
       res.details);
@@ -319,7 +319,7 @@ void RestAqlHandler::createQueryFromString () {
 
   auto query = new Query(vocbase, queryString.c_str(), queryString.size(),
                          parameters.steal(), options.steal());
-  QueryResult res = query->prepare();
+  QueryResult res = query->prepare(_queryRegistry);
   if (res.code != TRI_ERROR_NO_ERROR) {
     generateError(HttpResponse::BAD, TRI_ERROR_QUERY_BAD_JSON_PLAN,
       res.details);

arangod/RestServer/ArangoServer.cpp

@@ -391,12 +391,19 @@ void ArangoServer::buildApplicationServer () {
   _applicationDispatcher->setApplicationScheduler(_applicationScheduler);
 
   _applicationServer->addFeature(_applicationScheduler);
+  
+  // ...........................................................................
+  // create QueryRegistry
+  // ...........................................................................
+
+  _queryRegistry = new aql::QueryRegistry();
 
   // .............................................................................
   // V8 engine
   // .............................................................................
 
   _applicationV8 = new ApplicationV8(_server,
+                                     _queryRegistry,
                                      _applicationScheduler,
                                      _applicationDispatcher);
 
@@ -838,11 +845,7 @@ int ArangoServer::startupServer () {
     _applicationV8->prepareServer();
   }
 
-  // ...........................................................................
-  // create QueryRegistry
-  // ...........................................................................
 
-  _queryRegistry = new aql::QueryRegistry();
   _pairForAql = new std::pair<ApplicationV8*, aql::QueryRegistry*>;
   _pairForAql->first = _applicationV8;
   _pairForAql->second = _queryRegistry;

arangod/V8Server/ApplicationV8.cpp

@@ -30,6 +30,7 @@
 #include "ApplicationV8.h"
 
 #include "Actions/actions.h"
+#include "Aql/QueryRegistry.h"
 #include "ApplicationServer/ApplicationServer.h"
 #include "Basics/ConditionLocker.h"
 #include "Basics/FileUtils.h"
@@ -269,10 +270,12 @@ void ApplicationV8::V8Context::handleCancelationCleanup () {
 ////////////////////////////////////////////////////////////////////////////////
 
 ApplicationV8::ApplicationV8 (TRI_server_t* server,
+                              triagens::aql::QueryRegistry* queryRegistry,
                               ApplicationScheduler* scheduler,
                               ApplicationDispatcher* dispatcher)
   : ApplicationFeature("V8"),
     _server(server),
+    _queryRegistry(queryRegistry),
     _startupPath(),
     _appPath(),
     _devAppPath(),
@@ -1221,7 +1224,7 @@ bool ApplicationV8::prepareV8Instance (const string& name, size_t i, bool useAct
 
   context->_context->Enter();
 
-  TRI_InitV8VocBridge(context->_context, _server, _vocbase, &_startupLoader, i);
+  TRI_InitV8VocBridge(context->_context, _queryRegistry, _server, _vocbase, &_startupLoader, i);
   TRI_InitV8Queries(context->_context);
   TRI_InitV8UserStructures(context->_context);
 

arangod/V8Server/ApplicationV8.h

@@ -47,6 +47,10 @@ struct TRI_server_s;
 struct TRI_vocbase_s;
 
 namespace triagens {
+  namespace aql {
+    class QueryRegistry;
+  }
+
   namespace basics {
     class Thread;
   }
@@ -249,6 +253,7 @@ namespace triagens {
 ////////////////////////////////////////////////////////////////////////////////
 
         ApplicationV8 (struct TRI_server_s*,
+                       triagens::aql::QueryRegistry*,
                        rest::ApplicationScheduler*,
                        rest::ApplicationDispatcher*);
 
@@ -447,12 +452,20 @@ namespace triagens {
 // --SECTION--                                                 private variables
 // -----------------------------------------------------------------------------
 
+      private:
+
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief server object
 ////////////////////////////////////////////////////////////////////////////////
 
         struct TRI_server_s* _server;
 
+////////////////////////////////////////////////////////////////////////////////
+/// @brief query registry object
+////////////////////////////////////////////////////////////////////////////////
+
+        triagens::aql::QueryRegistry* _queryRegistry;
+
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief path to the directory containing the startup scripts
 /// 

arangod/V8Server/v8-vocbase.cpp

@@ -39,6 +39,7 @@
 #include "Ahuacatl/ahuacatl-result.h"
 #include "Ahuacatl/ahuacatl-explain.h"
 #include "Aql/Query.h"
+#include "Aql/QueryRegistry.h"
 #include "Basics/Utf8Helper.h"
 
 #include "Basics/conversions.h"
@@ -996,9 +997,10 @@ static v8::Handle<v8::Value> JS_ExecuteAqlJson (v8::Arguments const& argv) {
     options = TRI_ObjectToJson(argv[1]);
   }
 
+  TRI_v8_global_t* v8g = static_cast<TRI_v8_global_t*>(v8::Isolate::GetCurrent()->GetData());
+
   triagens::aql::Query query(vocbase, Json(TRI_UNKNOWN_MEM_ZONE, queryjson), options);
-  
+  auto queryResult = query.execute(static_cast<triagens::aql::QueryRegistry*>(v8g->_queryRegistry));
-  auto queryResult = query.execute();
   
   if (queryResult.code != TRI_ERROR_NO_ERROR) {
     TRI_V8_EXCEPTION_FULL(scope, queryResult.code, queryResult.details);
@@ -1130,11 +1132,12 @@ static v8::Handle<v8::Value> JS_ExecuteAql (v8::Arguments const& argv) {
 
     options = TRI_ObjectToJson(argv[2]);
   }
+      
+  TRI_v8_global_t* v8g = static_cast<TRI_v8_global_t*>(v8::Isolate::GetCurrent()->GetData());
 
   // bind parameters will be freed by the query later
   triagens::aql::Query query(vocbase, queryString.c_str(), queryString.size(), parameters, options);
-  
+  auto queryResult = query.execute(static_cast<triagens::aql::QueryRegistry*>(v8g->_queryRegistry));
-  auto queryResult = query.execute();
   
   if (queryResult.code != TRI_ERROR_NO_ERROR) {
     TRI_V8_EXCEPTION_FULL(scope, queryResult.code, queryResult.details);
@@ -2482,16 +2485,20 @@ void TRI_V8ReloadRouting (v8::Handle<v8::Context> context) {
 ////////////////////////////////////////////////////////////////////////////////
 
 void TRI_InitV8VocBridge (v8::Handle<v8::Context> context,
+                          triagens::aql::QueryRegistry* queryRegistry,
                           TRI_server_t* server,
                           TRI_vocbase_t* vocbase,
                           JSLoader* loader,
-                          const size_t threadNumber) {
+                          size_t threadNumber) {
   v8::HandleScope scope;
 
   // check the isolate
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   TRI_v8_global_t* v8g = TRI_CreateV8Globals(isolate);
 
+  // register the query registry
+  v8g->_queryRegistry = queryRegistry;
+
   // register the server
   v8g->_server = server;
 

arangod/V8Server/v8-vocbase.h

@@ -40,6 +40,10 @@ struct TRI_server_s;
 struct TRI_vocbase_s;
 
 namespace triagens {
+  namespace aql {
+    class QueryRegistry;
+  }
+
   namespace arango {
     class CollectionNameResolver;
     class JSLoader;
@@ -92,10 +96,11 @@ void TRI_V8ReloadRouting (v8::Handle<v8::Context>);
 ////////////////////////////////////////////////////////////////////////////////
 
 void TRI_InitV8VocBridge (v8::Handle<v8::Context>,
+                          triagens::aql::QueryRegistry*,
                           struct TRI_server_s*,
                           struct TRI_vocbase_s*,
                           triagens::arango::JSLoader*,
-                          const size_t);
+                          size_t);
 
 #endif
 

lib/V8/v8-globals.cpp

@@ -127,13 +127,14 @@ TRI_v8_global_s::TRI_v8_global_s (v8::Isolate* isolate)
 
     _currentRequest(0),
     _currentResponse(0),
-    _currentTransaction(0),
+    _currentTransaction(nullptr),
-    _resolver(0),
+    _queryRegistry(nullptr),
-    _server(0),
+    _resolver(nullptr),
-    _vocbase(0),
+    _server(nullptr),
+    _vocbase(nullptr),
     _allowUseDatabase(true),
     _hasDeadObjects(false),
-    _loader(0),
+    _loader(nullptr),
     _canceled(false) {
   v8::HandleScope scope;
 

lib/V8/v8-globals.h

@@ -770,6 +770,12 @@ typedef struct TRI_v8_global_s {
 
   void* _currentTransaction;
 
+////////////////////////////////////////////////////////////////////////////////
+/// @brief query registry
+////////////////////////////////////////////////////////////////////////////////
+
+  void* _queryRegistry;
+
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief resolver of currently running transaction
 ////////////////////////////////////////////////////////////////////////////////