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

346 lines
12 KiB
C++
Raw Blame History

////////////////////////////////////////////////////////////////////////////////
/// @brief Class to allow simple byExample matching of mptr.
///
/// @file
///
/// DISCLAIMER
///
/// Copyright 2014-2015 ArangoDB GmbH, Cologne, Germany
/// Copyright 2004-2014 triAGENS 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 Michael Hackstein
/// @author Copyright 2014-2015, ArangoDB GmbH, Cologne, Germany
/// @author Copyright 2011-2013, triAGENS GmbH, Cologne, Germany
////////////////////////////////////////////////////////////////////////////////
#include "ExampleMatcher.h"
#include "V8Server/v8-vocbaseprivate.h"
#include "voc-shaper.h"
#include "V8/v8-utils.h"
#include "V8/v8-conv.h"
#include "Basics/JsonHelper.h"
#include "Basics/StringUtils.h"
#include "Utils/V8ResolverGuard.h"
using namespace std;
using namespace triagens::arango;
using namespace triagens::basics;
////////////////////////////////////////////////////////////////////////////////
/// @brief cleans up the example object
////////////////////////////////////////////////////////////////////////////////
void ExampleMatcher::cleanup () {
auto zone = _shaper->_memoryZone;
// clean shaped json objects
for (auto& def : definitions) {
for (auto& it : def._values) {
TRI_FreeShapedJson(zone, it);
}
}
}
void ExampleMatcher::fillExampleDefinition (v8::Isolate* isolate,
v8::Handle<v8::Object> const& example,
v8::Handle<v8::Array> const& names,
size_t& n,
std::string& errorMessage,
ExampleDefinition& def) {
for (size_t i = 0; i < n; ++i) {
v8::Handle<v8::Value> key = names->Get((uint32_t) i);
v8::Handle<v8::Value> val = example->Get(key);
TRI_Utf8ValueNFC keyStr(TRI_UNKNOWN_MEM_ZONE, key);
if (*keyStr != nullptr) {
auto pid = _shaper->lookupAttributePathByName(_shaper, *keyStr);
if (pid == 0) {
// Internal attributes do have pid == 0.
if (strncmp("_", *keyStr, 1) == 0) {
string const key(*keyStr, (size_t) keyStr.length());
string keyVal = TRI_ObjectToString(val);
if (TRI_VOC_ATTRIBUTE_KEY == key) {
def._internal.insert(make_pair(internalAttr::key, DocumentId(0, keyVal)));
}
else if (TRI_VOC_ATTRIBUTE_REV == key) {
def._internal.insert(make_pair(internalAttr::rev, DocumentId(0, keyVal)));
}
else {
// We need a Collection Name Resolver here now!
TRI_vocbase_t* vocbase = GetContextVocBase(isolate);
if (vocbase == nullptr) {
// This should never be thrown as we are already in a transaction
TRI_V8_THROW_EXCEPTION(TRI_ERROR_ARANGO_DATABASE_NOT_FOUND);
}
V8ResolverGuard resolverGuard(vocbase);
CollectionNameResolver const* resolver = resolverGuard.getResolver();
string colName = keyVal.substr(0, keyVal.find("/"));
keyVal = keyVal.substr(keyVal.find("/") + 1, keyVal.length());
if (TRI_VOC_ATTRIBUTE_ID == key) {
def._internal.insert(make_pair(internalAttr::id, DocumentId(resolver->getCollectionId(colName), keyVal)));
}
else if (TRI_VOC_ATTRIBUTE_FROM == key) {
def._internal.insert(make_pair(internalAttr::from, DocumentId(resolver->getCollectionId(colName), keyVal)));
}
else if (TRI_VOC_ATTRIBUTE_TO == key) {
def._internal.insert(make_pair(internalAttr::to, DocumentId(resolver->getCollectionId(colName), keyVal)));
}
else {
// no attribute path found. this means the result will be empty
throw TRI_RESULT_ELEMENT_NOT_FOUND;
}
}
}
else {
// no attribute path found. this means the result will be empty
throw TRI_RESULT_ELEMENT_NOT_FOUND;
}
}
else {
def._pids.push_back(pid);
auto value = TRI_ShapedJsonV8Object(isolate, val, _shaper, false);
if (value == nullptr) {
throw TRI_RESULT_ELEMENT_NOT_FOUND;
}
def._values.push_back(value);
}
}
else {
errorMessage = "cannot convert attribute path to UTF8";
throw TRI_ERROR_BAD_PARAMETER;
}
}
}
////////////////////////////////////////////////////////////////////////////////
/// @brief Constructor using a v8::Object example
////////////////////////////////////////////////////////////////////////////////
ExampleMatcher::ExampleMatcher (v8::Isolate* isolate,
v8::Handle<v8::Object> const example,
TRI_shaper_t* shaper,
std::string& errorMessage)
: _shaper(shaper) {
v8::Handle<v8::Array> names = example->GetOwnPropertyNames();
size_t n = names->Length();
ExampleDefinition def;
def._pids.reserve(n);
def._values.reserve(n);
try {
ExampleMatcher::fillExampleDefinition(isolate, example, names, n, errorMessage, def);
}
catch (...) {
ExampleMatcher::cleanup();
throw;
}
definitions.emplace_back(move(def));
}
////////////////////////////////////////////////////////////////////////////////
/// @brief Constructor using an v8::Array of v8::Object examples
////////////////////////////////////////////////////////////////////////////////
ExampleMatcher::ExampleMatcher (v8::Isolate* isolate,
v8::Handle<v8::Array> const examples,
TRI_shaper_t* shaper,
std::string& errorMessage)
: _shaper(shaper) {
size_t exCount = examples->Length();
for (size_t j = 0; j < exCount; ++j) {
auto tmp = examples->Get((uint32_t) j);
if (! tmp->IsObject() || tmp->IsArray()) {
// Right now silently ignore this example
continue;
}
v8::Handle<v8::Object> example = v8::Handle<v8::Object>::Cast(tmp);
v8::Handle<v8::Array> names = example->GetOwnPropertyNames();
size_t n = names->Length();
ExampleDefinition def;
def._pids.reserve(n);
def._values.reserve(n);
try {
ExampleMatcher::fillExampleDefinition(isolate, example, names, n, errorMessage, def);
}
catch (...) {
ExampleMatcher::cleanup();
throw;
}
definitions.emplace_back(move(def));
}
}
////////////////////////////////////////////////////////////////////////////////
/// @brief Constructor using a TRI_json_t object
////////////////////////////////////////////////////////////////////////////////
ExampleMatcher::ExampleMatcher (TRI_json_t* const example,
TRI_shaper_t* shaper)
: _shaper(shaper) {
// Just make sure we are talking about objects
TRI_ASSERT(TRI_IsObjectJson(example));
TRI_vector_t objects = example->_value._objects;
ExampleDefinition def;
// Trolololol std::vector in C... ;(
size_t n = TRI_LengthVector(&objects);
def._pids.reserve(n);
def._values.reserve(n);
try {
for (size_t i = 0; i < n; i += 2) {
auto keyObj = static_cast<TRI_json_t const*>(TRI_AtVector(&objects, i));
TRI_ASSERT(TRI_IsStringJson(keyObj));
auto pid = _shaper->lookupAttributePathByName(_shaper, keyObj->_value._string.data);
if (pid == 0) {
// no attribute path found. this means the result will be empty
ExampleMatcher::cleanup();
throw TRI_RESULT_ELEMENT_NOT_FOUND;
}
def._pids.push_back(pid);
auto jsonValue = static_cast<TRI_json_t const*>(TRI_AtVector(&objects, i + 1));
auto value = TRI_ShapedJsonJson(_shaper, jsonValue, false);
if (value == nullptr) {
ExampleMatcher::cleanup();
throw TRI_RESULT_ELEMENT_NOT_FOUND;
}
def._values.push_back(value);
}
}
catch (bad_alloc&) {
ExampleMatcher::cleanup();
throw;
}
definitions.emplace_back(move(def));
}
////////////////////////////////////////////////////////////////////////////////
/// @brief Checks if the given mptr matches the examples in this class
////////////////////////////////////////////////////////////////////////////////
bool ExampleMatcher::matches (TRI_voc_cid_t cid, TRI_doc_mptr_t const* mptr) const {
if (mptr == nullptr) {
return false;
}
TRI_shaped_json_t document;
TRI_EXTRACT_SHAPED_JSON_MARKER(document, mptr->getDataPtr());
for (auto def : definitions) {
if (def._internal.size() > 0) {
// Match _key
auto it = def._internal.find(internalAttr::key);
if (it != def._internal.end()) {
if (strcmp(it->second.key.c_str(), TRI_EXTRACT_MARKER_KEY(mptr)) != 0) {
goto nextExample;
}
}
// Match _rev
it = def._internal.find(internalAttr::rev);
if (it != def._internal.end()) {
if (triagens::basics::StringUtils::uint64(it->second.key) != mptr->_rid) {
goto nextExample;
}
}
// Match _id
it = def._internal.find(internalAttr::id);
if (it != def._internal.end()) {
if (cid != it->second.cid) {
goto nextExample;
}
if (strcmp(it->second.key.c_str(), TRI_EXTRACT_MARKER_KEY(mptr)) != 0) {
goto nextExample;
}
}
// Match _to
it = def._internal.find(internalAttr::to);
if (it != def._internal.end()) {
if (it->second.cid != TRI_EXTRACT_MARKER_TO_CID(mptr)) {
goto nextExample;
}
if (strcmp(it->second.key.c_str(), TRI_EXTRACT_MARKER_TO_KEY(mptr)) != 0) {
goto nextExample;
}
}
// Match _from
it = def._internal.find(internalAttr::from);
if (it != def._internal.end()) {
if (it->second.cid != TRI_EXTRACT_MARKER_FROM_CID(mptr)) {
goto nextExample;
}
if (strcmp(it->second.key.c_str(), TRI_EXTRACT_MARKER_FROM_KEY(mptr)) != 0) {
goto nextExample;
}
}
}
TRI_shaped_json_t result;
TRI_shape_t const* shape;
for (size_t i = 0; i < def._values.size(); ++i) {
TRI_shaped_json_t* example = def._values[i];
bool ok = TRI_ExtractShapedJsonVocShaper(_shaper,
&document,
example->_sid,
def._pids[i],
&result,
&shape);
if (! ok || shape == nullptr) {
goto nextExample;
}
if (result._data.length != example->_data.length) {
// suppress excessive log spam
// LOG_TRACE("expecting length %lu, got length %lu for path %lu",
// (unsigned long) result._data.length,
// (unsigned long) example->_data.length,
// (unsigned long) pids[i]);
goto nextExample;
}
if (memcmp(result._data.data, example->_data.data, example->_data.length) != 0) {
// suppress excessive log spam
// LOG_TRACE("data mismatch at path %lu", (unsigned long) pids[i]);
goto nextExample;
}
}
// If you get here this example matches. Successful hit.
return true;
nextExample:
// This Example does not match, try the next one. Goto requires a statement
continue;
}
return false;
}
Reference in New Issue View Git Blame Copy Permalink