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

pass queryRegistry into the AQL functions

This commit is contained in:
Jan Steemann 2014-09-29 09:30:32 +02:00
parent d177bc110c
commit 0d075dca3f
14 changed files with 76 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
arangod/Aql/ExecutionEngine.cpp
View File

@ -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));

4
arangod/Aql/ExecutionEngine.h
View File

@ -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*);

2
arangod/Aql/Optimizer.cpp
View File

@ -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,

2
arangod/Aql/OptimizerRules.cpp
View File

@ -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 = {

8
arangod/Aql/Query.cpp
View File

@ -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 res = prepare();
QueryResult Query::execute (QueryRegistry* registry) {
QueryResult res = prepare(registry);
if (res.code != TRI_ERROR_NO_ERROR) {
return res;
}

15
arangod/Aql/Query.h
View File

@ -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

4
arangod/Aql/RestAqlHandler.cpp
View File

@ -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);

11
arangod/RestServer/ArangoServer.cpp
View File

@ -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;

5
arangod/V8Server/ApplicationV8.cpp
View File

@ -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);

13
arangod/V8Server/ApplicationV8.h
View File

@ -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
///

17
arangod/V8Server/v8-vocbase.cpp
View File

@ -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();
auto queryResult = query.execute(static_cast<triagens::aql::QueryRegistry*>(v8g->_queryRegistry));
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();
auto queryResult = query.execute(static_cast<triagens::aql::QueryRegistry*>(v8g->_queryRegistry));
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;

7
arangod/V8Server/v8-vocbase.h
View File

@ -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

11
lib/V8/v8-globals.cpp
View File

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

6
lib/V8/v8-globals.h
View File

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