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

issue 526.7.1: remove deprecated functions, update tests to set up required analyzers (#8688) 

* issue 526.7.1: remove deprecated functions, update tests to set up required analyzers

* address merge issues

* address more merge issues
This commit is contained in:
Vasiliy 2019-04-05 18:10:42 +03:00 committed by Andrey Abramov
parent 04fe5f816c
commit 0410588723
38 changed files with 649 additions and 832 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
arangod/GeneralServer/GeneralServerFeature.cpp
View File

@ -50,6 +50,7 @@
#include "RestHandler/RestAdminRoutingHandler.h"
#include "RestHandler/RestAdminServerHandler.h"
#include "RestHandler/RestAdminStatisticsHandler.h"
#include "RestHandler/RestAnalyzerHandler.h"
#include "RestHandler/RestAqlFunctionsHandler.h"
#include "RestHandler/RestAqlReloadHandler.h"
#include "RestHandler/RestAqlUserFunctionsHandler.h"
@ -327,6 +328,11 @@ void GeneralServerFeature::defineHandlers() {
// /_api
// ...........................................................................
_handlerFactory->addPrefixHandler( // add handler
RestVocbaseBaseHandler::ANALYZER_PATH, // base URL
RestHandlerCreator<iresearch::RestAnalyzerHandler>::createNoData // handler
);
_handlerFactory->addPrefixHandler(RestVocbaseBaseHandler::BATCH_PATH,
RestHandlerCreator<RestBatchHandler>::createNoData);

149
arangod/IResearch/IResearchAnalyzerFeature.cpp
View File

@ -691,8 +691,7 @@ irs::analysis::analyzer::ptr IResearchAnalyzerFeature::AnalyzerPool::get() const
IResearchAnalyzerFeature::IResearchAnalyzerFeature(arangodb::application_features::ApplicationServer& server)
: ApplicationFeature(server, IResearchAnalyzerFeature::name()),
_analyzers(getStaticAnalyzers()), // load static analyzers
_started(false) {
_analyzers(getStaticAnalyzers()) { // load static analyzers
setOptional(true);
startsAfter("V8Phase");
@ -737,131 +736,6 @@ IResearchAnalyzerFeature::IResearchAnalyzerFeature(arangodb::application_feature
);
}
std::pair<IResearchAnalyzerFeature::AnalyzerPool::ptr, bool> IResearchAnalyzerFeature::emplace(
irs::string_ref const& name, irs::string_ref const& type,
irs::string_ref const& properties, bool initAndPersist,
irs::flags const& features /*= irs::flags::empty_instance()*/
) noexcept {
try {
WriteMutex mutex(_mutex);
SCOPED_LOCK(mutex);
auto generator = [](irs::hashed_string_ref const& key,
AnalyzerPool::ptr const& value) -> irs::hashed_string_ref {
PTR_NAMED(AnalyzerPool, pool, key);
const_cast<AnalyzerPool::ptr&>(value) = pool; // lazy-instantiate pool
return pool ? irs::hashed_string_ref(key.hash(), pool->name())
: key; // reuse hash but point ref at value in pool
};
auto itr = irs::map_utils::try_emplace_update_key(
_analyzers, generator, irs::make_hashed_ref(name, std::hash<irs::string_ref>()));
bool erase = itr.second;
auto cleanup = irs::make_finally([&erase, this, &itr]() -> void {
if (erase) {
_analyzers.erase(itr.first); // ensure no broken analyzers are left behind
}
});
auto pool = itr.first->second;
if (!pool) {
LOG_TOPIC("2bdc6", WARN, arangodb::iresearch::TOPIC)
<< "failure creating an arangosearch analyzer instance for name '"
<< name << "' type '" << type << "' properties '" << properties << "'";
TRI_set_errno(TRI_ERROR_BAD_PARAMETER);
return std::make_pair(AnalyzerPool::ptr(), false);
}
// skip initialization and persistance
if (!initAndPersist) {
erase = false;
return std::make_pair(pool, itr.second);
}
if (itr.second) { // new pool
if (!_started) {
LOG_TOPIC("b8db7", WARN, arangodb::iresearch::TOPIC)
<< "cannot garantee collision-free persistance while creating an "
"arangosearch analyzer instance for name '"
<< name << "' type '" << type << "' properties '" << properties << "'";
TRI_set_errno(TRI_ERROR_ARANGO_ILLEGAL_STATE);
return std::make_pair(AnalyzerPool::ptr(), false);
}
if (!pool->init(type, properties, features)) {
LOG_TOPIC("dfe77", WARN, arangodb::iresearch::TOPIC)
<< "failure initializing an arangosearch analyzer instance for "
"name '"
<< name << "' type '" << type << "' properties '" << properties << "'";
TRI_set_errno(TRI_ERROR_BAD_PARAMETER);
return std::make_pair(AnalyzerPool::ptr(), false);
}
auto res = storeAnalyzer(*pool);
if (!res.ok()) {
LOG_TOPIC("ab445", WARN, arangodb::iresearch::TOPIC)
<< "failure persisting an arangosearch analyzer instance for name '"
<< name << "' type '" << type << "' properties '" << properties
<< "': " << res.errorNumber() << " " << res.errorMessage();
TRI_set_errno(res.errorNumber());
return std::make_pair(AnalyzerPool::ptr(), false);
}
_customAnalyzers[itr.first->first] = itr.first->second; // mark as custom
erase = false;
} else if (type != pool->_type || properties != pool->_properties) {
LOG_TOPIC("f3d4e", WARN, arangodb::iresearch::TOPIC)
<< "name collision detected while registering an arangosearch "
"analizer name '"
<< name << "' type '" << type << "' properties '" << properties
<< "', previous registration type '" << pool->_type
<< "' properties '" << pool->_properties << "'";
TRI_set_errno(TRI_ERROR_BAD_PARAMETER);
return std::make_pair(AnalyzerPool::ptr(), false);
} else if (pool->_key.null()) { // not yet persisted
auto res = storeAnalyzer(*pool);
if (!res.ok()) {
LOG_TOPIC("322a6", WARN, arangodb::iresearch::TOPIC)
<< "failure persisting an arangosearch analyzer instance for name '"
<< name << "' type '" << type << "' properties '" << properties
<< "': " << res.errorNumber() << " " << res.errorMessage();
TRI_set_errno(res.errorNumber());
return std::make_pair(AnalyzerPool::ptr(), false);
}
}
return std::make_pair(pool, itr.second);
} catch (arangodb::basics::Exception& e) {
LOG_TOPIC("ac568", WARN, arangodb::iresearch::TOPIC)
<< "caught exception while registering an arangosearch analizer name '"
<< name << "' type '" << type << "' properties '" << properties
<< "': " << e.code() << " " << e.what();
IR_LOG_EXCEPTION();
} catch (std::exception& e) {
LOG_TOPIC("8f3b4", WARN, arangodb::iresearch::TOPIC)
<< "caught exception while registering an arangosearch analizer name '"
<< name << "' type '" << type << "' properties '" << properties
<< "': " << e.what();
IR_LOG_EXCEPTION();
} catch (...) {
LOG_TOPIC("9030d", WARN, arangodb::iresearch::TOPIC)
<< "caught exception while registering an arangosearch analizer name '"
<< name << "' type '" << type << "' properties '" << properties << "'";
IR_LOG_EXCEPTION();
}
return std::make_pair(AnalyzerPool::ptr(), false);
}
arangodb::Result IResearchAnalyzerFeature::emplace( // emplace an analyzer
EmplaceResult& result, // emplacement result on success (out-parameter)
irs::string_ref const& name, // analyzer name
@ -956,17 +830,6 @@ arangodb::Result IResearchAnalyzerFeature::emplaceAnalyzer( // emplace
return arangodb::Result();
}
IResearchAnalyzerFeature::AnalyzerPool::ptr IResearchAnalyzerFeature::ensure( // get analyzer or placeholder
irs::string_ref const& name // analyzer name
) {
// insert dummy (uninitialized) placeholders if this feature has not been
// started to break the dependency loop on DatabaseFeature
// placeholders will be loaded/validation during start()/loadConfiguration()
return _started
? get(name)
: emplace(name, irs::string_ref::NIL, irs::string_ref::NIL, false).first;
}
arangodb::Result IResearchAnalyzerFeature::ensure( // ensure analyzer existence if possible
EmplaceResult& result, // emplacement result on success (out-param)
irs::string_ref const& name, // analyzer name
@ -1850,22 +1713,14 @@ void IResearchAnalyzerFeature::start() {
if (!res.ok()) {
THROW_ARANGO_EXCEPTION(res);
}
WriteMutex mutex(_mutex);
SCOPED_LOCK(mutex); // '_started' can be asynchronously read
_started = true;
}
void IResearchAnalyzerFeature::stop() {
{
WriteMutex mutex(_mutex);
SCOPED_LOCK(mutex); // '_analyzers'/_customAnalyzers/'_started' can be
// asynchronously read
SCOPED_LOCK(mutex); // '_analyzers' can be asynchronously read
_started = false;
_analyzers = getStaticAnalyzers(); // clear cache and reload static analyzers
_customAnalyzers.clear(); // clear cache
}
ApplicationFeature::stop();

21
arangod/IResearch/IResearchAnalyzerFeature.h
View File

@ -133,16 +133,6 @@ class IResearchAnalyzerFeature final : public arangodb::application_features::Ap
irs::flags const& features = irs::flags::empty_instance() // analyzer features
);
//////////////////////////////////////////////////////////////////////////////
/// @brief get analyzer or placeholder
/// before start() returns pool placeholder,
/// during start() all placeholders are initialized,
/// after start() returns same as get(...)
/// @param name analyzer name (used verbatim)
//////////////////////////////////////////////////////////////////////////////
// FIXME TODO remove
AnalyzerPool::ptr ensure(irs::string_ref const& name);
//////////////////////////////////////////////////////////////////////////////
/// @brief find analyzer
/// @param name analyzer name (already normalized)
@ -208,17 +198,8 @@ class IResearchAnalyzerFeature final : public arangodb::application_features::Ap
typedef std::unordered_map<irs::hashed_string_ref, AnalyzerPool::ptr> Analyzers;
Analyzers _analyzers; // all analyzers known to this feature (including static) (names are stored with expanded vocbase prefixes)
Analyzers _customAnalyzers; // user defined analyzers managed by this feature, a
// subset of '_analyzers' (used for removals)
std::unordered_map<std::string, std::chrono::system_clock::time_point> _lastLoad; // last time a database was loaded
mutable irs::async_utils::read_write_mutex _mutex;
bool _started;
// FIXME TODO remove
std::pair<AnalyzerPool::ptr, bool> emplace(
irs::string_ref const& name, irs::string_ref const& type,
irs::string_ref const& properties, bool initAndPersist,
irs::flags const& features = irs::flags::empty_instance()) noexcept;
mutable irs::async_utils::read_write_mutex _mutex; // for use with member '_analyzers', '_lastLoad'
static Analyzers const& getStaticAnalyzers();

137
arangod/IResearch/IResearchLink.cpp
View File

@ -778,26 +778,29 @@ arangodb::Result IResearchLink::init(
}
builder.close();
std::swap(const_cast<IResearchLinkMeta&>(_meta), meta); // required for IResearchViewCoordinator which calls IResearchLink::properties(...)
if (!view->emplace(_collection.id(), _collection.name(), builder.slice())) {
return arangodb::Result( // result
TRI_ERROR_INTERNAL, // code
std::string("failed to link with view '") + view->name() + "' while initializing link '" + std::to_string(_id) + "'"
);
auto revert = irs::make_finally([this, &meta]()->void { // revert '_meta'
std::swap(const_cast<IResearchLinkMeta&>(_meta), meta);
});
auto res = view->link(*this);
if (!res.ok()) {
return res;
}
}
} else if (arangodb::ServerState::instance()->isDBServer()) { // db-server link
} else if (arangodb::ServerState::instance()->isDBServer()) { // db-server link
auto* ci = arangodb::ClusterInfo::instance();
if (!ci) {
return arangodb::Result(TRI_ERROR_INTERNAL,
std::string("failure to get storage engine while "
"initializing arangosearch link '") +
std::to_string(_id) + "'");
return arangodb::Result( // result
TRI_ERROR_INTERNAL, // code
std::string("failure to get storage engine while initializing arangosearch link '") + std::to_string(_id) + "'"
);
}
auto clusterWideLink = _collection.id() == _collection.planId() &&
_collection.isAStub(); // cluster-wide link
auto clusterWideLink = // cluster-wide link
_collection.id() == _collection.planId() && _collection.isAStub();
if (!clusterWideLink) {
auto res = initDataStore(initCallback); // prepare data-store which can then update options
@ -808,67 +811,63 @@ arangodb::Result IResearchLink::init(
}
}
auto logicalView =
ci->getView(vocbase.name(), viewId); // valid to call ClusterInfo (initialized in
// ClusterFeature::prepare()) even from
// Databasefeature::start()
auto logicalView = ci->getView(vocbase.name(), viewId); // valid to call ClusterInfo (initialized in ClusterFeature::prepare()) even from Databasefeature::start()
// if there is no logicalView present yet then skip this step
if (logicalView) {
if (arangodb::iresearch::DATA_SOURCE_TYPE != logicalView->type()) {
unload(); // unlock the data store directory
return arangodb::Result(TRI_ERROR_ARANGO_DATA_SOURCE_NOT_FOUND,
std::string("error finding view: '") + viewId +
"' for link '" + std::to_string(_id) +
"' : no such view");
unload(); // unlock the data store directory
return arangodb::Result( // result
TRI_ERROR_ARANGO_DATA_SOURCE_NOT_FOUND, // code
std::string("error finding view: '") + viewId + "' for link '" + std::to_string(_id) + "' : no such view"
);
}
auto* view = arangodb::LogicalView::cast<IResearchView>(logicalView.get());
auto* view = // view
arangodb::LogicalView::cast<IResearchView>(logicalView.get());
if (!view) {
unload(); // unlock the data store directory
return arangodb::Result(TRI_ERROR_ARANGO_DATA_SOURCE_NOT_FOUND,
std::string("error finding view: '") + viewId +
"' for link '" + std::to_string(_id) + "'");
unload(); // unlock the data store directory
return arangodb::Result( // result
TRI_ERROR_ARANGO_DATA_SOURCE_NOT_FOUND, // code
std::string("error finding view: '") + viewId + "' for link '" + std::to_string(_id) + "'"
);
}
viewId = view->guid(); // ensue that this is a GUID (required by
// operator==(IResearchView))
viewId = view->guid(); // ensue that this is a GUID (required by operator==(IResearchView))
if (clusterWideLink) { // cluster cluster-wide link
if (clusterWideLink) { // cluster cluster-wide link
auto shardIds = _collection.shardIds();
// go through all shard IDs of the collection and try to link any links
// missing links will be populated when they are created in the
// per-shard collection
if (shardIds) {
for (auto& entry : *shardIds) {
auto collection = vocbase.lookupCollection(
entry.first); // per-shard collections are always in 'vocbase'
for (auto& entry: *shardIds) {
auto collection = vocbase.lookupCollection(entry.first); // per-shard collections are always in 'vocbase'
if (!collection) {
continue; // missing collection should be created after Plan
// becomes Current
continue; // missing collection should be created after Plan becomes Current
}
auto link = IResearchLinkHelper::find(*collection, *view);
if (link && !view->link(link->self())) {
return arangodb::Result(
TRI_ERROR_INTERNAL,
std::string("failed to link with view '") + view->name() +
"' while initializing link '" + std::to_string(_id) +
"', collection '" + collection->name() + "'");
if (link) {
auto res = view->link(link->self());
if (!res.ok()) {
return res;
}
}
}
}
} else { // cluster per-shard link
if (!view->link(_asyncSelf)) {
unload(); // unlock the data store directory
return arangodb::Result(TRI_ERROR_INTERNAL,
std::string("failed to link with view '") + view->name() +
"' while initializing link '" +
std::to_string(_id) + "'");
} else { // cluster per-shard link
auto res = view->link(_asyncSelf);
if (!res.ok()) {
unload(); // unlock the data store directory
return res;
}
}
}
@ -885,31 +884,34 @@ arangodb::Result IResearchLink::init(
// if there is no logicalView present yet then skip this step
if (logicalView) {
if (arangodb::iresearch::DATA_SOURCE_TYPE != logicalView->type()) {
unload(); // unlock the data store directory
return arangodb::Result(TRI_ERROR_ARANGO_DATA_SOURCE_NOT_FOUND,
std::string("error finding view: '") + viewId +
"' for link '" + std::to_string(_id) +
"' : no such view");
unload(); // unlock the data store directory
return arangodb::Result( // result
TRI_ERROR_ARANGO_DATA_SOURCE_NOT_FOUND, // code
std::string("error finding view: '") + viewId + "' for link '" + std::to_string(_id) + "' : no such view"
);
}
auto* view = arangodb::LogicalView::cast<IResearchView>(logicalView.get());
auto* view = // view
arangodb::LogicalView::cast<IResearchView>(logicalView.get());
if (!view) {
unload(); // unlock the data store directory
return arangodb::Result(TRI_ERROR_ARANGO_DATA_SOURCE_NOT_FOUND,
std::string("error finding view: '") + viewId +
"' for link '" + std::to_string(_id) + "'");
unload(); // unlock the data store directory
return arangodb::Result( // result
TRI_ERROR_ARANGO_DATA_SOURCE_NOT_FOUND, // code
std::string("error finding view: '") + viewId + "' for link '" + std::to_string(_id) + "'"
);
}
viewId = view->guid(); // ensue that this is a GUID (required by
// operator==(IResearchView))
viewId = view->guid(); // ensue that this is a GUID (required by operator==(IResearchView))
if (!view->link(_asyncSelf)) {
unload(); // unlock the directory
return arangodb::Result(TRI_ERROR_INTERNAL,
std::string("failed to link with view '") + view->name() +
"' while initializing link '" +
std::to_string(_id) + "'");
auto res = view->link(_asyncSelf);
if (!res.ok()) {
unload(); // unlock the directory
return res;
}
}
}
@ -1485,7 +1487,8 @@ arangodb::Result IResearchLink::properties( // get link properties
arangodb::velocypack::Builder& builder, // output buffer
bool forPersistence // properties for persistance
) const {
if (!builder.isOpenObject() || !_meta.json(builder, forPersistence)) {
if (!builder.isOpenObject() // not an open object
|| !_meta.json(builder, forPersistence, nullptr, &(collection().vocbase()))) {
return arangodb::Result(TRI_ERROR_BAD_PARAMETER);
}
@ -1768,4 +1771,4 @@ arangodb::Result IResearchLink::unload() {
// -----------------------------------------------------------------------------
// --SECTION-- END-OF-FILE
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------

15
arangod/IResearch/IResearchLinkHelper.cpp
View File

@ -663,13 +663,14 @@ namespace iresearch {
);
}
return meta.json(normalized, isCreation) // 'isCreation' is set when forPersistence
? arangodb::Result()
: arangodb::Result(
TRI_ERROR_BAD_PARAMETER,
std::string("error generating arangosearch link normalized definition")
)
;
if (!meta.json(normalized, isCreation, nullptr, &vocbase)) { // 'isCreation' is set when forPersistence
return arangodb::Result( // result
TRI_ERROR_BAD_PARAMETER, // code
"error generating arangosearch link normalized definition" // message
);
}
return arangodb::Result();
}
/*static*/ std::string const& IResearchLinkHelper::type() noexcept {

4
arangod/IResearch/IResearchLinkMeta.cpp
View File

@ -490,7 +490,7 @@ bool IResearchLinkMeta::init( // initialize meta
std::string childErrorField;
if (!_fields[name]->init(value, errorField, defaultVocbase, subDefaults)) {
if (!_fields[name]->init(value, childErrorField, defaultVocbase, subDefaults)) {
errorField = fieldName + "=>" + name + "=>" + childErrorField;
return false;
@ -537,7 +537,7 @@ bool IResearchLinkMeta::json( // append meta jSON
}
name = IResearchAnalyzerFeature::normalize( // normalize
entry->name(), *defaultVocbase, *sysVocbase, false // args
entry->name(), *defaultVocbase, *sysVocbase, writeAnalyzerDefinition // analyzer definitions should always have full names
);
} else {
name = entry->name(); // verbatim (assume already normalized)

53
arangod/IResearch/IResearchView.cpp
View File

@ -602,15 +602,21 @@ arangodb::Result IResearchView::dropImpl() {
return factory;
}
bool IResearchView::link(AsyncLinkPtr const& link) {
arangodb::Result IResearchView::link(AsyncLinkPtr const& link) {
if (!link) {
return false; // invalid link
return arangodb::Result( // result
TRI_ERROR_BAD_PARAMETER, // code
std::string("invalid link parameter while emplacing collection into arangosearch View '") + name() + "'"
);
}
SCOPED_LOCK(link->mutex()); // prevent the link from being deallocated
if (!link->get()) {
return false; // invalid link
return arangodb::Result( // result
TRI_ERROR_BAD_PARAMETER, // code
std::string("failed to aquire link while emplacing collection into arangosearch View '") + name() + "'"
);
}
auto cid = link->get()->collection().id();
@ -625,14 +631,17 @@ bool IResearchView::link(AsyncLinkPtr const& link) {
_links[cid] = link;
link->get()->properties(_meta);
return true; // single-server persisted cid placeholder substituted with actual link
return arangodb::Result(); // single-server persisted cid placeholder substituted with actual link
} else if (itr->second && !itr->second->get()) {
_links[cid] = link;
link->get()->properties(_meta);
return true; // a previous link instance was unload()ed and a new instance is linking
return arangodb::Result(); // a previous link instance was unload()ed and a new instance is linking
} else {
return false; // link already present
return arangodb::Result( // result
TRI_ERROR_ARANGO_DUPLICATE_IDENTIFIER, // code
std::string("duplicate entry while emplacing collection '") + std::to_string(cid) + "' into arangosearch View '" + name() + "'"
);
}
auto res = arangodb::ServerState::instance()->isSingleServer()
@ -642,43 +651,37 @@ bool IResearchView::link(AsyncLinkPtr const& link) {
if (!res.ok()) {
_links.erase(cid); // undo meta modification
LOG_TOPIC("faae3", WARN, arangodb::iresearch::TOPIC)
<< "failed to persist logical view while emplacing collection '" << cid << "' into arangosearch View '" << name() << "': " << res.errorMessage();
return false;
return res;
}
link->get()->properties(_meta);
return true;
return arangodb::Result();
}
arangodb::Result IResearchView::commit() {
ReadMutex mutex(_mutex); // '_links' can be asynchronously updated
ReadMutex mutex(_mutex); // '_links' can be asynchronously updated
SCOPED_LOCK(mutex);
for (auto& entry : _links) {
for (auto& entry: _links) {
auto cid = entry.first;
if (!entry.second) {
return arangodb::Result(
TRI_ERROR_ARANGO_INDEX_HANDLE_BAD,
std::string("failed to find an arangosearch link in collection '") +
std::to_string(cid) + "' while syncing arangosearch view '" +
name() + "'");
return arangodb::Result( // result
TRI_ERROR_ARANGO_INDEX_HANDLE_BAD, // code
std::string("failed to find an arangosearch link in collection '") + std::to_string(cid) + "' while syncing arangosearch view '" + name() + "'"
);
}
SCOPED_LOCK(entry.second->mutex()); // ensure link is not deallocated for
// the duration of the operation
SCOPED_LOCK(entry.second->mutex()); // ensure link is not deallocated for the duration of the operation
auto* link = entry.second->get();
if (!link) {
return arangodb::Result(
TRI_ERROR_ARANGO_INDEX_HANDLE_BAD,
std::string(
"failed to find a loaded arangosearch link in collection '") +
std::to_string(cid) + "' while syncing arangosearch view '" +
name() + "'");
return arangodb::Result( // result
TRI_ERROR_ARANGO_INDEX_HANDLE_BAD, // code
std::string("failed to find a loaded arangosearch link in collection '") + std::to_string(cid) + "' while syncing arangosearch view '" + name() + "'"
);
}
auto res = link->commit();

2
arangod/IResearch/IResearchView.h
View File

@ -127,7 +127,7 @@ class IResearchView final: public arangodb::LogicalView {
/// also track 'cid' via the persisted list of tracked collection IDs
/// @return the 'link' was newly added to the IResearch View
//////////////////////////////////////////////////////////////////////////////
bool link(AsyncLinkPtr const& link);
arangodb::Result link(AsyncLinkPtr const& link);
////////////////////////////////////////////////////////////////////////////////
/// @brief amount of memory in bytes occupied by this iResearch Link

75
arangod/IResearch/IResearchViewCoordinator.cpp
View File

@ -34,6 +34,7 @@
#include "Cluster/ClusterInfo.h"
#include "Cluster/ServerState.h"
#include "IResearch/IResearchFeature.h"
#include "IResearch/IResearchLink.h"
#include "IResearch/VelocyPackHelper.h"
#include "RestServer/ViewTypesFeature.h"
#include "Transaction/Methods.h"
@ -233,47 +234,65 @@ arangodb::Result IResearchViewCoordinator::appendVelocyPackImpl(
return arangodb::Result();
}
bool IResearchViewCoordinator::emplace(TRI_voc_cid_t cid, std::string const& key,
arangodb::velocypack::Slice const& value) {
LOG_TOPIC("d0b40", TRACE, arangodb::iresearch::TOPIC)
<< "beginning IResearchViewCoordinator::emplace";
static const std::function<bool(irs::string_ref const& key)> acceptor =
[](irs::string_ref const& key) -> bool {
return key != arangodb::StaticStrings::IndexId &&
key != arangodb::StaticStrings::IndexType &&
key != StaticStrings::ViewIdField; // ignored fields
/*static*/ arangodb::ViewFactory const& IResearchViewCoordinator::factory() {
static const ViewFactory factory;
return factory;
}
arangodb::Result IResearchViewCoordinator::link(IResearchLink const& link) {
static const std::function<bool(irs::string_ref const& key)> acceptor = []( // acceptor
irs::string_ref const& key // key
) -> bool {
return key != arangodb::StaticStrings::IndexId // ignore index id
&& key != arangodb::StaticStrings::IndexType // ignore index type
&& key != StaticStrings::ViewIdField; // ignore view id
};
arangodb::velocypack::Builder builder;
builder.openObject();
// strip internal keys (added in createLink(...)) from externally visible link
// definition
if (!mergeSliceSkipKeys(builder, value, acceptor)) {
LOG_TOPIC("fe9f7", WARN, iresearch::TOPIC)
<< "failed to generate externally visible link definition while "
"emplacing "
<< "link definition into arangosearch view '" << name()
<< "' collection '" << cid << "'";
auto res = link.properties(builder, false); // generate user-visible definition, agency will not see links
return false;
if (!res.ok()) {
return res;
}
builder.close();
WriteMutex mutex(_mutex);
SCOPED_LOCK(mutex); // '_collections' can be asynchronously read
auto cid = link.collection().id();
arangodb::velocypack::Builder sanitizedBuilder;
return _collections
.emplace(std::piecewise_construct, std::forward_as_tuple(cid),
std::forward_as_tuple(key, std::move(builder)))
.second;
}
sanitizedBuilder.openObject();
/*static*/ arangodb::ViewFactory const& IResearchViewCoordinator::factory() {
static const ViewFactory factory;
// strip internal keys (added in IResearchLink::properties(...)) from externally visible link definition
if (!mergeSliceSkipKeys(sanitizedBuilder, builder.slice(), acceptor)) {
return arangodb::Result( // result
TRI_ERROR_INTERNAL, // code
std::string("failed to generate externally visible link definition while emplacing collection '") + std::to_string(cid) + "' into arangosearch View '" + name() + "'"
);
}
return factory;
sanitizedBuilder.close();
WriteMutex mutex(_mutex); // '_collections' can be asynchronously read
SCOPED_LOCK(mutex);
auto entry = _collections.emplace( // emplace definition
std::piecewise_construct, // piecewise construct
std::forward_as_tuple(cid), // key
std::forward_as_tuple( // value
link.collection().name(), std::move(sanitizedBuilder) // args
)
);
if (!entry.second) {
return arangodb::Result( // result
TRI_ERROR_ARANGO_DUPLICATE_IDENTIFIER, // code
std::string("duplicate entry while emplacing collection '") + std::to_string(cid) + "' into arangosearch View '" + name() + "'"
);
}
return arangodb::Result();
}
arangodb::Result IResearchViewCoordinator::renameImpl(std::string const& oldName) {

24
arangod/IResearch/IResearchViewCoordinator.h
View File

@ -39,6 +39,8 @@ struct ViewFactory; // forward declaration
namespace arangodb {
namespace iresearch {
class IResearchLink; // forward declaration
///////////////////////////////////////////////////////////////////////////////
/// @class IResearchViewCoordinator
/// @brief an abstraction over the distributed IResearch index implementing the
@ -48,24 +50,20 @@ class IResearchViewCoordinator final : public arangodb::LogicalView {
public:
virtual ~IResearchViewCoordinator();
////////////////////////////////////////////////////////////////////////////////
/// @brief acquire locks on the specified 'cid' during read-transactions
/// allowing retrieval of documents contained in the aforementioned
/// collection
/// @note definitions are not persisted
/// @param cid the collection ID to track
/// @param key the key of the link definition for use in appendVelocyPack(...)
/// @param value the link definition to use in appendVelocyPack(...)
/// @return the 'cid' was newly added to the IResearch View
////////////////////////////////////////////////////////////////////////////////
bool emplace(TRI_voc_cid_t cid, std::string const& key,
arangodb::velocypack::Slice const& value);
//////////////////////////////////////////////////////////////////////////////
/// @brief the factory for this type of view
//////////////////////////////////////////////////////////////////////////////
static arangodb::ViewFactory const& factory();
//////////////////////////////////////////////////////////////////////////////
/// @brief acquire locks on the specified 'link' during read-transactions
/// allowing retrieval of documents contained in the aforementioned
/// collection
/// @note definitions are not persisted
/// @return the 'link' was newly added to the IResearch View
//////////////////////////////////////////////////////////////////////////////
arangodb::Result link(IResearchLink const& link);
void open() override {
// NOOP
}

13
arangod/RestHandler/RestAnalyzerHandler.cpp
View File

@ -22,6 +22,7 @@
////////////////////////////////////////////////////////////////////////////////
#include "RestAnalyzerHandler.h"
#include "Basics/StringUtils.h"
#include "ApplicationFeatures/ApplicationServer.h"
#include "IResearch/IResearchAnalyzerFeature.h"
#include "IResearch/VelocyPackHelper.h"
@ -269,15 +270,17 @@ arangodb::RestStatus RestAnalyzerHandler::execute() {
switch (_request->requestType()) {
case arangodb::rest::RequestType::DELETE_REQ:
if (suffixes.size() == 1) {
auto name = arangodb::basics::StringUtils::urlDecode(suffixes[0]);
if (!sysVocbase) {
removeAnalyzer(*analyzers, suffixes[0]); // verbatim (assume already normalized)
removeAnalyzer(*analyzers, name); // verbatim (assume already normalized)
return arangodb::RestStatus::DONE;
}
removeAnalyzer( // remove
*analyzers, // feature
IResearchAnalyzerFeature::normalize(suffixes[0], _vocbase, *sysVocbase) // normalize
IResearchAnalyzerFeature::normalize(name, _vocbase, *sysVocbase) // normalize
);
return arangodb::RestStatus::DONE;
@ -298,15 +301,17 @@ arangodb::RestStatus RestAnalyzerHandler::execute() {
}
if (suffixes.size() == 1) {
auto name = arangodb::basics::StringUtils::urlDecode(suffixes[0]);
if (!sysVocbase) {
getAnalyzer(*analyzers, suffixes[0]);
getAnalyzer(*analyzers, name);
return arangodb::RestStatus::DONE;
}
getAnalyzer( // get
*analyzers, // feature
IResearchAnalyzerFeature::normalize(suffixes[0], _vocbase, *sysVocbase) // normalize
IResearchAnalyzerFeature::normalize(name, _vocbase, *sysVocbase) // normalize
);
return arangodb::RestStatus::DONE;

2
arangod/RestHandler/RestAnalyzerHandler.h
View File

@ -31,7 +31,7 @@ namespace iresearch {
class IResearchAnalyzerFeature; // forward declaration
class RestAnalyzerHandler final: public RestVocbaseBaseHandler {
class RestAnalyzerHandler: public RestVocbaseBaseHandler {
public:
// @note RestHandlerFactory::createHandler(...) passes raw pointers for
// request/response to RestHandlerCreator::createNoData(...)

8
arangod/RestHandler/RestViewHandler.cpp
View File

@ -244,7 +244,7 @@ void RestViewHandler::modifyView(bool partialUpdate) {
return;
}
std::string const& name = suffixes[0];
auto name = arangodb::basics::StringUtils::urlDecode(suffixes[0]);
CollectionNameResolver resolver(_vocbase);
auto view = resolver.getView(name);
@ -392,7 +392,7 @@ void RestViewHandler::deleteView() {
return;
}
std::string const& name = suffixes[0];
auto name = arangodb::basics::StringUtils::urlDecode(suffixes[0]);
auto allowDropSystem = _request->parsedValue("isSystem", false);
auto view = CollectionNameResolver(_vocbase).getView(name);
@ -449,7 +449,9 @@ void RestViewHandler::getViews() {
// /_api/view/<name>[/properties]
if (!suffixes.empty()) {
getView(suffixes[0], suffixes.size() > 1);
auto name = arangodb::basics::StringUtils::urlDecode(suffixes[0]);
getView(name, suffixes.size() > 1);
return;
}

46
arangod/V8Server/v8-analyzers.cpp
View File

@ -654,46 +654,46 @@ void JS_Remove(v8::FunctionCallbackInfo<v8::Value> const& args) {
namespace arangodb {
namespace iresearch {
void TRI_InitV8Analyzers(
v8::Handle<v8::Context> context, // v8 context
TRI_vocbase_t& vocbase, // vocbase
TRI_v8_global_t& v8g, // v8 globals
v8::Isolate& isolate, // v8 isolate
v8::Handle<v8::ObjectTemplate> ArangoDBNS // v8 handler root
) {
void TRI_InitV8Analyzers(TRI_v8_global_t& v8g, v8::Isolate* isolate) {
// 'analyzers' feature functions
{
auto fnTemplate = v8::FunctionTemplate::New(&isolate);
auto fnTemplate = v8::FunctionTemplate::New(isolate);
fnTemplate->SetClassName(TRI_V8_ASCII_STRING(&isolate, "ArangoAnalyzersCtor"));
fnTemplate->SetClassName(TRI_V8_ASCII_STRING(isolate, "ArangoAnalyzersCtor"));
auto objTemplate = fnTemplate->InstanceTemplate();
objTemplate->SetInternalFieldCount(0);
TRI_AddMethodVocbase(&isolate, objTemplate, TRI_V8_ASCII_STRING(&isolate, "analyzer"), JS_Get);
TRI_AddMethodVocbase(&isolate, objTemplate, TRI_V8_ASCII_STRING(&isolate, "remove"), JS_Remove);
TRI_AddMethodVocbase(&isolate, objTemplate, TRI_V8_ASCII_STRING(&isolate, "save"), JS_Create);
TRI_AddMethodVocbase(&isolate, objTemplate, TRI_V8_ASCII_STRING(&isolate, "toArray"), JS_List);
TRI_AddMethodVocbase(isolate, objTemplate, TRI_V8_ASCII_STRING(isolate, "analyzer"), JS_Get);
TRI_AddMethodVocbase(isolate, objTemplate, TRI_V8_ASCII_STRING(isolate, "remove"), JS_Remove);
TRI_AddMethodVocbase(isolate, objTemplate, TRI_V8_ASCII_STRING(isolate, "save"), JS_Create);
TRI_AddMethodVocbase(isolate, objTemplate, TRI_V8_ASCII_STRING(isolate, "toArray"), JS_List);
v8g.IResearchAnalyzersTempl.Reset(&isolate, objTemplate);
v8g.IResearchAnalyzersTempl.Reset(isolate, objTemplate);
auto instance = objTemplate->NewInstance();
// register the global object accessable via JavaScipt
if (!instance.IsEmpty()) {
TRI_AddGlobalVariableVocbase(isolate, TRI_V8_ASCII_STRING(isolate, "ArangoAnalyzers"), instance);
}
}
// individual analyzer functions
{
auto fnTemplate = v8::FunctionTemplate::New(&isolate);
auto fnTemplate = v8::FunctionTemplate::New(isolate);
fnTemplate->SetClassName(TRI_V8_ASCII_STRING(&isolate, "ArangoAnalyzer"));
fnTemplate->SetClassName(TRI_V8_ASCII_STRING(isolate, "ArangoAnalyzer"));
auto objTemplate = fnTemplate->InstanceTemplate();
objTemplate->SetInternalFieldCount(2); // SLOT_CLASS_TYPE + SLOT_CLASS
TRI_AddMethodVocbase(&isolate, objTemplate, TRI_V8_ASCII_STRING(&isolate, "features"), JS_AnalyzerFeatures);
TRI_AddMethodVocbase(&isolate, objTemplate, TRI_V8_ASCII_STRING(&isolate, "name"), JS_AnalyzerName);
TRI_AddMethodVocbase(&isolate, objTemplate, TRI_V8_ASCII_STRING(&isolate, "properties"), JS_AnalyzerProperties);
TRI_AddMethodVocbase(&isolate, objTemplate, TRI_V8_ASCII_STRING(&isolate, "type"), JS_AnalyzerType);
TRI_AddMethodVocbase(isolate, objTemplate, TRI_V8_ASCII_STRING(isolate, "features"), JS_AnalyzerFeatures);
TRI_AddMethodVocbase(isolate, objTemplate, TRI_V8_ASCII_STRING(isolate, "name"), JS_AnalyzerName);
TRI_AddMethodVocbase(isolate, objTemplate, TRI_V8_ASCII_STRING(isolate, "properties"), JS_AnalyzerProperties);
TRI_AddMethodVocbase(isolate, objTemplate, TRI_V8_ASCII_STRING(isolate, "type"), JS_AnalyzerType);
v8g.IResearchAnalyzerTempl.Reset(&isolate, objTemplate);
TRI_AddGlobalFunctionVocbase(&isolate, TRI_V8_ASCII_STRING(&isolate, "ArangoAnalyzer"), fnTemplate->GetFunction());
v8g.IResearchAnalyzerTempl.Reset(isolate, objTemplate);
}
}
@ -702,4 +702,4 @@ void TRI_InitV8Analyzers(
// -----------------------------------------------------------------------------
// --SECTION-- END-OF-FILE
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------

8
arangod/V8Server/v8-analyzers.h
View File

@ -35,13 +35,7 @@ namespace iresearch {
////////////////////////////////////////////////////////////////////////////////
/// @brief add analyzer related handlers to 'ArangoDBNS'
////////////////////////////////////////////////////////////////////////////////
void TRI_InitV8Analyzers(
v8::Handle<v8::Context> context, // v8 context
TRI_vocbase_t& vocbase, // vocbase
TRI_v8_global_t& v8g, // v8 globals
v8::Isolate& isolate, // v8 isolate
v8::Handle<v8::ObjectTemplate> ArangoDBNS // v8 handler root
);
void TRI_InitV8Analyzers(TRI_v8_global_t& v8g, v8::Isolate* isolate);
} // iresearch
} // arangodb

7
arangod/V8Server/v8-views.cpp
View File

@ -692,8 +692,9 @@ static void JS_TypeViewVocbase(v8::FunctionCallbackInfo<v8::Value> const& args)
TRI_V8_TRY_CATCH_END
}
void TRI_InitV8Views(v8::Handle<v8::Context> context, TRI_vocbase_t* vocbase,
TRI_v8_global_t* v8g, v8::Isolate* isolate,
void TRI_InitV8Views( // init views
TRI_v8_global_t& v8g, // V8 globals
v8::Isolate* isolate, // V8 isolate
v8::Handle<v8::ObjectTemplate> ArangoDBNS) {
TRI_AddMethodVocbase(isolate, ArangoDBNS,
TRI_V8_ASCII_STRING(isolate, "_createView"), JS_CreateViewVocbase);
@ -720,7 +721,7 @@ void TRI_InitV8Views(v8::Handle<v8::Context> context, TRI_vocbase_t* vocbase,
TRI_AddMethodVocbase(isolate, rt, TRI_V8_ASCII_STRING(isolate, "rename"), JS_RenameViewVocbase);
TRI_AddMethodVocbase(isolate, rt, TRI_V8_ASCII_STRING(isolate, "type"), JS_TypeViewVocbase);
v8g->VocbaseViewTempl.Reset(isolate, rt);
v8g.VocbaseViewTempl.Reset(isolate, rt);
TRI_AddGlobalFunctionVocbase(isolate,
TRI_V8_ASCII_STRING(isolate, "ArangoView"),
ft->GetFunction());

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

@ -31,8 +31,9 @@
struct TRI_vocbase_t;
void TRI_InitV8Views(v8::Handle<v8::Context> context, TRI_vocbase_t* vocbase,
TRI_v8_global_t* v8g, v8::Isolate* isolate,
void TRI_InitV8Views( // init views
TRI_v8_global_t& v8g, // V8 globals
v8::Isolate* isolate, // V8 isolate
v8::Handle<v8::ObjectTemplate> ArangoDBNS);
#endif
#endif

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

@ -70,6 +70,7 @@
#include "V8/v8-utils.h"
#include "V8/v8-vpack.h"
#include "V8Server/V8DealerFeature.h"
#include "V8Server/v8-analyzers.h"
#include "V8Server/v8-collection.h"
#include "V8Server/v8-externals.h"
#include "V8Server/v8-general-graph.h"
@ -2019,12 +2020,13 @@ void TRI_InitV8VocBridge(v8::Isolate* isolate, v8::Handle<v8::Context> context,
TRI_V8_ASCII_STRING(isolate, "ArangoDatabase"),
ft->GetFunction());
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate);
TRI_InitV8Statistics(isolate, context);
TRI_InitV8IndexArangoDB(isolate, ArangoNS);
TRI_InitV8Collections(context, &vocbase, v8g, isolate, ArangoNS);
TRI_InitV8Views(context, &vocbase, v8g, isolate, ArangoNS);
TRI_InitV8Views(*v8g, isolate, ArangoNS);
TRI_InitV8Users(context, &vocbase, v8g, isolate);
TRI_InitV8GeneralGraph(context, &vocbase, v8g, isolate);

153
js/client/modules/@arangodb/analyzers.js Normal file
View File

@ -0,0 +1,153 @@
////////////////////////////////////////////////////////////////////////////////
/// DISCLAIMER
///
/// Copyright 2019 ArangoDB GmbH, Cologne, Germany
///
/// Licensed under the Apache License, Version 2.0 (the "License");
/// you may not use this file except in compliance with the License.
/// You may obtain a copy of the License at
///
/// http://www.apache.org/licenses/LICENSE-2.0
///
/// Unless required by applicable law or agreed to in writing, software
/// distributed under the License is distributed on an "AS IS" BASIS,
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
/// See the License for the specific language governing permissions and
/// limitations under the License.
///
/// Copyright holder is ArangoDB GmbH, Cologne, Germany
///
/// @author Andrey Abramov
/// @author Vasiliy Nabatchikov
////////////////////////////////////////////////////////////////////////////////
const internal = require('internal');
const arangosh = require('@arangodb/arangosh');
const errors = require('@arangodb').errors;
////////////////////////////////////////////////////////////////////////////////
/// @brief ArangoAnalyzer instance
////////////////////////////////////////////////////////////////////////////////
function ArangoAnalyzer(data) {
this._data = data;
}
ArangoAnalyzer.prototype.features = function() {
return this._data['features'];
};
ArangoAnalyzer.prototype.name = function() {
return this._data['name'];
};
ArangoAnalyzer.prototype.properties = function() {
return this._data['properties'];
};
ArangoAnalyzer.prototype.type = function() {
return this._data['type'];
};
ArangoAnalyzer.prototype._help = function () {
var help = arangosh.createHelpHeadline('ArangoAnalyzers help') +
'ArangoAnalyzer constructor: ' + '\n' +
' > var analyzer = require("@arangodb/analyzers").analyzer(<name>); ' + '\n' +
' ' + '\n' +
'Administration Functions: ' + '\n' +
' name() analyzer name ' + '\n' +
' type() analyzer type ' + '\n' +
' properties() analyzer properties ' + '\n' +
' features() analyzer features ' + '\n' +
' _help() this help ' + '\n' +
' ' + '\n' +
'Attributes: ' + '\n' +
' _data server-side definition ';
internal.print(help);
};
exports.ArangoAnalyzer = ArangoAnalyzer;
////////////////////////////////////////////////////////////////////////////////
/// @brief return the base url for analyzers usage
////////////////////////////////////////////////////////////////////////////////
var _baseurl = function(suffix) {
var url = '/_api/analyzer';
if (suffix) {
url += '/' + encodeURIComponent(suffix);
}
return url;
};
////////////////////////////////////////////////////////////////////////////////
/// @brief exported members and functions
////////////////////////////////////////////////////////////////////////////////
exports.analyzer = function(name) {
var db = internal.db;
var url = _baseurl(name);
var result = db._connection.GET(url);
if (result.hasOwnProperty('error')
&& result.hasOwnProperty('error')
&& errors.ERROR_ARANGO_DOCUMENT_NOT_FOUND.code === result.errorNum) {
return null;
}
arangosh.checkRequestResult(result);
return new ArangoAnalyzer(result);
};
exports.remove = function(name) {
var db = internal.db;
var url = _baseurl(name);
var result = db._connection.DELETE(url);
return arangosh.checkRequestResult(result);
};
exports.save = function(name, type, properties, features) {
var body = {};
if (name !== undefined) {
body['name'] = name;
}
if (type !== undefined) {
body['type'] = type;
}
if (properties !== undefined) {
body['properties'] = properties;
}
if (features !== undefined) {
body['features'] = features;
}
var db = internal.db;
var url = _baseurl();
var result = db._connection.POST(url, body);
return arangosh.checkRequestResult(result);
};
exports.toArray = function() {
var db = internal.db;
var url = _baseurl();
var result = db._connection.GET(url);
arangosh.checkRequestResult(result);
var list = [];
for (var i = 0; i < result.result.length; ++i) {
list.push(new ArangoAnalyzer(result.result[i]));
}
return list;
};

11
js/server/bootstrap/modules/internal.js
View File

@ -42,13 +42,20 @@
exports.db = global.db;
delete global.db;
////////////////////////////////////////////////////////////////////////////////
/// @brief ArangoAnalyzers
////////////////////////////////////////////////////////////////////////////////
exports.ArangoAnalyzers = global.ArangoAnalyzers;
delete global.ArangoAnalyzers;
// //////////////////////////////////////////////////////////////////////////////
// / @brief ArangoCollection
// //////////////////////////////////////////////////////////////////////////////
exports.ArangoCollection = global.ArangoCollection;
delete global.ArangoCollection;
// //////////////////////////////////////////////////////////////////////////////
// / @brief ArangoView
// //////////////////////////////////////////////////////////////////////////////
@ -62,7 +69,7 @@
exports.ArangoUsers = global.ArangoUsers;
delete global.ArangoUsers;
// //////////////////////////////////////////////////////////////////////////////
// / @brief ArangoGeneralGraphModule
// //////////////////////////////////////////////////////////////////////////////

34
js/server/modules/@arangodb/analyzers.js Normal file
View File

@ -0,0 +1,34 @@
////////////////////////////////////////////////////////////////////////////////
/// DISCLAIMER
///
/// Copyright 2019 ArangoDB GmbH, Cologne, Germany
///
/// Licensed under the Apache License, Version 2.0 (the "License");
/// you may not use this file except in compliance with the License.
/// You may obtain a copy of the License at
///
/// http://www.apache.org/licenses/LICENSE-2.0
///
/// Unless required by applicable law or agreed to in writing, software
/// distributed under the License is distributed on an "AS IS" BASIS,
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
/// See the License for the specific language governing permissions and
/// limitations under the License.
///
/// Copyright holder is ArangoDB GmbH, Cologne, Germany
///
/// @author Andrey Abramov
/// @author Vasiliy Nabatchikov
////////////////////////////////////////////////////////////////////////////////
const internal = require('internal');
////////////////////////////////////////////////////////////////////////////////
/// @brief exported members and functions
////////////////////////////////////////////////////////////////////////////////
var ArangoAnalyzers = internal.ArangoAnalyzers;
exports.analyzer = ArangoAnalyzers.analyzer;
exports.remove = ArangoAnalyzers.remove;
exports.save = ArangoAnalyzers.save;
exports.toArray = ArangoAnalyzers.toArray;

407
tests/IResearch/IResearchAnalyzerFeature-test.cpp
View File

@ -444,7 +444,6 @@ SECTION("test_emplace") {
{
arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
CHECK((true == feature.emplace(result, arangodb::StaticStrings::SystemDatabase + "::test_analyzer0", "TestAnalyzer", "abc").ok()));
CHECK((false == !result.first));
auto pool = feature.get(arangodb::StaticStrings::SystemDatabase + "::test_analyzer0");
@ -456,7 +455,6 @@ SECTION("test_emplace") {
{
arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
CHECK((true == feature.emplace(result, arangodb::StaticStrings::SystemDatabase + "::test_analyzer1", "TestAnalyzer", "abc", irs::flags{ irs::frequency::type() }).ok()));
CHECK((false == !result.first));
auto pool = feature.get(arangodb::StaticStrings::SystemDatabase + "::test_analyzer1");
@ -471,7 +469,6 @@ SECTION("test_emplace") {
{
arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
CHECK((true == feature.emplace(result, arangodb::StaticStrings::SystemDatabase + "::test_analyzer2", "TestAnalyzer", "abc").ok()));
CHECK((false == !result.first));
auto pool = feature.get(arangodb::StaticStrings::SystemDatabase + "::test_analyzer2");
@ -485,7 +482,6 @@ SECTION("test_emplace") {
{
arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
CHECK((true == feature.emplace(result, arangodb::StaticStrings::SystemDatabase + "::test_analyzer2", "TestAnalyzer", "abc").ok()));
CHECK((false == !result.first));
auto pool = feature.get(arangodb::StaticStrings::SystemDatabase + "::test_analyzer2");
@ -499,7 +495,6 @@ SECTION("test_emplace") {
{
arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
CHECK((true == feature.emplace(result, arangodb::StaticStrings::SystemDatabase + "::test_analyzer3", "TestAnalyzer", "abc").ok()));
CHECK((false == !result.first));
auto pool = feature.get(arangodb::StaticStrings::SystemDatabase + "::test_analyzer3");
@ -513,7 +508,6 @@ SECTION("test_emplace") {
{
arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
CHECK((false == feature.emplace(result, arangodb::StaticStrings::SystemDatabase + "::test_analyzer4", "TestAnalyzer", "").ok()));
CHECK((true == !feature.get(arangodb::StaticStrings::SystemDatabase + "::test_analyzer4")));
}
@ -522,7 +516,6 @@ SECTION("test_emplace") {
{
arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
CHECK((false == feature.emplace(result, arangodb::StaticStrings::SystemDatabase + "::test_analyzer5", "TestAnalyzer", irs::string_ref::NIL).ok()));
CHECK((true == !feature.get(arangodb::StaticStrings::SystemDatabase + "::test_analyzer5")));
}
@ -531,24 +524,14 @@ SECTION("test_emplace") {
{
arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
CHECK((false == feature.emplace(result, arangodb::StaticStrings::SystemDatabase + "::test_analyzer6", "invalid", irs::string_ref::NIL).ok()));
CHECK((true == !feature.get(arangodb::StaticStrings::SystemDatabase + "::test_analyzer6")));
}
// add invalid (feature not started)
{
arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
CHECK((false == feature.emplace(result, arangodb::StaticStrings::SystemDatabase + "::test_analyzer7", "invalid", irs::string_ref::NIL).ok()));
CHECK((true == !feature.get(arangodb::StaticStrings::SystemDatabase + "::test_analyzer7")));
}
// add valid inRecovery (failure)
{
arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
auto before = StorageEngineMock::inRecoveryResult;
StorageEngineMock::inRecoveryResult = true;
auto restore = irs::make_finally([&before]()->void { StorageEngineMock::inRecoveryResult = before; });
@ -560,7 +543,6 @@ SECTION("test_emplace") {
{
arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
auto before = StorageEngineMock::inRecoveryResult;
StorageEngineMock::inRecoveryResult = true;
auto restore = irs::make_finally([&before]()->void { StorageEngineMock::inRecoveryResult = before; });
@ -572,7 +554,6 @@ SECTION("test_emplace") {
{
arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
auto before = StorageEngineMock::inRecoveryResult;
StorageEngineMock::inRecoveryResult = true;
auto restore = irs::make_finally([&before]()->void { StorageEngineMock::inRecoveryResult = before; });
@ -584,7 +565,6 @@ SECTION("test_emplace") {
{
arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
CHECK((true == feature.emplace(result, "identity", "identity", irs::string_ref::NIL, irs::flags{ irs::frequency::type(), irs::norm::type() }).ok()));
CHECK((false == !result.first));
auto pool = feature.get("identity");
@ -593,74 +573,6 @@ SECTION("test_emplace") {
auto analyzer = pool->get();
CHECK((false == !analyzer));
}
// add static analyzer (feature not started)
{
arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
CHECK((true == feature.emplace(result, "identity", "identity", irs::string_ref::NIL, irs::flags{ irs::frequency::type(), irs::norm::type() }).ok()));
CHECK((false == !result.first));
auto pool = feature.get("identity");
CHECK((false == !pool));
CHECK((irs::flags({irs::norm::type(), irs::frequency::type() }) == pool->features()));
auto analyzer = pool->get();
CHECK((false == !analyzer));
}
}
SECTION("test_ensure") {
{
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
// ensure (not started)
{
auto pool = feature.ensure("test_analyzer");
REQUIRE((false == !pool));
CHECK((irs::flags::empty_instance() == pool->features()));
auto analyzer = pool->get();
CHECK((true == !analyzer));
}
// ensure static analyzer (not started)
{
auto pool = feature.ensure("identity");
REQUIRE((false == !pool));
CHECK((irs::flags({irs::norm::type(), irs::frequency::type()}) == pool->features()));
auto analyzer = pool->get();
CHECK((false == !analyzer));
}
}
{
arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
feature.emplace(result, "test_analyzer", "TestAnalyzer", "abc");
// ensure valid (started)
{
auto pool = feature.get("test_analyzer");
REQUIRE((false == !pool));
CHECK((irs::flags() == pool->features()));
auto analyzer = pool.get();
CHECK((false == !analyzer));
}
// ensure invalid (started)
{
CHECK((true == !feature.get("invalid")));
}
// ensure static analyzer (started)
{
auto pool = feature.ensure("identity");
REQUIRE((false == !pool));
CHECK((irs::flags({irs::norm::type(), irs::frequency::type() }) == pool->features()));
auto analyzer = pool->get();
CHECK((false == !analyzer));
}
}
}
SECTION("test_get") {
@ -669,43 +581,13 @@ SECTION("test_get") {
>("Database");
REQUIRE((false == !dbFeature));
{
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.ensure("test_analyzer");
// get valid (not started)
{
auto pool = feature.get("test_analyzer");
REQUIRE((false == !pool));
CHECK((irs::flags::empty_instance() == pool->features()));
auto analyzer = pool->get();
CHECK((true == !analyzer));
}
// get invalid (not started)
{
CHECK((true == !feature.get("invalid")));
}
// get static analyzer (not started)
{
auto pool = feature.get("identity");
REQUIRE((false == !pool));
CHECK((irs::flags({irs::norm::type(), irs::frequency::type()}) == pool->features()));
auto analyzer = pool->get();
CHECK((false == !analyzer));
}
}
{
arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
REQUIRE((feature.emplace(result, "test_analyzer", "TestAnalyzer", "abc").ok()));
// get valid (started)
// get valid
{
auto pool = feature.get("test_analyzer");
REQUIRE((false == !pool));
@ -714,12 +596,12 @@ SECTION("test_get") {
CHECK((false == !analyzer));
}
// get invalid (started)
// get invalid
{
CHECK((true == !feature.get("invalid")));
}
// get static analyzer (started)
// get static analyzer
{
auto pool = feature.get("identity");
REQUIRE((false == !pool));
@ -834,10 +716,7 @@ SECTION("test_identity") {
{
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
CHECK((false == !feature.get("identity")));
auto pool = feature.ensure("identity");
CHECK((false == !pool));
feature.start();
pool = feature.get("identity");
auto pool = feature.get("identity");
REQUIRE((false == !pool));
CHECK((irs::flags({irs::norm::type(), irs::frequency::type()}) == pool->features()));
CHECK(("identity" == pool->name()));
@ -1008,10 +887,7 @@ SECTION("test_static_analyzer_features") {
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
for (auto& analyzerEntry : staticAnalyzers()) {
CHECK((false == !feature.get(analyzerEntry.first)));
auto pool = feature.ensure(analyzerEntry.first);
CHECK((false == !pool));
feature.start();
pool = feature.get(analyzerEntry.first);
auto pool = feature.get(analyzerEntry.first);
REQUIRE((false == !pool));
CHECK(analyzerEntry.second.features == pool->features());
CHECK(analyzerEntry.first == pool->name());
@ -1056,10 +932,10 @@ SECTION("test_persistence") {
trx.commit();
}
std::map<irs::string_ref, std::pair<irs::string_ref, irs::string_ref>> expected = {};
std::map<std::string, std::pair<irs::string_ref, irs::string_ref>> expected = {};
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
feature.start(); // load persisted analyzers
feature.visit([&expected](
arangodb::iresearch::IResearchAnalyzerFeature::AnalyzerPool::ptr const& analyzer
@ -1098,27 +974,7 @@ SECTION("test_persistence") {
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
CHECK_THROWS((feature.start()));
}
/*FIXME TODO remove no longer possible
// read invalid configuration (static analyzers present)
{
{
std::string collection(ANALYZER_COLLECTION_NAME);
arangodb::OperationOptions options;
arangodb::SingleCollectionTransaction trx(
arangodb::transaction::StandaloneContext::Create(*vocbase),
collection,
arangodb::AccessMode::Type::WRITE
);
trx.begin();
trx.truncate(collection, options);
trx.insert(collection, arangodb::velocypack::Parser::fromJson("{\"name\": \"identity\", \"type\": \"identity\", \"properties\": \"abc\"}")->slice(), options);
trx.commit();
}
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
CHECK_THROWS((feature.start()));
}
*/
// read valid configuration (different parameter options)
{
{
@ -1140,7 +996,7 @@ SECTION("test_persistence") {
trx.commit();
}
std::map<irs::string_ref, std::pair<irs::string_ref, irs::string_ref>> expected = {
std::map<std::string, std::pair<irs::string_ref, irs::string_ref>> expected = {
{ arangodb::StaticStrings::SystemDatabase + "::valid0", { "identity", irs::string_ref::NIL } },
{ arangodb::StaticStrings::SystemDatabase + "::valid2", { "identity", "abc" } },
{ arangodb::StaticStrings::SystemDatabase + "::valid4", { "identity", "[1,\"abc\"]" } },
@ -1148,8 +1004,8 @@ SECTION("test_persistence") {
};
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
/*
feature.start(); // load persisted analyzers
feature.visit([&expected](
arangodb::iresearch::IResearchAnalyzerFeature::AnalyzerPool::ptr const& analyzer
)->bool {
@ -1162,12 +1018,9 @@ SECTION("test_persistence") {
CHECK((itr->second.first == analyzer->type()));
CHECK((itr->second.second == analyzer->properties()));
expected.erase(itr);
return true;
});
CHECK((expected.empty()));
*/
}
// add new records
@ -1189,20 +1042,20 @@ SECTION("test_persistence") {
{
arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
CHECK((feature.emplace(result, arangodb::StaticStrings::SystemDatabase + "::valid", "identity", "abc").ok()));
CHECK((result.first));
CHECK((result.second));
}
{
std::map<irs::string_ref, std::pair<irs::string_ref, irs::string_ref>> expected = {
std::map<std::string, std::pair<irs::string_ref, irs::string_ref>> expected = {
{ arangodb::StaticStrings::SystemDatabase + "::valid", { "identity", "abc" } },
};
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
/*
feature.start(); // load persisted analyzers
feature.visit([&expected](
arangodb::iresearch::IResearchAnalyzerFeature::AnalyzerPool::ptr const& analyzer
)->bool {
@ -1218,7 +1071,6 @@ SECTION("test_persistence") {
return true;
});
CHECK((expected.empty()));
*/
}
}
@ -1239,14 +1091,14 @@ SECTION("test_persistence") {
}
{
std::map<irs::string_ref, std::pair<irs::string_ref, irs::string_ref>> expected = {
std::map<std::string, std::pair<irs::string_ref, irs::string_ref>> expected = {
{ "identity", { "identity", irs::string_ref::NIL } },
{ arangodb::StaticStrings::SystemDatabase + "::valid", { "identity", irs::string_ref::NIL } },
};
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
/*
feature.start(); // load persisted analyzers
feature.visit([&expected](
arangodb::iresearch::IResearchAnalyzerFeature::AnalyzerPool::ptr const& analyzer
)->bool {
@ -1264,17 +1116,16 @@ SECTION("test_persistence") {
return true;
});
CHECK((expected.empty()));
*/
CHECK((true == feature.remove(arangodb::StaticStrings::SystemDatabase + "::valid").ok()));
CHECK((false == feature.remove("identity").ok()));
}
{
std::map<irs::string_ref, std::pair<irs::string_ref, irs::string_ref>> expected = {};
std::map<std::string, std::pair<irs::string_ref, irs::string_ref>> expected = {};
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
/*
feature.start(); // load persisted analyzers
feature.visit([&expected](
arangodb::iresearch::IResearchAnalyzerFeature::AnalyzerPool::ptr const& analyzer
)->bool {
@ -1290,7 +1141,6 @@ SECTION("test_persistence") {
return true;
});
CHECK((expected.empty()));
*/
}
}
@ -1352,8 +1202,6 @@ SECTION("test_persistence") {
server.addFeature(new arangodb::application_features::CommunicationFeaturePhase(server)); // required for SimpleHttpClient::doRequest()
server.addFeature(feature = new arangodb::iresearch::IResearchAnalyzerFeature(server)); // required for running upgrade task
TRI_DEFER(dbFeature->unprepare()); // prevent leaking the vocbases
// create system vocbase (before feature start)
{
auto const databases = arangodb::velocypack::Parser::fromJson(std::string("[ { \"name\": \"") + arangodb::StaticStrings::SystemDatabase + "\" } ]");
@ -1441,8 +1289,6 @@ SECTION("test_persistence") {
server.addFeature(new arangodb::application_features::CommunicationFeaturePhase(server)); // required for SimpleHttpClient::doRequest()
server.addFeature(feature = new arangodb::iresearch::IResearchAnalyzerFeature(server)); // required for running upgrade task
TRI_DEFER(dbFeature->unprepare()); // prevent leaking the vocbases
// create system vocbase (before feature start)
{
auto const databases = arangodb::velocypack::Parser::fromJson(std::string("[ { \"name\": \"") + arangodb::StaticStrings::SystemDatabase + "\" } ]");
@ -1553,8 +1399,6 @@ SECTION("test_remove") {
arangodb::aql::OptimizerRulesFeature(server).prepare(); // required for Query::preparePlan(...)
auto clearOptimizerRules = irs::make_finally([&s]()->void { arangodb::aql::OptimizerRulesFeature(s.server).unprepare(); });
TRI_DEFER(dbFeature->unprepare()); // prevent leaking the vocbases
// create system vocbase (before feature start)
{
auto const databases = arangodb::velocypack::Parser::fromJson(std::string("[ { \"name\": \"") + arangodb::StaticStrings::SystemDatabase + "\" } ]");
@ -1653,8 +1497,6 @@ SECTION("test_remove") {
arangodb::aql::OptimizerRulesFeature(server).prepare(); // required for Query::preparePlan(...)
auto clearOptimizerRules = irs::make_finally([&s]()->void { arangodb::aql::OptimizerRulesFeature(s.server).unprepare(); });
TRI_DEFER(dbFeature->unprepare()); // prevent leaking the vocbases
// create system vocbase (before feature start)
{
auto const databases = arangodb::velocypack::Parser::fromJson(std::string("[ { \"name\": \"") + arangodb::StaticStrings::SystemDatabase + "\" } ]");
@ -1911,7 +1753,7 @@ SECTION("test_start") {
StorageEngineMock::inRecoveryResult = true;
auto restore = irs::make_finally([&before]()->void { StorageEngineMock::inRecoveryResult = before; });
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
feature.start(); // load persisted analyzers
CHECK((nullptr == vocbase->lookupCollection(ANALYZER_COLLECTION_NAME)));
auto expected = staticAnalyzers();
@ -1930,46 +1772,6 @@ SECTION("test_start") {
CHECK((expected.empty()));
}
// test feature start load configuration (inRecovery, no configuration collection, uninitialized analyzers)
{
// ensure no configuration collection
{
auto collection = vocbase->lookupCollection(ANALYZER_COLLECTION_NAME);
if (collection) {
vocbase->dropCollection(collection->id(), true, -1);
}
collection = vocbase->lookupCollection(ANALYZER_COLLECTION_NAME);
CHECK((nullptr == collection));
}
auto before = StorageEngineMock::inRecoveryResult;
StorageEngineMock::inRecoveryResult = true;
auto restore = irs::make_finally([&before]()->void { StorageEngineMock::inRecoveryResult = before; });
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
CHECK((true == !feature.get("test_analyzer")));
CHECK((false == !feature.ensure("test_analyzer")));
feature.start();
CHECK((nullptr == vocbase->lookupCollection(ANALYZER_COLLECTION_NAME)));
auto expected = staticAnalyzers();
expected.emplace(std::piecewise_construct, std::forward_as_tuple("test_analyzer"), std::forward_as_tuple(irs::string_ref::NIL, irs::string_ref::NIL));
feature.visit([&expected, &feature](
arangodb::iresearch::IResearchAnalyzerFeature::AnalyzerPool::ptr const& analyzer
)->bool {
auto itr = expected.find(analyzer->name());
CHECK((itr != expected.end()));
CHECK((itr->second.type == analyzer->type()));
CHECK((itr->second.properties == analyzer->properties()));
CHECK((itr->second.features.is_subset_of(feature.get(analyzer->name())->features())));
expected.erase(itr);
return true;
});
CHECK((expected.empty()));
}
// test feature start load configuration (inRecovery, with configuration collection)
{
// ensure there is an empty configuration collection
@ -1984,7 +1786,7 @@ SECTION("test_start") {
CHECK((nullptr == collection));
arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
CHECK((true == feature.emplace(result, arangodb::StaticStrings::SystemDatabase + "::test_analyzer", "identity", "abc").ok()));
CHECK((false == !result.first));
collection = vocbase->lookupCollection(ANALYZER_COLLECTION_NAME);
@ -1995,12 +1797,13 @@ SECTION("test_start") {
StorageEngineMock::inRecoveryResult = true;
auto restore = irs::make_finally([&before]()->void { StorageEngineMock::inRecoveryResult = before; });
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
feature.start(); // load persisted analyzers
CHECK((nullptr != vocbase->lookupCollection(ANALYZER_COLLECTION_NAME)));
auto expected = staticAnalyzers();
/*
expected.emplace(std::piecewise_construct, std::forward_as_tuple(arangodb::StaticStrings::SystemDatabase + "::test_analyzer"), std::forward_as_tuple("identity", "abc"));
auto expectedAnalyzer = arangodb::StaticStrings::SystemDatabase + "::test_analyzer";
expected.emplace(std::piecewise_construct, std::forward_as_tuple(expectedAnalyzer), std::forward_as_tuple("identity", "abc"));
feature.visit([&expected, &feature](
arangodb::iresearch::IResearchAnalyzerFeature::AnalyzerPool::ptr const& analyzer
)->bool {
@ -2013,56 +1816,6 @@ SECTION("test_start") {
return true;
});
CHECK((expected.empty()));
*/
}
// FIXME TODO remove test since there is no more ensure()
// test feature start load configuration (inRecovery, with configuration collection, uninitialized analyzers)
{
// ensure there is an empty configuration collection
{
auto collection = vocbase->lookupCollection(ANALYZER_COLLECTION_NAME);
if (collection) {
vocbase->dropCollection(collection->id(), true, -1);
}
collection = vocbase->lookupCollection(ANALYZER_COLLECTION_NAME);
CHECK((nullptr == collection));
arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
CHECK((true == feature.emplace(result, arangodb::StaticStrings::SystemDatabase + "::test_analyzer", "identity", "abc").ok()));
CHECK((false == !result.first));
collection = vocbase->lookupCollection(ANALYZER_COLLECTION_NAME);
CHECK((nullptr != collection));
}
auto before = StorageEngineMock::inRecoveryResult;
StorageEngineMock::inRecoveryResult = true;
auto restore = irs::make_finally([&before]()->void { StorageEngineMock::inRecoveryResult = before; });
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
CHECK((false == !feature.get(arangodb::StaticStrings::SystemDatabase + "::test_analyzer")));
CHECK((false == !feature.ensure(arangodb::StaticStrings::SystemDatabase + "::test_analyzer")));
feature.start();
CHECK((nullptr != vocbase->lookupCollection(ANALYZER_COLLECTION_NAME)));
auto expected = staticAnalyzers();
/*
expected.emplace(std::piecewise_construct, std::forward_as_tuple(arangodb::StaticStrings::SystemDatabase + "::test_analyzer"), std::forward_as_tuple("identity", "abc"));
feature.visit([&expected, &feature](
arangodb::iresearch::IResearchAnalyzerFeature::AnalyzerPool::ptr const& analyzer
)->bool {
auto itr = expected.find(analyzer->name());
CHECK((itr != expected.end()));
CHECK((itr->second.type == analyzer->type()));
CHECK((itr->second.properties == analyzer->properties()));
CHECK((itr->second.features.is_subset_of(feature.get(analyzer->name())->features())));
expected.erase(itr);
return true;
});
CHECK((expected.empty()));
*/
}
// test feature start load configuration (no configuration collection)
@ -2080,11 +1833,11 @@ SECTION("test_start") {
}
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
feature.start(); // load persisted analyzers
CHECK((nullptr == vocbase->lookupCollection(ANALYZER_COLLECTION_NAME)));
auto expected = staticAnalyzers();
/*
feature.visit([&expected, &feature](
arangodb::iresearch::IResearchAnalyzerFeature::AnalyzerPool::ptr const& analyzer
)->bool {
@ -2097,48 +1850,10 @@ SECTION("test_start") {
return true;
});
CHECK((expected.empty()));
*/
}
// test feature start load configuration (no configuration collection, static analyzers)
{
// ensure no configuration collection
{
auto collection = vocbase->lookupCollection(ANALYZER_COLLECTION_NAME);
if (collection) {
vocbase->dropCollection(collection->id(), true, -1);
}
collection = vocbase->lookupCollection(ANALYZER_COLLECTION_NAME);
CHECK((nullptr == collection));
}
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
CHECK((false == !feature.get("identity")));
feature.start();
CHECK((nullptr == vocbase->lookupCollection(ANALYZER_COLLECTION_NAME)));
auto expected = staticAnalyzers();
/*
feature.visit([&expected, &feature](
arangodb::iresearch::IResearchAnalyzerFeature::AnalyzerPool::ptr const& analyzer
)->bool {
auto itr = expected.find(analyzer->name());
CHECK((itr != expected.end()));
CHECK((itr->second.type == analyzer->type()));
CHECK((itr->second.properties == analyzer->properties()));
CHECK((itr->second.features.is_subset_of(feature.get(analyzer->name())->features())));
expected.erase(itr);
return true;
});
CHECK((expected.empty()));
*/
}
// test feature start load configuration (with configuration collection)
{
// ensure there is an empty configuration collection
{
auto collection = vocbase->lookupCollection(ANALYZER_COLLECTION_NAME);
@ -2151,7 +1866,7 @@ SECTION("test_start") {
CHECK((nullptr == collection));
arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
CHECK((true == feature.emplace(result, arangodb::StaticStrings::SystemDatabase + "::test_analyzer", "identity", "abc").ok()));
CHECK((false == !result.first));
collection = vocbase->lookupCollection(ANALYZER_COLLECTION_NAME);
@ -2159,12 +1874,13 @@ SECTION("test_start") {
}
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
feature.start(); // load persisted analyzers
CHECK((nullptr != vocbase->lookupCollection(ANALYZER_COLLECTION_NAME)));
auto expected = staticAnalyzers();
/*
expected.emplace(std::piecewise_construct, std::forward_as_tuple(arangodb::StaticStrings::SystemDatabase + "::test_analyzer"), std::forward_as_tuple("identity", "abc"));
auto expectedAnalyzer = arangodb::StaticStrings::SystemDatabase + "::test_analyzer";
expected.emplace(std::piecewise_construct, std::forward_as_tuple(expectedAnalyzer), std::forward_as_tuple("identity", "abc"));
feature.visit([&expected, &feature](
arangodb::iresearch::IResearchAnalyzerFeature::AnalyzerPool::ptr const& analyzer
)->bool {
@ -2177,53 +1893,6 @@ SECTION("test_start") {
return true;
});
CHECK((expected.empty()));
*/
}
// FIXME TODO remove test since there is no more ensure()
// test feature start load configuration (with configuration collection, uninitialized analyzers)
{
// ensure there is an empty configuration collection
{
auto collection = vocbase->lookupCollection(ANALYZER_COLLECTION_NAME);
if (collection) {
vocbase->dropCollection(collection->id(), true, -1);
}
collection = vocbase->lookupCollection(ANALYZER_COLLECTION_NAME);
CHECK((nullptr == collection));
arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
feature.start();
CHECK((true == feature.emplace(result, arangodb::StaticStrings::SystemDatabase + "::test_analyzer", "identity", "abc").ok()));
CHECK((false == !result.first));
collection = vocbase->lookupCollection(ANALYZER_COLLECTION_NAME);
CHECK((nullptr != collection));
}
arangodb::iresearch::IResearchAnalyzerFeature feature(s.server);
CHECK((false == !feature.get(arangodb::StaticStrings::SystemDatabase + "::test_analyzer")));
CHECK((false == !feature.ensure(arangodb::StaticStrings::SystemDatabase + "::test_analyzer")));
feature.start();
CHECK((nullptr != vocbase->lookupCollection(ANALYZER_COLLECTION_NAME)));
auto expected = staticAnalyzers();
/*
expected.emplace(std::piecewise_construct, std::forward_as_tuple(arangodb::StaticStrings::SystemDatabase + "::test_analyzer"), std::forward_as_tuple("identity", "abc"));
feature.visit([&expected, &feature](
arangodb::iresearch::IResearchAnalyzerFeature::AnalyzerPool::ptr const& analyzer
)->bool {
auto itr = expected.find(analyzer->name());
CHECK((itr != expected.end()));
CHECK((itr->second.type == analyzer->type()));
CHECK((itr->second.properties == analyzer->properties()));
CHECK((itr->second.features.is_subset_of(feature.get(analyzer->name())->features())));
expected.erase(itr);
return true;
});
CHECK((expected.empty()));
*/
}
}
@ -2276,12 +1945,12 @@ SECTION("test_tokens") {
// AqlFunctionFeature::byName(..) throws exception instead of returning a nullptr
CHECK_THROWS((functions->byName("TOKENS")));
feature.start();
feature.start(); // load AQL functions
CHECK((nullptr != functions->byName("TOKENS")));
}
arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
analyzers->start();
analyzers->start(); // load AQL functions
REQUIRE((true == analyzers->emplace(result, "test_analyzer", "TestAnalyzer", "abc").ok()));
REQUIRE((false == !result.first));
@ -3741,10 +3410,6 @@ SECTION("test_visit") {
server.addFeature(new arangodb::SystemDatabaseFeature(server, &system)); // required for IResearchAnalyzerFeature::start()
server.addFeature(new arangodb::V8DealerFeature(server)); // required for DatabaseFeature::createDatabase(...)
TRI_DEFER(dbFeature->unprepare()); // prevent leaking the vocbases
feature.start();
arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
CHECK((true == feature.emplace(result, "test_analyzer0", "TestAnalyzer", "abc0").ok()));
CHECK((false == !result.first));
@ -3870,4 +3535,4 @@ SECTION("test_visit") {
// -----------------------------------------------------------------------------
// --SECTION-- END-OF-FILE
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------

8
tests/IResearch/IResearchFeature-test.cpp
View File

@ -237,6 +237,8 @@ SECTION("test_upgrade0_1") {
server.addFeature(dbPathFeature = new arangodb::DatabasePathFeature(server)); // required for IResearchLink::initDataStore()
server.addFeature(new arangodb::iresearch::IResearchAnalyzerFeature(server)); // required for restoring link analyzers
server.addFeature(new arangodb::QueryRegistryFeature(server)); // required for constructing TRI_vocbase_t
TRI_vocbase_t system(TRI_vocbase_type_e::TRI_VOCBASE_TYPE_NORMAL, 0, TRI_VOC_SYSTEM_DATABASE);
server.addFeature(new arangodb::SystemDatabaseFeature(server, &system)); // required for IResearchAnalyzerFeature::start()
server.addFeature(new arangodb::UpgradeFeature(server, nullptr, {})); // required for upgrade tasks
server.addFeature(new arangodb::ViewTypesFeature(server)); // required for IResearchFeature::prepare()
feature.prepare(); // register iresearch view type
@ -316,6 +318,8 @@ SECTION("test_upgrade0_1") {
server.addFeature(dbPathFeature = new arangodb::DatabasePathFeature(server)); // required for IResearchLink::initDataStore()
server.addFeature(new arangodb::iresearch::IResearchAnalyzerFeature(server)); // required for restoring link analyzers
server.addFeature(new arangodb::QueryRegistryFeature(server)); // required for constructing TRI_vocbase_t
TRI_vocbase_t system(TRI_vocbase_type_e::TRI_VOCBASE_TYPE_NORMAL, 0, TRI_VOC_SYSTEM_DATABASE);
server.addFeature(new arangodb::SystemDatabaseFeature(server, &system)); // required for IResearchLinkHelper::normalize(...)
server.addFeature(new arangodb::UpgradeFeature(server, nullptr, {})); // required for upgrade tasks
server.addFeature(new arangodb::ViewTypesFeature(server)); // required for IResearchFeature::prepare()
feature.prepare(); // register iresearch view type
@ -543,7 +547,7 @@ SECTION("test_upgrade0_1") {
REQUIRE((false == !index));
auto link = std::dynamic_pointer_cast<arangodb::iresearch::IResearchLink>(index);
REQUIRE((false == !link));
REQUIRE((view->link(link->self()))); // link will not notify view in 'vocbase', hence notify manually
REQUIRE((view->link(link->self()).ok())); // link will not notify view in 'vocbase', hence notify manually
index->unload(); // release file handles
bool result;
@ -624,7 +628,7 @@ SECTION("test_upgrade0_1") {
REQUIRE((false == !index));
auto link = std::dynamic_pointer_cast<arangodb::iresearch::IResearchLink>(index);
REQUIRE((false == !link));
REQUIRE((view->link(link->self()))); // link will not notify view in 'vocbase', hence notify manually
REQUIRE((view->link(link->self()).ok())); // link will not notify view in 'vocbase', hence notify manually
index->unload(); // release file handles
bool result;

4
tests/IResearch/IResearchLinkMeta-test.cpp
View File

@ -938,7 +938,7 @@ SECTION("test_writeCustomizedValues") {
std::unordered_set<std::string> expectedFields = { "a", "b", "c" };
std::unordered_set<std::string> expectedOverrides = { "default", "all", "some", "none" };
std::set<std::pair<std::string, std::string>> expectedAnalyzers = {
{ "empty", "en" },
{ "testVocbase::empty", "en" },
{ "identity", "" },
};
TRI_vocbase_t vocbase(TRI_vocbase_type_e::TRI_VOCBASE_TYPE_NORMAL, 1, "testVocbase");
@ -1011,7 +1011,7 @@ SECTION("test_writeCustomizedValues") {
true == tmpSlice.isArray()
&& 1 == tmpSlice.length()
&& tmpSlice.at(0).isObject()
&& tmpSlice.at(0).get("name").isString() && std::string("empty") == tmpSlice.at(0).get("name").copyString()
&& tmpSlice.at(0).get("name").isString() && std::string("testVocbase::empty") == tmpSlice.at(0).get("name").copyString()
&& tmpSlice.at(0).get("type").isString() && std::string("empty") == tmpSlice.at(0).get("type").copyString()
&& tmpSlice.at(0).get("properties").isString() && std::string("en") == tmpSlice.at(0).get("properties").copyString()
&& tmpSlice.at(0).get("features").isArray() && 1 == tmpSlice.at(0).get("features").length()

10
tests/IResearch/IResearchView-test.cpp
View File

@ -1314,7 +1314,7 @@ SECTION("test_emplace_cid") {
auto restore = irs::make_finally([&before]()->void { StorageEngineMock::before = before; });
StorageEngineMock::before = [&persisted]()->void { persisted = true; };
CHECK((false == view->link(link->self())));
CHECK((false == view->link(link->self()).ok()));
CHECK((!persisted)); // emplace() does not modify view meta if cid existed previously
}
@ -1370,7 +1370,7 @@ SECTION("test_emplace_cid") {
} link(42, *logicalCollection);
auto asyncLinkPtr = std::make_shared<arangodb::iresearch::IResearchLink::AsyncLinkPtr::element_type>(&link);
CHECK((true == view->link(asyncLinkPtr)));
CHECK((true == view->link(asyncLinkPtr).ok()));
CHECK((persisted)); // emplace() modifies view meta if cid did not exist previously
}
@ -1429,7 +1429,7 @@ SECTION("test_emplace_cid") {
} link(42, *logicalCollection);
auto asyncLinkPtr = std::make_shared<arangodb::iresearch::IResearchLink::AsyncLinkPtr::element_type>(&link);
CHECK((true == view->link(asyncLinkPtr)));
CHECK((true == view->link(asyncLinkPtr).ok()));
CHECK((!persisted)); // emplace() modifies view meta if cid did not exist previously (but not persisted until after recovery)
}
@ -1484,7 +1484,7 @@ SECTION("test_emplace_cid") {
} link(42, *logicalCollection);
auto asyncLinkPtr = std::make_shared<arangodb::iresearch::IResearchLink::AsyncLinkPtr::element_type>(&link);
CHECK((false == view->link(asyncLinkPtr)));
CHECK((false == view->link(asyncLinkPtr).ok()));
}
// collection in view after
@ -1542,7 +1542,7 @@ SECTION("test_emplace_cid") {
} link(42, *logicalCollection);
auto asyncLinkPtr = std::make_shared<arangodb::iresearch::IResearchLink::AsyncLinkPtr::element_type>(&link);
CHECK((true == view->link(asyncLinkPtr)));
CHECK((true == view->link(asyncLinkPtr).ok()));
CHECK((!persisted)); // emplace() modifies view meta if cid did not exist previously (but not persisted until after recovery)
}

50
tests/IResearch/IResearchViewCoordinator-test.cpp
View File

@ -42,6 +42,7 @@
#include "Aql/ExecutionEngine.h"
#include "Aql/ExecutionPlan.h"
#include "Aql/Function.h"
#include "Aql/IResearchViewNode.h"
#include "Aql/NoResultsExecutor.h"
#include "Aql/OptimizerRulesFeature.h"
#include "Aql/QueryRegistry.h"
@ -56,7 +57,6 @@
#endif
#include "Agency/AgencyFeature.h"
#include "Aql/IResearchViewNode.h"
#include "Cluster/ClusterComm.h"
#include "Cluster/ClusterFeature.h"
#include "Cluster/ClusterInfo.h"
@ -308,29 +308,57 @@ TEST_CASE("IResearchViewCoordinatorTest",
}
SECTION("visit_collections") {
auto* ci = arangodb::ClusterInfo::instance();
REQUIRE((nullptr != ci));
TRI_vocbase_t* vocbase; // will be owned by DatabaseFeature
{
auto* database = arangodb::DatabaseFeature::DATABASE;
REQUIRE((nullptr != database));
REQUIRE((TRI_ERROR_NO_ERROR == database->createDatabase(1, "testVocbase", vocbase)));
REQUIRE((nullptr != vocbase));
REQUIRE((ci->createDatabaseCoordinator(vocbase->name(), arangodb::velocypack::Slice::emptyObjectSlice(), 0.0).ok()));
}
std::string collectionId0("100");
std::string collectionId1("101");
std::string collectionId2("102");
std::string viewId("1");
auto collectionJson0 = arangodb::velocypack::Parser::fromJson("{ \"name\": \"testCollection0\", \"shards\":{} }");
auto collectionJson1 = arangodb::velocypack::Parser::fromJson("{ \"name\": \"testCollection1\", \"shards\":{} }");
auto collectionJson2 = arangodb::velocypack::Parser::fromJson("{ \"name\": \"testCollection2\", \"shards\":{} }");
auto linkJson = arangodb::velocypack::Parser::fromJson("{ \"view\": \"1\" }");
auto json = arangodb::velocypack::Parser::fromJson(
"{ \"name\": \"testView\", \"type\": \"arangosearch\", \"id\": \"1\" "
"}");
Vocbase vocbase(TRI_vocbase_type_e::TRI_VOCBASE_TYPE_COORDINATOR, 1,
"testVocbase");
arangodb::LogicalView::ptr logicalView;
REQUIRE((arangodb::LogicalView::instantiate(logicalView, vocbase, json->slice(), 0)
.ok()));
REQUIRE((ci->createCollectionCoordinator(vocbase->name(), collectionId0, 0, 1, false, collectionJson0->slice(), 0.0).ok()));
auto logicalCollection0 = ci->getCollection(vocbase->name(), collectionId0);
REQUIRE((false == !logicalCollection0));
REQUIRE((ci->createCollectionCoordinator(vocbase->name(), collectionId1, 0, 1, false, collectionJson1->slice(), 0.0).ok()));
auto logicalCollection1 = ci->getCollection(vocbase->name(), collectionId1);
REQUIRE((false == !logicalCollection1));
REQUIRE((ci->createCollectionCoordinator(vocbase->name(), collectionId2, 0, 1, false, collectionJson2->slice(), 0.0).ok()));
auto logicalCollection2 = ci->getCollection(vocbase->name(), collectionId2);
REQUIRE((false == !logicalCollection2));
REQUIRE((ci->createViewCoordinator(vocbase->name(), viewId, json->slice()).ok()));
auto logicalView = ci->getView(vocbase->name(), viewId);
REQUIRE((false == !logicalView));
auto* view =
dynamic_cast<arangodb::iresearch::IResearchViewCoordinator*>(logicalView.get());
CHECK(nullptr != view);
CHECK(0 == view->planVersion());
CHECK(6 == view->planVersion());
CHECK("testView" == view->name());
CHECK(false == view->deleted());
CHECK(1 == view->id());
CHECK(arangodb::iresearch::DATA_SOURCE_TYPE == view->type());
CHECK(arangodb::LogicalView::category() == view->category());
CHECK(&vocbase == &view->vocbase());
CHECK(vocbase == &view->vocbase());
CHECK((true == view->emplace(1, "1", arangodb::velocypack::Slice::emptyObjectSlice())));
CHECK((true == view->emplace(2, "2", arangodb::velocypack::Slice::emptyObjectSlice())));
CHECK((true == view->emplace(3, "3", arangodb::velocypack::Slice::emptyObjectSlice())));
std::shared_ptr<arangodb::Index> link;
CHECK((arangodb::iresearch::IResearchLinkCoordinator::factory().instantiate(link, *logicalCollection0, linkJson->slice(), 1, false).ok()));
CHECK((arangodb::iresearch::IResearchLinkCoordinator::factory().instantiate(link, *logicalCollection1, linkJson->slice(), 2, false).ok()));
CHECK((arangodb::iresearch::IResearchLinkCoordinator::factory().instantiate(link, *logicalCollection2, linkJson->slice(), 3, false).ok()));
// visit view
TRI_voc_cid_t expectedCollections[] = {1, 2, 3};

16
tests/IResearch/IResearchViewDBServer-test.cpp
View File

@ -52,6 +52,7 @@
#include "RestServer/DatabasePathFeature.h"
#include "RestServer/FlushFeature.h"
#include "RestServer/QueryRegistryFeature.h"
#include "RestServer/SystemDatabaseFeature.h"
#include "RestServer/ViewTypesFeature.h"
#include "StorageEngine/EngineSelectorFeature.h"
#include "Transaction/Methods.h"
@ -122,6 +123,7 @@ struct IResearchViewDBServerSetup {
buildFeatureEntry(new arangodb::FlushFeature(server), false); // do not start the thread
buildFeatureEntry(new arangodb::QueryRegistryFeature(server), false); // required for TRI_vocbase_t instantiation
buildFeatureEntry(new arangodb::ShardingFeature(server), false); // required for TRI_vocbase_t instantiation
buildFeatureEntry(new arangodb::SystemDatabaseFeature(server), true); // required for IResearchAnalyzerFeature
buildFeatureEntry(new arangodb::ViewTypesFeature(server), false); // required for TRI_vocbase_t::createView(...)
buildFeatureEntry(new arangodb::iresearch::IResearchAnalyzerFeature(server), false); // required for IResearchLinkMeta::init(...)
buildFeatureEntry(new arangodb::iresearch::IResearchFeature(server), false); // required for instantiating IResearchView*
@ -146,6 +148,12 @@ struct IResearchViewDBServerSetup {
}
}
auto const databases = arangodb::velocypack::Parser::fromJson(std::string("[ { \"name\": \"") + arangodb::StaticStrings::SystemDatabase + "\" } ]");
auto* dbFeature = arangodb::application_features::ApplicationServer::lookupFeature<
arangodb::DatabaseFeature
>("Database");
dbFeature->loadDatabases(databases->slice());
for (auto& f : orderedFeatures) {
if (features.at(f->name()).second) {
f->start();
@ -491,7 +499,7 @@ SECTION("test_open") {
static auto visitor = [](TRI_voc_cid_t)->bool { return false; };
CHECK((true == impl->visitCollections(visitor)));
CHECK((true == impl->link(asyncLinkPtr)));
CHECK((true == impl->link(asyncLinkPtr).ok()));
CHECK((false == impl->visitCollections(visitor)));
wiew->open();
}
@ -821,7 +829,7 @@ SECTION("test_rename") {
Link(TRI_idx_iid_t id, arangodb::LogicalCollection& col): IResearchLink(id, col) {}
} link(42, *logicalCollection);
auto asyncLinkPtr = std::make_shared<arangodb::iresearch::IResearchLink::AsyncLinkPtr::element_type>(&link);
CHECK((true == impl->link(asyncLinkPtr)));
CHECK((true == impl->link(asyncLinkPtr).ok()));
}
// rename non-empty
@ -843,7 +851,7 @@ SECTION("test_rename") {
Link(TRI_idx_iid_t id, arangodb::LogicalCollection& col): IResearchLink(id, col) {}
} link(42, *logicalCollection);
auto asyncLinkPtr = std::make_shared<arangodb::iresearch::IResearchLink::AsyncLinkPtr::element_type>(&link);
CHECK((true == impl->link(asyncLinkPtr)));
CHECK((true == impl->link(asyncLinkPtr).ok()));
{
arangodb::velocypack::Builder builder;
@ -1493,7 +1501,7 @@ SECTION("test_visitCollections") {
Link(TRI_idx_iid_t id, arangodb::LogicalCollection& col): IResearchLink(id, col) {}
} link(42, *logicalCollection);
auto asyncLinkPtr = std::make_shared<arangodb::iresearch::IResearchLink::AsyncLinkPtr::element_type>(&link);
CHECK((true == impl->link(asyncLinkPtr)));
CHECK((true == impl->link(asyncLinkPtr).ok()));
std::set<TRI_voc_cid_t> cids = { logicalCollection->id() };
static auto visitor = [&cids](TRI_voc_cid_t cid)->bool { return 1 == cids.erase(cid); };

108
tests/V8Server/v8-analyzers-test.cpp
View File

@ -203,8 +203,7 @@ SECTION("test_accessors") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzer = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzerTempl)->NewInstance();
auto fn_name = v8Analyzer->Get(TRI_V8_ASCII_STRING(isolate.get(), "name"));
@ -244,8 +243,7 @@ SECTION("test_accessors") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzer = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzerTempl)->NewInstance();
auto fn_name = v8Analyzer->Get(TRI_V8_ASCII_STRING(isolate.get(), "name"));
@ -290,8 +288,7 @@ SECTION("test_accessors") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzer = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzerTempl)->NewInstance();
auto fn_type = v8Analyzer->Get(TRI_V8_ASCII_STRING(isolate.get(), "type"));
@ -331,8 +328,7 @@ SECTION("test_accessors") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzer = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzerTempl)->NewInstance();
auto fn_type = v8Analyzer->Get(TRI_V8_ASCII_STRING(isolate.get(), "type"));
@ -377,8 +373,7 @@ SECTION("test_accessors") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzer = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzerTempl)->NewInstance();
auto fn_properties = v8Analyzer->Get(TRI_V8_ASCII_STRING(isolate.get(), "properties"));
@ -417,8 +412,7 @@ SECTION("test_accessors") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzer = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzerTempl)->NewInstance();
auto fn_properties = v8Analyzer->Get(TRI_V8_ASCII_STRING(isolate.get(), "properties"));
@ -463,8 +457,7 @@ SECTION("test_accessors") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzer = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzerTempl)->NewInstance();
auto fn_features = v8Analyzer->Get(TRI_V8_ASCII_STRING(isolate.get(), "features"));
@ -505,8 +498,7 @@ SECTION("test_accessors") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzer = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzerTempl)->NewInstance();
auto fn_features = v8Analyzer->Get(TRI_V8_ASCII_STRING(isolate.get(), "features"));
@ -590,8 +582,7 @@ SECTION("test_create") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_create = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "save"));
@ -634,8 +625,7 @@ SECTION("test_create") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_create = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "save"));
@ -681,8 +671,7 @@ SECTION("test_create") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_create = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "save"));
@ -729,8 +718,7 @@ SECTION("test_create") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_create = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "save"));
@ -777,8 +765,7 @@ SECTION("test_create") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_create = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "save"));
@ -827,8 +814,7 @@ SECTION("test_create") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_create = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "save"));
@ -875,8 +861,7 @@ SECTION("test_create") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_create = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "save"));
@ -964,8 +949,7 @@ SECTION("test_get") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_get = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "analyzer"));
@ -1008,8 +992,7 @@ SECTION("test_get") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_get = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "analyzer"));
@ -1054,8 +1037,7 @@ SECTION("test_get") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_get = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "analyzer"));
@ -1094,8 +1076,7 @@ SECTION("test_get") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_get = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "analyzer"));
@ -1140,8 +1121,7 @@ SECTION("test_get") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_get = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "analyzer"));
@ -1186,8 +1166,7 @@ SECTION("test_get") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_get = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "analyzer"));
@ -1226,8 +1205,7 @@ SECTION("test_get") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_get = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "analyzer"));
@ -1272,8 +1250,7 @@ SECTION("test_get") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_get = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "analyzer"));
@ -1312,8 +1289,7 @@ SECTION("test_get") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_get = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "analyzer"));
@ -1403,8 +1379,7 @@ SECTION("test_list") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_list = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "toArray"));
@ -1456,8 +1431,7 @@ SECTION("test_list") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_list = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "toArray"));
@ -1507,8 +1481,7 @@ SECTION("test_list") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_list = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "toArray"));
@ -1562,8 +1535,7 @@ SECTION("test_list") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_list = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "toArray"));
@ -1616,8 +1588,7 @@ SECTION("test_list") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_list = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "toArray"));
@ -1670,8 +1641,7 @@ SECTION("test_list") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_list = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "toArray"));
@ -1762,8 +1732,7 @@ SECTION("test_remove") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_remove = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "remove"));
@ -1806,8 +1775,7 @@ SECTION("test_remove") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_remove = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "remove"));
@ -1852,8 +1820,7 @@ SECTION("test_remove") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_remove = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "remove"));
@ -1900,8 +1867,7 @@ SECTION("test_remove") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_remove = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "remove"));
@ -1951,8 +1917,7 @@ SECTION("test_remove") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_remove = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "remove"));
@ -1996,8 +1961,7 @@ SECTION("test_remove") {
std::unique_ptr<TRI_v8_global_t> v8g(TRI_CreateV8Globals(isolate.get())); // create and set inside 'isolate' for use with 'TRI_GET_GLOBALS()'
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
arangodb::iresearch::TRI_InitV8Analyzers(context, vocbase, *v8g, *isolate, arangoDBNS);
arangodb::iresearch::TRI_InitV8Analyzers(*v8g, isolate.get());
auto v8Analyzers = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->IResearchAnalyzersTempl)->NewInstance();
auto fn_remove = v8Analyzers->Get(TRI_V8_ASCII_STRING(isolate.get(), "remove"));

16
tests/V8Server/v8-views-test.cpp
View File

@ -213,7 +213,7 @@ SECTION("test_auth") {
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
TRI_InitV8Views(context, &vocbase, v8g.get(), isolate.get(), arangoDBNS);
TRI_InitV8Views(*v8g, isolate.get(), arangoDBNS);
auto fn_createView = arangoDBNS->NewInstance()->Get(TRI_V8_ASCII_STRING(isolate.get(), "_createView"));
CHECK((fn_createView->IsFunction()));
@ -316,7 +316,7 @@ SECTION("test_auth") {
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
TRI_InitV8Views(context, &vocbase, v8g.get(), isolate.get(), arangoDBNS);
TRI_InitV8Views(*v8g, isolate.get(), arangoDBNS);
auto fn_dropView = arangoDBNS->NewInstance()->Get(TRI_V8_ASCII_STRING(isolate.get(), "_dropView"));
CHECK((fn_dropView->IsFunction()));
@ -449,7 +449,7 @@ SECTION("test_auth") {
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
TRI_InitV8Views(context, &vocbase, v8g.get(), isolate.get(), arangoDBNS);
TRI_InitV8Views(*v8g, isolate.get(), arangoDBNS);
auto arangoView = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->VocbaseViewTempl)->NewInstance();
auto fn_drop = arangoView->Get(TRI_V8_ASCII_STRING(isolate.get(), "drop"));
@ -584,7 +584,7 @@ SECTION("test_auth") {
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
TRI_InitV8Views(context, &vocbase, v8g.get(), isolate.get(), arangoDBNS);
TRI_InitV8Views(*v8g, isolate.get(), arangoDBNS);
auto arangoView = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->VocbaseViewTempl)->NewInstance();
auto fn_rename = arangoView->Get(TRI_V8_ASCII_STRING(isolate.get(), "rename"));
@ -761,7 +761,7 @@ SECTION("test_auth") {
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
TRI_InitV8Views(context, &vocbase, v8g.get(), isolate.get(), arangoDBNS);
TRI_InitV8Views(*v8g, isolate.get(), arangoDBNS);
auto arangoView = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->VocbaseViewTempl)->NewInstance();
auto fn_properties = arangoView->Get(TRI_V8_ASCII_STRING(isolate.get(), "properties"));
@ -969,7 +969,7 @@ SECTION("test_auth") {
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
TRI_InitV8Views(context, &vocbase, v8g.get(), isolate.get(), arangoDBNS);
TRI_InitV8Views(*v8g, isolate.get(), arangoDBNS);
auto fn_view = arangoDBNS->NewInstance()->Get(TRI_V8_ASCII_STRING(isolate.get(), "_view"));
CHECK((fn_view->IsFunction()));
@ -1119,7 +1119,7 @@ SECTION("test_auth") {
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
TRI_InitV8Views(context, &vocbase, v8g.get(), isolate.get(), arangoDBNS);
TRI_InitV8Views(*v8g, isolate.get(), arangoDBNS);
auto arangoView = v8::Local<v8::ObjectTemplate>::New(isolate.get(), v8g->VocbaseViewTempl)->NewInstance();
auto fn_properties = arangoView->Get(TRI_V8_ASCII_STRING(isolate.get(), "properties"));
@ -1273,7 +1273,7 @@ SECTION("test_auth") {
v8g->ArangoErrorTempl.Reset(isolate.get(), v8::ObjectTemplate::New(isolate.get())); // otherwise v8:-utils::CreateErrorObject(...) will fail
v8g->_vocbase = &vocbase;
auto arangoDBNS = v8::ObjectTemplate::New(isolate.get());
TRI_InitV8Views(context, &vocbase, v8g.get(), isolate.get(), arangoDBNS);
TRI_InitV8Views(*v8g, isolate.get(), arangoDBNS);
auto fn_views = arangoDBNS->NewInstance()->Get(TRI_V8_ASCII_STRING(isolate.get(), "_views"));
CHECK((fn_views->IsFunction()));

4
tests/js/client/authentication/user-access-right-task-update-view-arangosearch.js
View File

@ -30,6 +30,7 @@
'use strict';
var jsunity = require('jsunity');
var analyzers = require("@arangodb/analyzers");
const testHelper = require('@arangodb/test-helper');
const isEqual = testHelper.isEqual;
const deriveTestSuite = testHelper.deriveTestSuite;
@ -243,6 +244,9 @@ function UserRightsManagement(name) {
rootPrepareCollection(testCol2Name);
rootCreateView(testViewName, { links: { [testCol1Name] : {includeAllFields: true } } });
helper.switchUser('root', dbName);
analyzers.save(db._name() + "::text_de", "text", "{ \"locale\": \"de.UTF-8\", \"ignored_words\": [ ] }", [ "frequency", "norm", "position" ]);
analyzers.save(db._name() + "::text_en", "text", "{ \"locale\": \"en.UTF-8\", \"ignored_words\": [ ] }", [ "frequency", "norm", "position" ]);
},
tearDown: function() {

4
tests/js/client/authentication/user-access-right-update-view-arangosearch.js
View File

@ -31,6 +31,7 @@
'use strict';
var jsunity = require('jsunity');
var analyzers = require("@arangodb/analyzers");
const testHelper = require('@arangodb/test-helper');
const isEqual = testHelper.isEqual;
const deriveTestSuite = testHelper.deriveTestSuite;
@ -206,6 +207,9 @@ function UserRightsManagement(name) {
rootCreateView(testViewName, { links: { [testCol1Name] : {includeAllFields: true } } });
db._useDatabase(dbName);
helper.switchUser('root', dbName);
analyzers.save(db._name() + "::text_de", "text", "{ \"locale\": \"de.UTF-8\", \"ignored_words\": [ ] }", [ "frequency", "norm", "position" ]);
analyzers.save(db._name() + "::text_en", "text", "{ \"locale\": \"en.UTF-8\", \"ignored_words\": [ ] }", [ "frequency", "norm", "position" ]);
},
tearDown: function () {

2
tests/js/common/aql/aql-view-arangosearch-cluster.js
View File

@ -30,6 +30,7 @@
var jsunity = require("jsunity");
var db = require("@arangodb").db;
var analyzers = require("@arangodb/analyzers");
var ERRORS = require("@arangodb").errors;
var deriveTestSuite = require('@arangodb/test-helper').deriveTestSuite;
@ -50,6 +51,7 @@ function IResearchAqlTestSuite(args) {
return {
setUp : function () {
analyzers.save(db._name() + "::text_en", "text", "{ \"locale\": \"en.UTF-8\", \"ignored_words\": [ ] }", [ "frequency", "norm", "position" ]);
db._drop("UnitTestsCollection");
c = db._create("UnitTestsCollection", args);

3
tests/js/common/aql/aql-view-arangosearch-ddl-cluster.js
View File

@ -26,6 +26,7 @@
var jsunity = require("jsunity");
var db = require("@arangodb").db;
var analyzers = require("@arangodb/analyzers");
var ERRORS = require("@arangodb").errors;
////////////////////////////////////////////////////////////////////////////////
@ -35,6 +36,8 @@ var ERRORS = require("@arangodb").errors;
function IResearchFeatureDDLTestSuite () {
return {
setUpAll : function () {
analyzers.save(db._name() + "::text_de", "text", "{ \"locale\": \"de.UTF-8\", \"ignored_words\": [ ] }", [ "frequency", "norm", "position" ]);
analyzers.save(db._name() + "::text_en", "text", "{ \"locale\": \"en.UTF-8\", \"ignored_words\": [ ] }", [ "frequency", "norm", "position" ]);
},
tearDownAll : function () {

3
tests/js/common/aql/aql-view-arangosearch-ddl-noncluster.js
View File

@ -26,6 +26,7 @@
var jsunity = require("jsunity");
var db = require("@arangodb").db;
var analyzers = require("@arangodb/analyzers");
var ERRORS = require("@arangodb").errors;
////////////////////////////////////////////////////////////////////////////////
@ -35,6 +36,8 @@ var ERRORS = require("@arangodb").errors;
function IResearchFeatureDDLTestSuite () {
return {
setUpAll : function () {
analyzers.save(db._name() + "::text_de", "text", "{ \"locale\": \"de.UTF-8\", \"ignored_words\": [ ] }", [ "frequency", "norm", "position" ]);
analyzers.save(db._name() + "::text_en", "text", "{ \"locale\": \"en.UTF-8\", \"ignored_words\": [ ] }", [ "frequency", "norm", "position" ]);
},
tearDownAll : function () {

61
tests/js/common/aql/aql-view-arangosearch-feature.js
View File

@ -26,6 +26,7 @@
var jsunity = require("jsunity");
var db = require("@arangodb").db;
var analyzers = require("@arangodb/analyzers");
////////////////////////////////////////////////////////////////////////////////
/// @brief test suite
@ -34,11 +35,71 @@ var db = require("@arangodb").db;
function iResearchFeatureAqlTestSuite () {
return {
setUpAll : function () {
analyzers.save(db._name() + "::text_de", "text", "{ \"locale\": \"de.UTF-8\", \"ignored_words\": [ ] }", [ "frequency", "norm", "position" ]);
analyzers.save(db._name() + "::text_en", "text", "{ \"locale\": \"en.UTF-8\", \"ignored_words\": [ ] }", [ "frequency", "norm", "position" ]);
analyzers.save(db._name() + "::text_es", "text", "{ \"locale\": \"es.UTF-8\", \"ignored_words\": [ ] }", [ "frequency", "norm", "position" ]);
analyzers.save(db._name() + "::text_fi", "text", "{ \"locale\": \"fi.UTF-8\", \"ignored_words\": [ ] }", [ "frequency", "norm", "position" ]);
analyzers.save(db._name() + "::text_fr", "text", "{ \"locale\": \"fr.UTF-8\", \"ignored_words\": [ ] }", [ "frequency", "norm", "position" ]);
analyzers.save(db._name() + "::text_it", "text", "{ \"locale\": \"it.UTF-8\", \"ignored_words\": [ ] }", [ "frequency", "norm", "position" ]);
analyzers.save(db._name() + "::text_nl", "text", "{ \"locale\": \"nl.UTF-8\", \"ignored_words\": [ ] }", [ "frequency", "norm", "position" ]);
analyzers.save(db._name() + "::text_no", "text", "{ \"locale\": \"no.UTF-8\", \"ignored_words\": [ ] }", [ "frequency", "norm", "position" ]);
analyzers.save(db._name() + "::text_pt", "text", "{ \"locale\": \"pt.UTF-8\", \"ignored_words\": [ ] }", [ "frequency", "norm", "position" ]);
analyzers.save(db._name() + "::text_ru", "text", "{ \"locale\": \"ru.UTF-8\", \"ignored_words\": [ ] }", [ "frequency", "norm", "position" ]);
analyzers.save(db._name() + "::text_sv", "text", "{ \"locale\": \"sv.UTF-8\", \"ignored_words\": [ ] }", [ "frequency", "norm", "position" ]);
analyzers.save(db._name() + "::text_zh", "text", "{ \"locale\": \"zh.UTF-8\", \"ignored_words\": [ ] }", [ "frequency", "norm", "position" ]);
},
tearDownAll : function () {
},
////////////////////////////////////////////////////////////////////////////////
/// @brief IResearchAnalyzerFeature tests
////////////////////////////////////////////////////////////////////////////////
testAnalyzers: function() {
let oldList = analyzers.toArray();
assertTrue(Array === oldList.constructor);
// creation
analyzers.save(db._name() + "::testAnalyzer", "identity", "test properties", [ "frequency" ]);
// properties
let analyzer = analyzers.analyzer(db._name() + "::testAnalyzer");
assertTrue(null !== analyzer);
assertEqual(db._name() + "::testAnalyzer", analyzer.name());
assertEqual("identity", analyzer.type());
assertEqual("test properties", analyzer.properties());
assertTrue(Array === analyzer.features().constructor);
assertEqual(1, analyzer.features().length);
assertEqual([ "frequency" ], analyzer.features());
analyzer = undefined; // release reference
// listing
let list = analyzers.toArray();
assertTrue(Array === list.constructor);
assertEqual(oldList.length + 1, list.length);
list = undefined; // release reference
// force server-side V8 garbage collection
if (db._connection !== undefined) { // client test
let url = require('internal').arango.getEndpoint().replace('tcp', 'http');
url += '/_admin/execute?returnAsJSON=true';
let options = require('@arangodb/process-utils').makeAuthorizationHeaders({
username: 'root',
password: ''
});
options.method = 'POST';
require('internal').download(url, 'require("internal").wait(0.1, true);', options);
} else {
require("internal").wait(0.1, true);
}
// removal
analyzers.remove(db._name() + "::testAnalyzer");
assertTrue(null === analyzers.analyzer(db._name() + "::testAnalyzer"));
assertEqual(oldList.length, analyzers.toArray().length);
},
////////////////////////////////////////////////////////////////////////////////
/// @brief IResearchFeature tests
////////////////////////////////////////////////////////////////////////////////

2
tests/js/common/aql/aql-view-arangosearch-noncluster.js
View File

@ -30,6 +30,7 @@
var jsunity = require("jsunity");
var db = require("@arangodb").db;
var analyzers = require("@arangodb/analyzers");
var ERRORS = require("@arangodb").errors;
////////////////////////////////////////////////////////////////////////////////
@ -44,6 +45,7 @@ function iResearchAqlTestSuite () {
return {
setUp : function () {
analyzers.save(db._name() + "::text_en", "text", "{ \"locale\": \"en.UTF-8\", \"ignored_words\": [ ] }", [ "frequency", "norm", "position" ]);
db._drop("UnitTestsCollection");
c = db._create("UnitTestsCollection");

2
tests/js/server/dump/dump-mmfiles-cluster.js
View File

@ -31,6 +31,7 @@
const fs = require('fs');
const internal = require("internal");
const jsunity = require("jsunity");
var analyzers = require("@arangodb/analyzers");
const isEnterprise = internal.isEnterprise();
const db = internal.db;
@ -48,6 +49,7 @@ function dumpTestSuite () {
////////////////////////////////////////////////////////////////////////////////
setUp : function () {
analyzers.save(db._name() + "::text_en", "text", "{ \"locale\": \"en.UTF-8\", \"ignored_words\": [ ] }", [ "frequency", "norm", "position" ]);
},
////////////////////////////////////////////////////////////////////////////////

2
tests/js/server/dump/dump-mmfiles.js
View File

@ -30,6 +30,7 @@
var internal = require("internal");
var jsunity = require("jsunity");
var analyzers = require("@arangodb/analyzers");
////////////////////////////////////////////////////////////////////////////////
/// @brief test suite
@ -46,6 +47,7 @@ function dumpTestSuite () {
////////////////////////////////////////////////////////////////////////////////
setUp : function () {
analyzers.save(db._name() + "::text_en", "text", "{ \"locale\": \"en.UTF-8\", \"ignored_words\": [ ] }", [ "frequency", "norm", "position" ]);
},
////////////////////////////////////////////////////////////////////////////////