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

Merge branch 'devel' of github.com:arangodb/arangodb into devel

This commit is contained in:
hkernbach 2016-04-29 15:37:24 +02:00
parent cddb11d315 841790e524
commit 23d780cf23
30 changed files with 291 additions and 319 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
arangod/Aql/AqlItemBlock.cpp
View File

@ -494,7 +494,7 @@ void AqlItemBlock::toVelocyPack(arangodb::AqlTransaction* trx,
auto it = table.find(a);
if (it == table.end()) {
a.toVelocyPack(trx, raw);
a.toVelocyPack(trx, raw, false);
data.add(VPackValue(1));
table.emplace(a, pos++);
} else {

29
arangod/Aql/AqlValue.cpp
View File

@ -57,7 +57,7 @@ uint64_t AqlValue::hash(arangodb::AqlTransaction* trx) const {
case DOCVEC:
case RANGE: {
VPackBuilder builder;
toVelocyPack(trx, builder);
toVelocyPack(trx, builder, false);
// we must use the slow hash function here, because a value may have
// different representations in case its an array/object/number
return builder.slice().normalizedHash();
@ -605,14 +605,18 @@ v8::Handle<v8::Value> AqlValue::toV8(
/// @brief materializes a value into the builder
void AqlValue::toVelocyPack(AqlTransaction* trx,
arangodb::velocypack::Builder& builder) const {
arangodb::velocypack::Builder& builder,
bool resolveExternals) const {
switch (type()) {
case VPACK_DOCUMENT:
case VPACK_POINTER:
case VPACK_INLINE:
case VPACK_EXTERNAL: {
// TODO: optionally resolve externals
builder.add(slice());
if (resolveExternals) {
arangodb::basics::VelocyPackHelper::SanitizeExternals(slice(), builder);
} else {
builder.add(slice());
}
break;
}
case DOCVEC: {
@ -620,8 +624,7 @@ void AqlValue::toVelocyPack(AqlTransaction* trx,
for (auto const& it : *_data.docvec) {
size_t const n = it->size();
for (size_t i = 0; i < n; ++i) {
// TODO: optionally resolve externals
it->getValueReference(i, 0).toVelocyPack(trx, builder);
it->getValueReference(i, 0).toVelocyPack(trx, builder, resolveExternals);
}
}
builder.close();
@ -631,7 +634,6 @@ void AqlValue::toVelocyPack(AqlTransaction* trx,
builder.openArray();
size_t const n = _data.range->size();
for (size_t i = 0; i < n; ++i) {
// TODO: optionally resolve externals
builder.add(VPackValue(_data.range->at(i)));
}
builder.close();
@ -641,7 +643,7 @@ void AqlValue::toVelocyPack(AqlTransaction* trx,
}
/// @brief materializes a value into the builder
AqlValue AqlValue::materialize(AqlTransaction* trx, bool& hasCopied) const {
AqlValue AqlValue::materialize(AqlTransaction* trx, bool& hasCopied, bool resolveExternals) const {
switch (type()) {
case VPACK_DOCUMENT:
case VPACK_POINTER:
@ -653,8 +655,7 @@ AqlValue AqlValue::materialize(AqlTransaction* trx, bool& hasCopied) const {
case DOCVEC:
case RANGE: {
VPackBuilder builder;
// TODO: optionally resolve externals
toVelocyPack(trx, builder);
toVelocyPack(trx, builder, resolveExternals);
hasCopied = true;
return AqlValue(builder);
}
@ -792,7 +793,7 @@ AqlValue AqlValue::CreateFromBlocks(
// only enumerate the registers that are left
for (auto const& reg : registers) {
builder.add(VPackValue(variableNames[reg]));
current->getValueReference(i, reg).toVelocyPack(trx, builder);
current->getValueReference(i, reg).toVelocyPack(trx, builder, false);
}
builder.close();
@ -813,7 +814,7 @@ AqlValue AqlValue::CreateFromBlocks(
for (auto const& current : src) {
for (size_t i = 0; i < current->size(); ++i) {
current->getValueReference(i, expressionRegister).toVelocyPack(trx, builder);
current->getValueReference(i, expressionRegister).toVelocyPack(trx, builder, false);
}
}
@ -834,10 +835,10 @@ int AqlValue::Compare(arangodb::AqlTransaction* trx, AqlValue const& left,
if (leftType == RANGE || rightType == RANGE || leftType == DOCVEC || rightType == DOCVEC) {
// range|docvec against x
VPackBuilder leftBuilder;
left.toVelocyPack(trx, leftBuilder);
left.toVelocyPack(trx, leftBuilder, false);
VPackBuilder rightBuilder;
right.toVelocyPack(trx, rightBuilder);
right.toVelocyPack(trx, rightBuilder, false);
return arangodb::basics::VelocyPackHelper::compare(leftBuilder.slice(), rightBuilder.slice(), compareUtf8, options);
}

14
arangod/Aql/AqlValue.h
View File

@ -243,11 +243,14 @@ struct AqlValue final {
v8::Handle<v8::Value> toV8(v8::Isolate* isolate, arangodb::AqlTransaction*) const;
/// @brief materializes a value into the builder
void toVelocyPack(arangodb::AqlTransaction*, arangodb::velocypack::Builder& builder) const;
void toVelocyPack(arangodb::AqlTransaction*,
arangodb::velocypack::Builder& builder,
bool resolveExternals) const;
/// @brief materialize a value into a new one. this expands docvecs and
/// ranges
AqlValue materialize(arangodb::AqlTransaction*, bool& hasCopied) const;
AqlValue materialize(arangodb::AqlTransaction*, bool& hasCopied,
bool resolveExternals) const;
/// @brief return the slice for the value
/// this will throw if the value type is not VPACK_POINTER, VPACK_INLINE or
@ -341,8 +344,9 @@ struct AqlValueMaterializer {
}
}
arangodb::velocypack::Slice slice(AqlValue const& value) {
materialized = value.materialize(trx, hasCopied);
arangodb::velocypack::Slice slice(AqlValue const& value,
bool resolveExternals) {
materialized = value.materialize(trx, hasCopied, resolveExternals);
return materialized.slice();
}

8
arangod/Aql/Expression.cpp
View File

@ -638,7 +638,7 @@ AqlValue Expression::executeSimpleExpressionArray(
startPos, vars, regs, localMustDestroy, false);
AqlValueGuard guard(result, localMustDestroy);
result.toVelocyPack(trx, builder);
result.toVelocyPack(trx, builder, false);
}
builder.close();
@ -677,7 +677,7 @@ AqlValue Expression::executeSimpleExpressionObject(
AqlValue result = executeSimpleExpression(member, trx, argv,
startPos, vars, regs, localMustDestroy, false);
AqlValueGuard guard(result, localMustDestroy);
result.toVelocyPack(trx, builder);
result.toVelocyPack(trx, builder, false);
}
builder.close();
@ -1231,7 +1231,7 @@ AqlValue Expression::executeSimpleExpressionExpansion(
AqlValueGuard guard(item, localMustDestroy);
AqlValueMaterializer materializer(trx);
setVariable(variable, materializer.slice(item));
setVariable(variable, materializer.slice(item, false));
bool takeItem = true;
@ -1256,7 +1256,7 @@ AqlValue Expression::executeSimpleExpressionExpansion(
AqlValue sub =
executeSimpleExpression(projectionNode, trx, argv,
startPos, vars, regs, localMustDestroy, false);
sub.toVelocyPack(trx, builder);
sub.toVelocyPack(trx, builder, false);
if (localMustDestroy) { sub.destroy(); }
}

124
arangod/Aql/Functions.cpp
View File

@ -307,7 +307,7 @@ static void ExtractKeys(std::unordered_set<std::string>& names,
}
} else if (param.isArray()) {
AqlValueMaterializer materializer(trx);
VPackSlice s = materializer.slice(param);
VPackSlice s = materializer.slice(param, false);
for (auto const& v : VPackArrayIterator(s)) {
if (v.isString()) {
@ -363,7 +363,7 @@ static void AppendAsString(arangodb::AqlTransaction* trx,
arangodb::basics::VPackStringBufferAdapter& buffer,
AqlValue const& value) {
AqlValueMaterializer materializer(trx);
VPackSlice slice = materializer.slice(value);
VPackSlice slice = materializer.slice(value, false);
AppendAsString(buffer, slice);
}
@ -374,10 +374,10 @@ static bool ListContainsElement(arangodb::AqlTransaction* trx,
AqlValue const& testee, size_t& index) {
TRI_ASSERT(list.isArray());
AqlValueMaterializer materializer(trx);
VPackSlice slice = materializer.slice(list);
VPackSlice slice = materializer.slice(list, false);
AqlValueMaterializer testeeMaterializer(trx);
VPackSlice testeeSlice = testeeMaterializer.slice(testee);
VPackSlice testeeSlice = testeeMaterializer.slice(testee, false);
VPackArrayIterator it(slice);
while (it.valid()) {
@ -423,7 +423,7 @@ static bool Variance(arangodb::AqlTransaction* trx,
double mean = 0.0;
AqlValueMaterializer materializer(trx);
VPackSlice slice = materializer.slice(values);
VPackSlice slice = materializer.slice(values, false);
for (auto const& element : VPackArrayIterator(slice)) {
if (!element.isNull()) {
@ -450,7 +450,7 @@ static bool SortNumberList(arangodb::AqlTransaction* trx,
TRI_ASSERT(result.empty());
bool unused;
AqlValueMaterializer materializer(trx);
VPackSlice slice = materializer.slice(values);
VPackSlice slice = materializer.slice(values, false);
for (auto const& element : VPackArrayIterator(slice)) {
if (!element.isNull()) {
@ -674,7 +674,7 @@ static AqlValue MergeParameters(arangodb::aql::Query* query,
// use the first argument as the preliminary result
AqlValue initial = ExtractFunctionParameterValue(trx, parameters, 0);
AqlValueMaterializer materializer(trx);
VPackSlice initialSlice = materializer.slice(initial);
VPackSlice initialSlice = materializer.slice(initial, false);
if (initial.isArray() && n == 1) {
// special case: a single array parameter
@ -718,7 +718,7 @@ static AqlValue MergeParameters(arangodb::aql::Query* query,
}
AqlValueMaterializer materializer(trx);
VPackSlice slice = materializer.slice(param);
VPackSlice slice = materializer.slice(param, false);
try {
builder = arangodb::basics::VelocyPackHelper::merge(initialSlice, slice, false,
@ -731,29 +731,6 @@ static AqlValue MergeParameters(arangodb::aql::Query* query,
return AqlValue(builder);
}
/// @brief Transforms an std::vector<VertexId> to AQL VelocyPack values
static AqlValue VertexIdsToAqlValueVPack(arangodb::aql::Query* query,
arangodb::AqlTransaction* trx,
std::vector<std::string> const& ids,
bool includeData = false) {
TransactionBuilderLeaser builder(trx);
builder->openArray();
if (includeData) {
for (auto& it : ids) {
// THROWS ERRORS if the Document was not found
std::string colName;
GetDocumentByIdentifier(trx, colName, it, false, *builder.get());
}
} else {
for (auto& it : ids) {
builder->add(VPackValue(it));
}
}
builder->close();
return AqlValue(builder.get());
}
/// @brief Transforms an std::vector<VPackSlice> to AQL VelocyPack values
static AqlValue VertexIdsToAqlValueVPack(arangodb::aql::Query* query,
arangodb::AqlTransaction* trx,
@ -765,7 +742,6 @@ static AqlValue VertexIdsToAqlValueVPack(arangodb::aql::Query* query,
for (auto& it : ids) {
// THROWS ERRORS if the Document was not found
std::string colName;
// TODO
GetDocumentByIdentifier(trx, colName, it.copyString(), false, *builder.get());
}
} else {
@ -1025,7 +1001,7 @@ AqlValue Functions::ToArray(arangodb::aql::Query* query,
builder->add(value.slice());
} else if (value.isObject()) {
AqlValueMaterializer materializer(trx);
VPackSlice slice = materializer.slice(value);
VPackSlice slice = materializer.slice(value, false);
// return an array with the attribute values
for (auto const& it : VPackObjectIterator(slice)) {
builder->add(it.value);
@ -1167,7 +1143,7 @@ AqlValue Functions::Concat(arangodb::aql::Query* query,
if (member.isArray()) {
// append each member individually
AqlValueMaterializer materializer(trx);
VPackSlice slice = materializer.slice(member);
VPackSlice slice = materializer.slice(member, false);
for (auto const& sub : VPackArrayIterator(slice)) {
if (sub.isNone() || sub.isNull()) {
continue;
@ -1292,7 +1268,7 @@ AqlValue Functions::Unset(arangodb::aql::Query* query,
try {
AqlValueMaterializer materializer(trx);
VPackSlice slice = materializer.slice(value);
VPackSlice slice = materializer.slice(value, false);
TransactionBuilderLeaser builder(trx);
UnsetOrKeep(slice, names, true, false, *builder.get());
return AqlValue(builder.get());
@ -1318,7 +1294,7 @@ AqlValue Functions::UnsetRecursive(arangodb::aql::Query* query,
try {
AqlValueMaterializer materializer(trx);
VPackSlice slice = materializer.slice(value);
VPackSlice slice = materializer.slice(value, false);
TransactionBuilderLeaser builder(trx);
UnsetOrKeep(slice, names, true, true, *builder.get());
return AqlValue(builder.get());
@ -1344,7 +1320,7 @@ AqlValue Functions::Keep(arangodb::aql::Query* query,
try {
AqlValueMaterializer materializer(trx);
VPackSlice slice = materializer.slice(value);
VPackSlice slice = materializer.slice(value, false);
TransactionBuilderLeaser builder(trx);
UnsetOrKeep(slice, names, false, false, *builder.get());
return AqlValue(builder.get());
@ -1426,7 +1402,7 @@ AqlValue Functions::Attributes(arangodb::aql::Query* query,
}
AqlValueMaterializer materializer(trx);
VPackSlice slice = materializer.slice(value);
VPackSlice slice = materializer.slice(value, false);
if (doSort) {
std::set<std::string, arangodb::basics::VelocyPackHelper::AttributeSorterUTF8>
@ -1490,7 +1466,7 @@ AqlValue Functions::Values(arangodb::aql::Query* query,
}
AqlValueMaterializer materializer(trx);
VPackSlice slice = materializer.slice(value);
VPackSlice slice = materializer.slice(value, false);
TransactionBuilderLeaser builder(trx);
builder->openArray();
for (auto const& entry : VPackObjectIterator(slice)) {
@ -1522,7 +1498,7 @@ AqlValue Functions::Min(arangodb::aql::Query* query,
}
AqlValueMaterializer materializer(trx);
VPackSlice slice = materializer.slice(value);
VPackSlice slice = materializer.slice(value, false);
VPackSlice minValue;
for (auto const& it : VPackArrayIterator(slice)) {
@ -1552,7 +1528,7 @@ AqlValue Functions::Max(arangodb::aql::Query* query,
}
AqlValueMaterializer materializer(trx);
VPackSlice slice = materializer.slice(value);
VPackSlice slice = materializer.slice(value, false);
VPackSlice maxValue;
for (auto const& it : VPackArrayIterator(slice)) {
if (maxValue.isNone() || arangodb::basics::VelocyPackHelper::compare(it, maxValue, true) > 0) {
@ -1578,7 +1554,7 @@ AqlValue Functions::Sum(arangodb::aql::Query* query,
}
AqlValueMaterializer materializer(trx);
VPackSlice slice = materializer.slice(value);
VPackSlice slice = materializer.slice(value, false);
double sum = 0.0;
for (auto const& it : VPackArrayIterator(slice)) {
if (it.isNull()) {
@ -1610,7 +1586,7 @@ AqlValue Functions::Average(arangodb::aql::Query* query,
}
AqlValueMaterializer materializer(trx);
VPackSlice slice = materializer.slice(value);
VPackSlice slice = materializer.slice(value, false);
double sum = 0.0;
size_t count = 0;
@ -1713,7 +1689,7 @@ AqlValue Functions::Unique(arangodb::aql::Query* query,
}
AqlValueMaterializer materializer(trx);
VPackSlice slice = materializer.slice(value);
VPackSlice slice = materializer.slice(value, false);
std::unordered_set<VPackSlice,
arangodb::basics::VelocyPackHelper::VPackHash,
@ -1754,7 +1730,7 @@ AqlValue Functions::SortedUnique(arangodb::aql::Query* query,
}
AqlValueMaterializer materializer(trx);
VPackSlice slice = materializer.slice(value);
VPackSlice slice = materializer.slice(value, false);
arangodb::basics::VelocyPackHelper::VPackLess<true> less(trx->transactionContext()->getVPackOptions(), &slice, &slice);
std::set<VPackSlice, arangodb::basics::VelocyPackHelper::VPackLess<true>> values(less);
@ -1801,7 +1777,7 @@ AqlValue Functions::Union(arangodb::aql::Query* query,
}
AqlValueMaterializer materializer(trx);
VPackSlice slice = materializer.slice(value);
VPackSlice slice = materializer.slice(value, false);
// this passes ownership for the JSON contens into result
for (auto const& it : VPackArrayIterator(slice)) {
@ -1850,7 +1826,7 @@ AqlValue Functions::UnionDistinct(arangodb::aql::Query* query,
}
AqlValueMaterializer materializer(trx);
VPackSlice slice = materializer.slice(value);
VPackSlice slice = materializer.slice(value, false);
for (auto const& v : VPackArrayIterator(slice)) {
if (values.find(v) == values.end()) {
@ -1910,7 +1886,7 @@ AqlValue Functions::Intersection(arangodb::aql::Query* query,
}
AqlValueMaterializer materializer(trx);
VPackSlice slice = materializer.slice(value);
VPackSlice slice = materializer.slice(value, false);
for (auto const& it : VPackArrayIterator(slice)) {
if (i == 0) {
@ -2060,7 +2036,7 @@ AqlValue Functions::Neighbors(arangodb::aql::Query* query,
}
AqlValueMaterializer materializer(trx);
VPackSlice s = materializer.slice(options);
VPackSlice s = materializer.slice(options, false);
includeData = arangodb::basics::VelocyPackHelper::getBooleanValue(
s, "includeData", false);
@ -2096,7 +2072,7 @@ AqlValue Functions::Neighbors(arangodb::aql::Query* query,
AqlValue examples = ExtractFunctionParameterValue(trx, parameters, 4);
if (!(examples.isArray() && examples.length() == 0)) {
AqlValueMaterializer materializer(trx);
VPackSlice edges = materializer.slice(examples);
VPackSlice edges = materializer.slice(examples, false);
opts.addEdgeFilter(edges, eColName);
}
}
@ -2260,7 +2236,7 @@ AqlValue Functions::Flatten(arangodb::aql::Query* query,
}
AqlValueMaterializer materializer(trx);
VPackSlice listSlice = materializer.slice(list);
VPackSlice listSlice = materializer.slice(list, false);
try {
TransactionBuilderLeaser builder(trx);
@ -2293,10 +2269,10 @@ AqlValue Functions::Zip(arangodb::aql::Query* query,
try {
AqlValueMaterializer keyMaterializer(trx);
VPackSlice keysSlice = keyMaterializer.slice(keys);
VPackSlice keysSlice = keyMaterializer.slice(keys, false);
AqlValueMaterializer valueMaterializer(trx);
VPackSlice valuesSlice = valueMaterializer.slice(values);
VPackSlice valuesSlice = valueMaterializer.slice(values, false);
TransactionBuilderLeaser builder(trx);
builder->openObject();
@ -2386,7 +2362,7 @@ AqlValue Functions::Minus(arangodb::aql::Query* query,
// Fill the original map
AqlValueMaterializer materializer(trx);
VPackSlice arraySlice = materializer.slice(baseArray);
VPackSlice arraySlice = materializer.slice(baseArray, false);
VPackArrayIterator it(arraySlice);
while (it.valid()) {
@ -2405,7 +2381,7 @@ AqlValue Functions::Minus(arangodb::aql::Query* query,
}
AqlValueMaterializer materializer(trx);
VPackSlice arraySlice = materializer.slice(next);
VPackSlice arraySlice = materializer.slice(next, false);
for (auto const& search : VPackArrayIterator(arraySlice)) {
auto find = contains.find(search);
@ -2451,7 +2427,7 @@ AqlValue Functions::Document(arangodb::aql::Query* query,
}
if (id.isArray()) {
AqlValueMaterializer materializer(trx);
VPackSlice idSlice = materializer.slice(id);
VPackSlice idSlice = materializer.slice(id, false);
builder->openArray();
for (auto const& next : VPackArrayIterator(idSlice)) {
if (next.isString()) {
@ -2494,7 +2470,7 @@ AqlValue Functions::Document(arangodb::aql::Query* query,
builder->openArray();
if (!notFound) {
AqlValueMaterializer materializer(trx);
VPackSlice idSlice = materializer.slice(id);
VPackSlice idSlice = materializer.slice(id, false);
for (auto const& next : VPackArrayIterator(idSlice)) {
if (next.isString()) {
std::string identifier(next.copyString());
@ -2573,7 +2549,7 @@ AqlValue Functions::Edges(arangodb::aql::Query* query,
AqlValue exampleValue = ExtractFunctionParameterValue(trx, parameters, 3);
if ((exampleValue.isArray() && exampleValue.length() != 0) || exampleValue.isObject()) {
AqlValueMaterializer materializer(trx);
VPackSlice exampleSlice = materializer.slice(exampleValue);
VPackSlice exampleSlice = materializer.slice(exampleValue, false);
try {
matcher.reset(
@ -2596,13 +2572,13 @@ AqlValue Functions::Edges(arangodb::aql::Query* query,
AqlValue options = ExtractFunctionParameterValue(trx, parameters, 4);
if (options.isObject()) {
AqlValueMaterializer materializer(trx);
VPackSlice s = materializer.slice(options);
VPackSlice s = materializer.slice(options, false);
includeVertices = arangodb::basics::VelocyPackHelper::getBooleanValue(s, "includeVertices", false);
}
}
AqlValueMaterializer vertexMaterializer(trx);
VPackSlice vertexSlice = vertexMaterializer.slice(vertexValue);
VPackSlice vertexSlice = vertexMaterializer.slice(vertexValue, false);
TransactionBuilderLeaser builder(trx);
builder->openArray();
@ -2757,7 +2733,7 @@ AqlValue Functions::Push(arangodb::aql::Query* query,
AqlValue toPush = ExtractFunctionParameterValue(trx, parameters, 1);
AqlValueMaterializer toPushMaterializer(trx);
VPackSlice p = toPushMaterializer.slice(toPush);
VPackSlice p = toPushMaterializer.slice(toPush, false);
if (list.isNull(true)) {
TransactionBuilderLeaser builder(trx);
@ -2776,7 +2752,7 @@ AqlValue Functions::Push(arangodb::aql::Query* query,
TransactionBuilderLeaser builder(trx);
builder->openArray();
AqlValueMaterializer materializer(trx);
VPackSlice l = materializer.slice(list);
VPackSlice l = materializer.slice(list, false);
for (auto const& it : VPackArrayIterator(l)) {
builder->add(it);
@ -2812,7 +2788,7 @@ AqlValue Functions::Pop(arangodb::aql::Query* query,
try {
AqlValueMaterializer materializer(trx);
VPackSlice slice = materializer.slice(list);
VPackSlice slice = materializer.slice(list, false);
TransactionBuilderLeaser builder(trx);
builder->openArray();
@ -2847,10 +2823,10 @@ AqlValue Functions::Append(arangodb::aql::Query* query,
}
AqlValueMaterializer toAppendMaterializer(trx);
VPackSlice t = toAppendMaterializer.slice(toAppend);
VPackSlice t = toAppendMaterializer.slice(toAppend, false);
AqlValueMaterializer materializer(trx);
VPackSlice l = materializer.slice(list);
VPackSlice l = materializer.slice(list, false);
TransactionBuilderLeaser builder(trx);
builder->openArray();
@ -2867,7 +2843,7 @@ AqlValue Functions::Append(arangodb::aql::Query* query,
}
} else {
AqlValueMaterializer materializer(trx);
VPackSlice slice = materializer.slice(toAppend);
VPackSlice slice = materializer.slice(toAppend, false);
for (auto const& it : VPackArrayIterator(slice)) {
if (!unique || !ListContainsElement(l, it)) {
builder->add(it);
@ -2904,7 +2880,7 @@ AqlValue Functions::Unshift(arangodb::aql::Query* query,
}
AqlValueMaterializer materializer(trx);
VPackSlice a = materializer.slice(toAppend);
VPackSlice a = materializer.slice(toAppend, false);
TransactionBuilderLeaser builder(trx);
builder->openArray();
@ -2912,7 +2888,7 @@ AqlValue Functions::Unshift(arangodb::aql::Query* query,
if (list.isArray()) {
AqlValueMaterializer materializer(trx);
VPackSlice v = materializer.slice(list);
VPackSlice v = materializer.slice(list, false);
for (auto const& it : VPackArrayIterator(v)) {
builder->add(it);
}
@ -2942,7 +2918,7 @@ AqlValue Functions::Shift(arangodb::aql::Query* query,
if (list.length() > 0) {
AqlValueMaterializer materializer(trx);
VPackSlice l = materializer.slice(list);
VPackSlice l = materializer.slice(list, false);
auto iterator = VPackArrayIterator(l);
// This jumps over the first element
@ -2988,10 +2964,10 @@ AqlValue Functions::RemoveValue(arangodb::aql::Query* query,
AqlValue toRemove = ExtractFunctionParameterValue(trx, parameters, 1);
AqlValueMaterializer toRemoveMaterializer(trx);
VPackSlice r = toRemoveMaterializer.slice(toRemove);
VPackSlice r = toRemoveMaterializer.slice(toRemove, false);
AqlValueMaterializer materializer(trx);
VPackSlice v = materializer.slice(list);
VPackSlice v = materializer.slice(list, false);
for (auto const& it : VPackArrayIterator(v)) {
if (useLimit && limit == 0) {
@ -3036,10 +3012,10 @@ AqlValue Functions::RemoveValues(arangodb::aql::Query* query,
try {
AqlValueMaterializer valuesMaterializer(trx);
VPackSlice v = valuesMaterializer.slice(values);
VPackSlice v = valuesMaterializer.slice(values, false);
AqlValueMaterializer listMaterializer(trx);
VPackSlice l = listMaterializer.slice(list);
VPackSlice l = listMaterializer.slice(list, false);
TransactionBuilderLeaser builder(trx);
builder->openArray();
@ -3086,7 +3062,7 @@ AqlValue Functions::RemoveNth(arangodb::aql::Query* query,
try {
AqlValueMaterializer materializer(trx);
VPackSlice v = materializer.slice(list);
VPackSlice v = materializer.slice(list, false);
TransactionBuilderLeaser builder(trx);
size_t target = static_cast<size_t>(p);

2
arangod/Aql/IndexBlock.cpp
View File

@ -107,7 +107,7 @@ void IndexBlock::executeExpressions() {
AstNode* evaluatedNode = nullptr;
AqlValueMaterializer materializer(_trx);
VPackSlice slice = materializer.slice(a);
VPackSlice slice = materializer.slice(a, false);
evaluatedNode = ast->nodeFromVPack(slice, true);
_condition->getMember(toReplace->orMember)

6
arangod/Aql/Query.cpp
View File

@ -583,7 +583,7 @@ QueryResult Query::execute(QueryRegistry* registry) {
AqlValue const& val = value->getValueReference(i, resultRegister);
if (!val.isEmpty()) {
val.toVelocyPack(_trx, *resultBuilder);
val.toVelocyPack(_trx, *resultBuilder, true);
}
}
delete value;
@ -614,7 +614,7 @@ QueryResult Query::execute(QueryRegistry* registry) {
AqlValue const& val = value->getValueReference(i, resultRegister);
if (!val.isEmpty()) {
val.toVelocyPack(_trx, *resultBuilder);
val.toVelocyPack(_trx, *resultBuilder, false);
}
}
delete value;
@ -742,7 +742,7 @@ QueryResultV8 Query::executeV8(v8::Isolate* isolate, QueryRegistry* registry) {
if (!val.isEmpty()) {
result.result->Set(j++, val.toV8(isolate, _trx));
val.toVelocyPack(_trx, *builder);
val.toVelocyPack(_trx, *builder, true);
}
}
delete value;

2
arangod/Aql/TraversalBlock.cpp
View File

@ -185,7 +185,7 @@ void TraversalBlock::executeExpressions() {
AqlValueGuard guard(a, mustDestroy);
AqlValueMaterializer materializer(_trx);
VPackSlice slice = materializer.slice(a);
VPackSlice slice = materializer.slice(a, false);
VPackBuilder* builder = new VPackBuilder;
try {

4
arangod/Cluster/ClusterMethods.cpp
View File

@ -834,7 +834,7 @@ int createDocumentOnCoordinator(
} else {
reqBuilder.clear();
reqBuilder.openObject();
reqBuilder.add(Transaction::KeyString, VPackValue(idx.second));
reqBuilder.add(StaticStrings::KeyString, VPackValue(idx.second));
TRI_SanitizeObject(slice, reqBuilder);
reqBuilder.close();
body = std::make_shared<std::string>(reqBuilder.slice().toJson());
@ -847,7 +847,7 @@ int createDocumentOnCoordinator(
reqBuilder.add(slice.at(idx.first));
} else {
reqBuilder.openObject();
reqBuilder.add(Transaction::KeyString, VPackValue(idx.second));
reqBuilder.add(StaticStrings::KeyString, VPackValue(idx.second));
TRI_SanitizeObject(slice.at(idx.first), reqBuilder);
reqBuilder.close();
}

2
arangod/Cluster/HeartbeatThread.cpp
View File

@ -178,7 +178,7 @@ void HeartbeatThread::runDBServer() {
if (isStopping()) {
break;
}
double remain;
double remain = interval - (TRI_microtime() - start);
// mop: execute at least once
do {
LOG(TRACE) << "Entering update loop";

33
arangod/Indexes/EdgeIndex.cpp
View File

@ -25,6 +25,7 @@
#include "Aql/AstNode.h"
#include "Aql/SortCondition.h"
#include "Basics/Exceptions.h"
#include "Basics/StaticStrings.h"
#include "Basics/fasthash.h"
#include "Basics/hashes.h"
#include "Indexes/SimpleAttributeEqualityMatcher.h"
@ -72,7 +73,7 @@ static uint64_t HashElementEdgeFrom(void*, TRI_doc_mptr_t const* mptr,
} else {
// Is identical to HashElementKey
VPackSlice tmp(mptr->vpack());
tmp = tmp.get(Transaction::FromString);
tmp = tmp.get(StaticStrings::FromString);
TRI_ASSERT(tmp.isString());
// we can get away with the fast hash function here, as edge
// index values are restricted to strings
@ -98,7 +99,7 @@ static uint64_t HashElementEdgeTo(void*, TRI_doc_mptr_t const* mptr,
// Is identical to HashElementKey
VPackSlice tmp(mptr->vpack());
TRI_ASSERT(tmp.isObject());
tmp = tmp.get(Transaction::ToString);
tmp = tmp.get(StaticStrings::ToString);
TRI_ASSERT(tmp.isString());
// we can get away with the fast hash function here, as edge
// index values are restricted to strings
@ -119,7 +120,7 @@ static bool IsEqualKeyEdgeFrom(void*, VPackSlice const* left,
// left is a key
// right is an element, that is a master pointer
VPackSlice tmp(right->vpack());
tmp = tmp.get(Transaction::FromString);
tmp = tmp.get(StaticStrings::FromString);
TRI_ASSERT(tmp.isString());
return *left == tmp;
}
@ -136,7 +137,7 @@ static bool IsEqualKeyEdgeTo(void*, VPackSlice const* left,
// left is a key
// right is an element, that is a master pointer
VPackSlice tmp(right->vpack());
tmp = tmp.get(Transaction::ToString);
tmp = tmp.get(StaticStrings::ToString);
TRI_ASSERT(tmp.isString());
return *left == tmp;
}
@ -161,11 +162,11 @@ static bool IsEqualElementEdgeFromByKey(void*,
TRI_ASSERT(right != nullptr);
VPackSlice lSlice(left->vpack());
lSlice = lSlice.get(Transaction::FromString);
lSlice = lSlice.get(StaticStrings::FromString);
TRI_ASSERT(lSlice.isString());
VPackSlice rSlice(right->vpack());
rSlice = rSlice.get(Transaction::FromString);
rSlice = rSlice.get(StaticStrings::FromString);
TRI_ASSERT(rSlice.isString());
return lSlice == rSlice;
}
@ -181,11 +182,11 @@ static bool IsEqualElementEdgeToByKey(void*,
TRI_ASSERT(right != nullptr);
VPackSlice lSlice(left->vpack());
lSlice = lSlice.get(Transaction::ToString);
lSlice = lSlice.get(StaticStrings::ToString);
TRI_ASSERT(lSlice.isString());
VPackSlice rSlice(right->vpack());
rSlice = rSlice.get(Transaction::ToString);
rSlice = rSlice.get(StaticStrings::ToString);
TRI_ASSERT(rSlice.isString());
return lSlice == rSlice;
}
@ -309,8 +310,8 @@ void AnyDirectionEdgeIndexIterator::reset() {
EdgeIndex::EdgeIndex(TRI_idx_iid_t iid, TRI_document_collection_t* collection)
: Index(iid, collection,
std::vector<std::vector<arangodb::basics::AttributeName>>(
{{{Transaction::FromString, false}},
{{Transaction::ToString, false}}}),
{{{StaticStrings::FromString, false}},
{{StaticStrings::ToString, false}}}),
false, false),
_edgesFrom(nullptr),
_edgesTo(nullptr),
@ -594,8 +595,8 @@ bool EdgeIndex::supportsFilterCondition(
arangodb::aql::Variable const* reference, size_t itemsInIndex,
size_t& estimatedItems, double& estimatedCost) const {
SimpleAttributeEqualityMatcher matcher(
{{arangodb::basics::AttributeName(Transaction::FromString, false)},
{arangodb::basics::AttributeName(Transaction::ToString, false)}});
{{arangodb::basics::AttributeName(StaticStrings::FromString, false)},
{arangodb::basics::AttributeName(StaticStrings::ToString, false)}});
return matcher.matchOne(this, node, reference, itemsInIndex, estimatedItems,
estimatedCost);
}
@ -611,8 +612,8 @@ IndexIterator* EdgeIndex::iteratorForCondition(
TRI_ASSERT(node->type == aql::NODE_TYPE_OPERATOR_NARY_AND);
SimpleAttributeEqualityMatcher matcher(
{{arangodb::basics::AttributeName(Transaction::FromString, false)},
{arangodb::basics::AttributeName(Transaction::ToString, false)}});
{{arangodb::basics::AttributeName(StaticStrings::FromString, false)},
{arangodb::basics::AttributeName(StaticStrings::ToString, false)}});
TRI_ASSERT(node->numMembers() == 1);
@ -667,8 +668,8 @@ arangodb::aql::AstNode* EdgeIndex::specializeCondition(
arangodb::aql::AstNode* node,
arangodb::aql::Variable const* reference) const {
SimpleAttributeEqualityMatcher matcher(
{{arangodb::basics::AttributeName(Transaction::FromString, false)},
{arangodb::basics::AttributeName(Transaction::ToString, false)}});
{{arangodb::basics::AttributeName(StaticStrings::FromString, false)},
{arangodb::basics::AttributeName(StaticStrings::ToString, false)}});
return matcher.specializeOne(this, node, reference);
}

19
arangod/Indexes/PrimaryIndex.cpp
View File

@ -24,6 +24,7 @@
#include "PrimaryIndex.h"
#include "Aql/AstNode.h"
#include "Basics/Exceptions.h"
#include "Basics/StaticStrings.h"
#include "Basics/hashes.h"
#include "Basics/tri-strings.h"
#include "Indexes/SimpleAttributeEqualityMatcher.h"
@ -61,7 +62,7 @@ static bool IsEqualKeyElement(void*, uint8_t const* key,
VPackSlice slice(key);
VPackSlice other(element->vpack());
return other.get(Transaction::KeyString).equals(slice);
return other.get(StaticStrings::KeyString).equals(slice);
}
////////////////////////////////////////////////////////////////////////////////
@ -77,7 +78,7 @@ static bool IsEqualElementElement(void*, TRI_doc_mptr_t const* left,
VPackSlice l(left->vpack());
VPackSlice r(right->vpack());
return l.get(Transaction::KeyString).equals(r.get(Transaction::KeyString));
return l.get(StaticStrings::KeyString).equals(r.get(StaticStrings::KeyString));
}
TRI_doc_mptr_t* PrimaryIndexIterator::next() {
@ -125,7 +126,7 @@ void AnyIndexIterator::reset() {
PrimaryIndex::PrimaryIndex(TRI_document_collection_t* collection)
: Index(0, collection,
std::vector<std::vector<arangodb::basics::AttributeName>>(
{{{Transaction::KeyString, false}}}),
{{{StaticStrings::KeyString, false}}}),
true, false),
_primaryIndex(nullptr) {
uint32_t indexBuckets = 1;
@ -397,8 +398,8 @@ bool PrimaryIndex::supportsFilterCondition(
arangodb::aql::Variable const* reference, size_t itemsInIndex,
size_t& estimatedItems, double& estimatedCost) const {
SimpleAttributeEqualityMatcher matcher(
{{arangodb::basics::AttributeName(Transaction::IdString, false)},
{arangodb::basics::AttributeName(Transaction::KeyString, false)}});
{{arangodb::basics::AttributeName(StaticStrings::IdString, false)},
{arangodb::basics::AttributeName(StaticStrings::KeyString, false)}});
return matcher.matchOne(this, node, reference, itemsInIndex, estimatedItems,
estimatedCost);
@ -415,8 +416,8 @@ IndexIterator* PrimaryIndex::iteratorForCondition(
TRI_ASSERT(node->type == aql::NODE_TYPE_OPERATOR_NARY_AND);
SimpleAttributeEqualityMatcher matcher(
{{arangodb::basics::AttributeName(Transaction::IdString, false)},
{arangodb::basics::AttributeName(Transaction::KeyString, false)}});
{{arangodb::basics::AttributeName(StaticStrings::IdString, false)},
{arangodb::basics::AttributeName(StaticStrings::KeyString, false)}});
TRI_ASSERT(node->numMembers() == 1);
@ -485,8 +486,8 @@ arangodb::aql::AstNode* PrimaryIndex::specializeCondition(
arangodb::aql::AstNode* node,
arangodb::aql::Variable const* reference) const {
SimpleAttributeEqualityMatcher matcher(
{{arangodb::basics::AttributeName(Transaction::IdString, false)},
{arangodb::basics::AttributeName(Transaction::KeyString, false)}});
{{arangodb::basics::AttributeName(StaticStrings::IdString, false)},
{arangodb::basics::AttributeName(StaticStrings::KeyString, false)}});
return matcher.specializeOne(this, node, reference);
}

5
arangod/Indexes/SkiplistIndex.cpp
View File

@ -25,6 +25,7 @@
#include "Aql/AstNode.h"
#include "Aql/SortCondition.h"
#include "Basics/AttributeNameParser.h"
#include "Basics/StaticStrings.h"
#include "Basics/debugging.h"
#include "Basics/VelocyPackHelper.h"
#include "Utils/Transaction.h"
@ -544,8 +545,8 @@ int SkiplistIndex::ElementElementComparator::operator()(
}
// We break this tie in the key comparison by looking at the key:
VPackSlice leftKey = VPackSlice(leftElement->document()->vpack()).get(Transaction::KeyString);
VPackSlice rightKey = VPackSlice(rightElement->document()->vpack()).get(Transaction::KeyString);
VPackSlice leftKey = VPackSlice(leftElement->document()->vpack()).get(StaticStrings::KeyString);
VPackSlice rightKey = VPackSlice(rightElement->document()->vpack()).get(StaticStrings::KeyString);
int compareResult = leftKey.compareString(rightKey.copyString());

15
arangod/RestHandler/RestDocumentHandler.cpp
View File

@ -22,6 +22,7 @@
////////////////////////////////////////////////////////////////////////////////
#include "RestDocumentHandler.h"
#include "Basics/StaticStrings.h"
#include "Basics/StringBuffer.h"
#include "Basics/StringUtils.h"
#include "Basics/VelocyPackHelper.h"
@ -227,10 +228,10 @@ bool RestDocumentHandler::readSingleDocument(bool generateBody) {
VPackBuilder builder;
{
VPackObjectBuilder guard(&builder);
builder.add(Transaction::KeyString, VPackValue(key));
builder.add(StaticStrings::KeyString, VPackValue(key));
if (ifRid != 0) {
options.ignoreRevs = false;
builder.add(Transaction::RevString, VPackValue(std::to_string(ifRid)));
builder.add(StaticStrings::RevString, VPackValue(std::to_string(ifRid)));
}
}
VPackSlice search = builder.slice();
@ -393,7 +394,7 @@ bool RestDocumentHandler::modifyDocument(bool isPatch) {
"invalid revision number");
return false;
}
VPackSlice keyInBody = body.get(Transaction::KeyString);
VPackSlice keyInBody = body.get(StaticStrings::KeyString);
if ((revision != 0 && TRI_ExtractRevisionId(body) != revision) ||
keyInBody.isNone() ||
(keyInBody.isString() && keyInBody.copyString() != key)) {
@ -402,9 +403,9 @@ bool RestDocumentHandler::modifyDocument(bool isPatch) {
{
VPackObjectBuilder guard(builder.get());
TRI_SanitizeObject(body, *builder);
builder->add(Transaction::KeyString, VPackValue(key));
builder->add(StaticStrings::KeyString, VPackValue(key));
if (revision != 0) {
builder->add(Transaction::RevString,
builder->add(StaticStrings::RevString,
VPackValue(std::to_string(revision)));
}
}
@ -523,10 +524,10 @@ bool RestDocumentHandler::deleteDocument() {
if (suffix.size() == 2) {
{
VPackObjectBuilder guard(&builder);
builder.add(Transaction::KeyString, VPackValue(key));
builder.add(StaticStrings::KeyString, VPackValue(key));
if (revision != 0) {
opOptions.ignoreRevs = false;
builder.add(Transaction::RevString, VPackValue(std::to_string(revision)));
builder.add(StaticStrings::RevString, VPackValue(std::to_string(revision)));
}
}
search = builder.slice();

14
arangod/RestHandler/RestImportHandler.cpp
View File

@ -216,20 +216,20 @@ int RestImportHandler::handleSingleDocument(
tempBuilder.clear();
tempBuilder.openObject();
if (!_fromPrefix.empty()) {
VPackSlice from = slice.get(Transaction::FromString);
VPackSlice from = slice.get(StaticStrings::FromString);
if (from.isString()) {
std::string f = from.copyString();
if (f.find('/') == std::string::npos) {
tempBuilder.add(Transaction::FromString, VPackValue(_fromPrefix + f));
tempBuilder.add(StaticStrings::FromString, VPackValue(_fromPrefix + f));
}
}
}
if (!_toPrefix.empty()) {
VPackSlice to = slice.get(Transaction::ToString);
VPackSlice to = slice.get(StaticStrings::ToString);
if (to.isString()) {
std::string t = to.copyString();
if (t.find('/') == std::string::npos) {
tempBuilder.add(Transaction::ToString, VPackValue(_toPrefix + t));
tempBuilder.add(StaticStrings::ToString, VPackValue(_toPrefix + t));
}
}
}
@ -243,9 +243,9 @@ int RestImportHandler::handleSingleDocument(
try {
arangodb::basics::VelocyPackHelper::checkAndGetStringValue(
slice, Transaction::FromString);
slice, StaticStrings::FromString);
arangodb::basics::VelocyPackHelper::checkAndGetStringValue(
slice, Transaction::ToString);
slice, StaticStrings::ToString);
} catch (arangodb::basics::Exception const&) {
std::string part = VPackDumper::toString(slice);
if (part.size() > 255) {
@ -274,7 +274,7 @@ int RestImportHandler::handleSingleDocument(
// special behavior in case of unique constraint violation . . .
if (res == TRI_ERROR_ARANGO_UNIQUE_CONSTRAINT_VIOLATED &&
_onDuplicateAction != DUPLICATE_ERROR) {
VPackSlice const keySlice = slice.get(Transaction::KeyString);
VPackSlice const keySlice = slice.get(StaticStrings::KeyString);
if (keySlice.isString()) {
// insert failed. now try an update/replace

20
arangod/RestHandler/RestVocbaseBaseHandler.cpp
View File

@ -245,10 +245,10 @@ void RestVocbaseBaseHandler::generate20x(
VPackSlice slice = result.slice();
TRI_ASSERT(slice.isObject() || slice.isArray());
if (slice.isObject()) {
_response->setHeaderNC("etag", "\"" + slice.get(Transaction::RevString).copyString() + "\"");
_response->setHeaderNC("etag", "\"" + slice.get(StaticStrings::RevString).copyString() + "\"");
// pre 1.4 location headers withdrawn for >= 3.0
std::string escapedHandle(assembleDocumentId(
collectionName, slice.get(Transaction::KeyString).copyString(), true));
collectionName, slice.get(StaticStrings::KeyString).copyString(), true));
_response->setHeaderNC("location",
std::string("/_db/" + _request->databaseName() +
DOCUMENT_PATH + "/" + escapedHandle));
@ -285,7 +285,7 @@ void RestVocbaseBaseHandler::generatePreconditionFailed(
createResponse(GeneralResponse::ResponseCode::PRECONDITION_FAILED);
if (slice.isObject()) { // single document case
std::string const rev = VelocyPackHelper::getStringValue(slice, Transaction::KeyString, "");
std::string const rev = VelocyPackHelper::getStringValue(slice, StaticStrings::KeyString, "");
_response->setHeaderNC("etag", "\"" + rev + "\"");
}
VPackBuilder builder;
@ -298,9 +298,9 @@ void RestVocbaseBaseHandler::generatePreconditionFailed(
builder.add("errorNum", VPackValue(TRI_ERROR_ARANGO_CONFLICT));
builder.add("errorMessage", VPackValue("precondition failed"));
if (slice.isObject()) {
builder.add(Transaction::IdString, slice.get(Transaction::IdString));
builder.add(Transaction::KeyString, slice.get(Transaction::KeyString));
builder.add(Transaction::RevString, slice.get(Transaction::RevString));
builder.add(StaticStrings::IdString, slice.get(StaticStrings::IdString));
builder.add(StaticStrings::KeyString, slice.get(StaticStrings::KeyString));
builder.add(StaticStrings::RevString, slice.get(StaticStrings::RevString));
} else {
builder.add("result", slice);
}
@ -319,9 +319,9 @@ void RestVocbaseBaseHandler::generatePreconditionFailed(
VPackBuilder builder;
builder.openObject();
builder.add(Transaction::IdString, VPackValue(assembleDocumentId(collectionName, key, false)));
builder.add(Transaction::KeyString, VPackValue(std::to_string(rev)));
builder.add(Transaction::RevString, VPackValue(key));
builder.add(StaticStrings::IdString, VPackValue(assembleDocumentId(collectionName, key, false)));
builder.add(StaticStrings::KeyString, VPackValue(std::to_string(rev)));
builder.add(StaticStrings::RevString, VPackValue(key));
builder.close();
generatePreconditionFailed(builder.slice());
@ -350,7 +350,7 @@ void RestVocbaseBaseHandler::generateDocument(VPackSlice const& input,
VPackSlice document = input.resolveExternal();
std::string rev;
if (document.isObject()) {
rev = VelocyPackHelper::getStringValue(document, Transaction::RevString, "");
rev = VelocyPackHelper::getStringValue(document, StaticStrings::RevString, "");
}
// and generate a response

61
arangod/Utils/Transaction.cpp
View File

@ -28,6 +28,7 @@
#include "Aql/SortCondition.h"
#include "Basics/AttributeNameParser.h"
#include "Basics/Exceptions.h"
#include "Basics/StaticStrings.h"
#include "Basics/StringUtils.h"
#include "Basics/Timers.h"
#include "Basics/VelocyPackHelper.h"
@ -59,16 +60,6 @@
using namespace arangodb;
//////////////////////////////////////////////////////////////////////////////
/// @brief constants for _id, _key, _rev
//////////////////////////////////////////////////////////////////////////////
std::string const Transaction::KeyString(TRI_VOC_ATTRIBUTE_KEY);
std::string const Transaction::RevString(TRI_VOC_ATTRIBUTE_REV);
std::string const Transaction::IdString(TRI_VOC_ATTRIBUTE_ID);
std::string const Transaction::FromString(TRI_VOC_ATTRIBUTE_FROM);
std::string const Transaction::ToString(TRI_VOC_ATTRIBUTE_TO);
//////////////////////////////////////////////////////////////////////////////
/// @brief IndexHandle getter method
//////////////////////////////////////////////////////////////////////////////
@ -607,7 +598,7 @@ DocumentDitch* Transaction::orderDitch(TRI_voc_cid_t cid) {
std::string Transaction::extractKey(VPackSlice const slice) {
// extract _key
if (slice.isObject()) {
VPackSlice k = slice.get(KeyString);
VPackSlice k = slice.get(StaticStrings::KeyString);
if (!k.isString()) {
return ""; // fail
}
@ -644,7 +635,7 @@ std::string Transaction::extractIdString(CollectionNameResolver const* resolver,
VPackSlice id = slice;
if (slice.isObject()) {
// extract id attribute from object
id = slice.get(IdString);
id = slice.get(StaticStrings::IdString);
}
if (id.isString()) {
// already a string...
@ -658,9 +649,9 @@ std::string Transaction::extractIdString(CollectionNameResolver const* resolver,
// we now need to extract the _key attribute
VPackSlice key;
if (slice.isObject()) {
key = slice.get(KeyString);
key = slice.get(StaticStrings::KeyString);
} else if (base.isObject()) {
key = base.get(KeyString);
key = base.get(StaticStrings::KeyString);
}
if (!key.isString()) {
@ -697,13 +688,13 @@ void Transaction::buildDocumentIdentity(TRI_document_collection_t* document,
TRI_doc_mptr_t const* newMptr) {
builder.openObject();
if (ServerState::isRunningInCluster(_serverRole)) {
builder.add(IdString, VPackValue(resolver()->getCollectionName(cid) + "/" + key));
builder.add(StaticStrings::IdString, VPackValue(resolver()->getCollectionName(cid) + "/" + key));
} else {
builder.add(IdString, VPackValue(document->_info.name() + "/" + key));
builder.add(StaticStrings::IdString, VPackValue(document->_info.name() + "/" + key));
}
builder.add(KeyString, VPackValue(key));
builder.add(StaticStrings::KeyString, VPackValue(key));
TRI_ASSERT(!rid.isNone());
builder.add(RevString, rid);
builder.add(StaticStrings::RevString, rid);
if (!oldRid.isNone()) {
builder.add("_oldRev", oldRid);
}
@ -1266,7 +1257,7 @@ OperationResult Transaction::insertLocal(std::string const& collectionName,
TRI_ASSERT(mptr.vpack() != nullptr);
std::string keyString
= VPackSlice(mptr.vpack()).get(KeyString).copyString();
= VPackSlice(mptr.vpack()).get(StaticStrings::KeyString).copyString();
TIMER_START(TRANSACTION_INSERT_BUILD_DOCUMENT_IDENTITY);
@ -1322,10 +1313,10 @@ OperationResult Transaction::insertLocal(std::string const& collectionName,
auto doOneDoc = [&](VPackSlice const& doc, VPackSlice result) {
VPackObjectBuilder guard(&payload);
VPackSlice s = result.get(KeyString);
payload.add(KeyString, s);
s = result.get(RevString);
payload.add(RevString, s);
VPackSlice s = result.get(StaticStrings::KeyString);
payload.add(StaticStrings::KeyString, s);
s = result.get(StaticStrings::RevString);
payload.add(StaticStrings::RevString, s);
TRI_SanitizeObject(doc, payload);
};
@ -1603,7 +1594,7 @@ OperationResult Transaction::modifyLocal(
if (res == TRI_ERROR_ARANGO_CONFLICT) {
// still return
if ((!options.silent || doingSynchronousReplication) && !isBabies) {
std::string key = newVal.get(KeyString).copyString();
std::string key = newVal.get(StaticStrings::KeyString).copyString();
buildDocumentIdentity(document, resultBuilder, cid, key, actualRevision,
VPackSlice(),
options.returnOld ? &previous : nullptr, nullptr);
@ -1616,7 +1607,7 @@ OperationResult Transaction::modifyLocal(
TRI_ASSERT(mptr.vpack() != nullptr);
if (!options.silent || doingSynchronousReplication) {
std::string key = newVal.get(KeyString).copyString();
std::string key = newVal.get(StaticStrings::KeyString).copyString();
buildDocumentIdentity(document, resultBuilder, cid, key,
mptr.revisionIdAsSlice(), actualRevision,
options.returnOld ? &previous : nullptr ,
@ -1664,10 +1655,10 @@ OperationResult Transaction::modifyLocal(
auto doOneDoc = [&](VPackSlice const& doc, VPackSlice result) {
VPackObjectBuilder guard(&payload);
VPackSlice s = result.get(KeyString);
payload.add(KeyString, s);
s = result.get(RevString);
payload.add(RevString, s);
VPackSlice s = result.get(StaticStrings::KeyString);
payload.add(StaticStrings::KeyString, s);
s = result.get(StaticStrings::RevString);
payload.add(StaticStrings::RevString, s);
TRI_SanitizeObject(doc, payload);
};
@ -1842,11 +1833,11 @@ OperationResult Transaction::removeLocal(std::string const& collectionName,
value = builder->slice();
}
} else if (value.isObject()) {
VPackSlice keySlice = value.get(KeyString);
VPackSlice keySlice = value.get(StaticStrings::KeyString);
if (!keySlice.isString()) {
return TRI_ERROR_ARANGO_DOCUMENT_HANDLE_BAD;
}
key = value.get(KeyString).copyString();
key = value.get(StaticStrings::KeyString).copyString();
} else {
return TRI_ERROR_ARANGO_DOCUMENT_HANDLE_BAD;
}
@ -1911,10 +1902,10 @@ OperationResult Transaction::removeLocal(std::string const& collectionName,
auto doOneDoc = [&](VPackSlice const& doc, VPackSlice result) {
VPackObjectBuilder guard(&payload);
VPackSlice s = result.get(KeyString);
payload.add(KeyString, s);
s = result.get(RevString);
payload.add(RevString, s);
VPackSlice s = result.get(StaticStrings::KeyString);
payload.add(StaticStrings::KeyString, s);
s = result.get(StaticStrings::RevString);
payload.add(StaticStrings::RevString, s);
TRI_SanitizeObject(doc, payload);
};

10
arangod/Utils/Transaction.h
View File

@ -857,16 +857,6 @@ class Transaction {
//////////////////////////////////////////////////////////////////////////////
static thread_local std::unordered_set<std::string>* _makeNolockHeaders;
//////////////////////////////////////////////////////////////////////////////
/// @brief constants for _id, _key, _rev
//////////////////////////////////////////////////////////////////////////////
static std::string const KeyString;
static std::string const RevString;
static std::string const IdString;
static std::string const FromString;
static std::string const ToString;
};
class TransactionBuilderLeaser {

31
arangod/V8Server/V8Traverser.cpp
View File

@ -22,6 +22,7 @@
////////////////////////////////////////////////////////////////////////////////
#include "V8Traverser.h"
#include "Basics/StaticStrings.h"
#include "Indexes/EdgeIndex.h"
#include "Utils/CollectionNameResolver.h"
#include "Utils/OperationCursor.h"
@ -93,7 +94,7 @@ static OperationResult FetchDocumentById(arangodb::Transaction* trx,
trx->addCollectionAtRuntime(col);
builder.clear();
builder.openObject();
builder.add(VPackValue(Transaction::KeyString));
builder.add(VPackValue(StaticStrings::KeyString));
builder.add(VPackValue(id.substr(pos + 1)));
builder.close();
@ -134,9 +135,9 @@ struct BasicExpander {
edgeCursor->getMoreMptr(_cursor, UINT64_MAX);
for (auto const& mptr : _cursor) {
VPackSlice edge(mptr->vpack());
VPackSlice from = edge.get(Transaction::FromString);
VPackSlice from = edge.get(StaticStrings::FromString);
if (from == v) {
VPackSlice to = edge.get(Transaction::ToString);
VPackSlice to = edge.get(StaticStrings::ToString);
if (to != v) {
res_edges.emplace_back(std::move(edge));
neighbors.emplace_back(std::move(to));
@ -284,8 +285,8 @@ class MultiCollectionEdgeExpander {
if (!_isAllowed(edge)) {
continue;
}
VPackSlice from = edge.get(Transaction::FromString);
VPackSlice to = edge.get(Transaction::ToString);
VPackSlice from = edge.get(StaticStrings::FromString);
VPackSlice to = edge.get(StaticStrings::ToString);
double currentWeight = edgeCollection->weightEdge(edge);
if (from == source) {
inserter(from, to, currentWeight, edge);
@ -350,8 +351,8 @@ class SimpleEdgeExpander {
}
VPackSlice edges = opRes->slice();
for (auto const& edge : VPackArrayIterator(edges)) {
VPackSlice const from = edge.get(Transaction::FromString);
VPackSlice const to = edge.get(Transaction::ToString);
VPackSlice const from = edge.get(StaticStrings::FromString);
VPackSlice const to = edge.get(StaticStrings::ToString);
double currentWeight = _edgeCollection->weightEdge(edge);
if (from == source) {
inserter(std::move(from), std::move(to), currentWeight, edge);
@ -557,7 +558,7 @@ bool NeighborsOptions::matchesVertex(std::string const& id) const {
std::string key = id.substr(pos + 1);
VPackBuilder tmp;
tmp.openObject();
tmp.add(Transaction::KeyString, VPackValue(key));
tmp.add(StaticStrings::KeyString, VPackValue(key));
tmp.close();
OperationOptions opOpts;
OperationResult opRes = _trx->document(col, tmp.slice(), opOpts);
@ -632,7 +633,7 @@ std::unique_ptr<ArangoDBPathFinder::Path> TRI_RunShortestPathSearch(
tmpBuilder.clear();
tmpBuilder.openObject();
tmpBuilder.add(Transaction::KeyString, VPackValue(key));
tmpBuilder.add(StaticStrings::KeyString, VPackValue(key));
tmpBuilder.close();
OperationOptions opOpts;
OperationResult opRes = opts.trx()->document(col, tmpBuilder.slice(), opOpts);
@ -723,7 +724,7 @@ static void InboundNeighbors(std::vector<EdgeCollectionInfo*> const& collectionI
for (auto const& mptr : cursor) {
VPackSlice edge(mptr->vpack());
if (opts.matchesEdge(edge)) {
VPackSlice v = edge.get(Transaction::FromString);
VPackSlice v = edge.get(StaticStrings::FromString);
if (visited.find(v) != visited.end()) {
// We have already visited this vertex
continue;
@ -774,7 +775,7 @@ static void OutboundNeighbors(std::vector<EdgeCollectionInfo*> const& collection
for (auto const& mptr : cursor) {
VPackSlice edge(mptr->vpack());
if (opts.matchesEdge(edge)) {
VPackSlice v = edge.get(Transaction::ToString);
VPackSlice v = edge.get(StaticStrings::ToString);
if (visited.find(v) != visited.end()) {
// We have already visited this vertex
continue;
@ -826,7 +827,7 @@ static void AnyNeighbors(std::vector<EdgeCollectionInfo*> const& collectionInfos
for (auto const& mptr : cursor) {
VPackSlice edge(mptr->vpack());
if (opts.matchesEdge(edge)) {
VPackSlice v = edge.get(Transaction::ToString);
VPackSlice v = edge.get(StaticStrings::ToString);
if (visited.find(v) == visited.end()) {
if (depth >= opts.minDepth) {
if (opts.matchesVertex(v)) {
@ -839,7 +840,7 @@ static void AnyNeighbors(std::vector<EdgeCollectionInfo*> const& collectionInfos
visited.emplace(std::move(v));
continue;
}
v = edge.get(Transaction::FromString);
v = edge.get(StaticStrings::FromString);
if (visited.find(v) == visited.end()) {
if (depth >= opts.minDepth) {
if (opts.matchesVertex(v)) {
@ -1018,9 +1019,9 @@ void DepthFirstTraverser::_defInternalFunctions() {
TRI_ASSERT(it != _edges.end());
VPackSlice v(it->second->data());
// NOTE: We assume that we only have valid edges.
result = v.get(Transaction::FromString).copyString();
result = v.get(StaticStrings::FromString).copyString();
if (result == vertex) {
result = v.get(Transaction::ToString).copyString();
result = v.get(StaticStrings::ToString).copyString();
}
return true;
};

5
arangod/V8Server/v8-collection.cpp
View File

@ -27,6 +27,7 @@
#include "Basics/Utf8Helper.h"
#include "Basics/conversions.h"
#include "Basics/ScopeGuard.h"
#include "Basics/StaticStrings.h"
#include "Basics/VelocyPackHelper.h"
#include "Cluster/ClusterMethods.h"
#include "Indexes/PrimaryIndex.h"
@ -2212,13 +2213,13 @@ static void JS_InsertVocbaseCol(
if (tmpId.empty()) {
THROW_ARANGO_EXCEPTION(TRI_ERROR_ARANGO_DOCUMENT_HANDLE_BAD);
}
builder.add(Transaction::FromString, VPackValue(tmpId));
builder.add(StaticStrings::FromString, VPackValue(tmpId));
tmpId = ExtractIdString(isolate, args[1]);
if (tmpId.empty()) {
THROW_ARANGO_EXCEPTION(TRI_ERROR_ARANGO_DOCUMENT_HANDLE_BAD);
}
builder.add(Transaction::ToString, VPackValue(tmpId));
builder.add(StaticStrings::ToString, VPackValue(tmpId));
}
builder.close();

9
arangod/V8Server/v8-query.cpp
View File

@ -24,6 +24,7 @@
#include "v8-query.h"
#include "Aql/Query.h"
#include "Aql/QueryResultV8.h"
#include "Basics/StaticStrings.h"
#include "Basics/VelocyPackHelper.h"
#include "Indexes/GeoIndex2.h"
#include "Utils/OperationCursor.h"
@ -128,8 +129,8 @@ static void EdgesQuery(TRI_edge_direction_e direction,
builder->add(VPackValue(TRI_ObjectToString(val)));
} else if (val->IsObject()) {
v8::Handle<v8::Object> obj = val->ToObject();
if (obj->Has(TRI_V8_ASCII_STD_STRING(isolate, Transaction::IdString))) {
builder->add(VPackValue(TRI_ObjectToString(obj->Get(TRI_V8_ASCII_STD_STRING(isolate, Transaction::IdString)))));
if (obj->Has(TRI_V8_ASCII_STD_STRING(isolate, StaticStrings::IdString))) {
builder->add(VPackValue(TRI_ObjectToString(obj->Get(TRI_V8_ASCII_STD_STRING(isolate, StaticStrings::IdString)))));
} else {
builder->add(VPackValue(""));
}
@ -372,10 +373,10 @@ static void JS_ChecksumCollection(
trx.invokeOnAllElements(col->_name, [&hash, &withData, &withRevisions](TRI_doc_mptr_t const* mptr) {
VPackSlice const slice(mptr->vpack());
uint64_t localHash = slice.get(Transaction::KeyString).hash();
uint64_t localHash = slice.get(StaticStrings::KeyString).hash();
if (withRevisions) {
localHash += slice.get(Transaction::RevString).hash();
localHash += slice.get(StaticStrings::RevString).hash();
}
if (withData) {

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

@ -41,6 +41,7 @@
#include "Aql/QueryRegistry.h"
#include "Basics/MutexLocker.h"
#include "Basics/ScopeGuard.h"
#include "Basics/StaticStrings.h"
#include "Basics/Timers.h"
#include "Basics/Utf8Helper.h"
#include "Basics/conversions.h"
@ -1709,7 +1710,7 @@ static v8::Handle<v8::Value> VertexIdToData(v8::Isolate* isolate,
VPackBuilder builder;
builder.openObject();
builder.add(Transaction::KeyString, VPackValue(parts[1]));
builder.add(StaticStrings::KeyString, VPackValue(parts[1]));
builder.close();
OperationResult opRes = trx->document(parts[0], builder.slice(), options);
@ -2173,30 +2174,6 @@ static void JS_QueryShortestPath(
/// @brief Transforms an vector<VertexId> to v8 json values
////////////////////////////////////////////////////////////////////////////////
static v8::Handle<v8::Value> VertexIdsToV8(v8::Isolate* isolate,
ExplicitTransaction* trx,
std::vector<std::string> const& ids,
bool includeData = false) {
v8::EscapableHandleScope scope(isolate);
uint32_t const vn = static_cast<uint32_t>(ids.size());
v8::Handle<v8::Array> vertices =
v8::Array::New(isolate, static_cast<int>(vn));
uint32_t j = 0;
if (includeData) {
for (auto& it : ids) {
vertices->Set(j, VertexIdToData(isolate, trx, it));
++j;
}
} else {
for (auto& it : ids) {
vertices->Set(j, TRI_V8_STD_STRING(it));
++j;
}
}
return scope.Escape<v8::Value>(vertices);
}
static v8::Handle<v8::Value> VertexIdsToV8(v8::Isolate* isolate,
ExplicitTransaction* trx,
std::vector<VPackSlice> const& ids,

113
arangod/VocBase/document-collection.cpp
View File

@ -30,8 +30,8 @@
#include "Basics/FileUtils.h"
#include "Basics/Timers.h"
#include "Basics/files.h"
#include "Logger/Logger.h"
#include "Basics/tri-strings.h"
#include "Basics/StaticStrings.h"
#include "Basics/ThreadPool.h"
#include "Basics/VelocyPackHelper.h"
#include "Basics/WriteLocker.h"
@ -44,6 +44,7 @@
#include "Indexes/HashIndex.h"
#include "Indexes/PrimaryIndex.h"
#include "Indexes/SkiplistIndex.h"
#include "Logger/Logger.h"
#include "Utils/CollectionNameResolver.h"
#include "Utils/CollectionReadLocker.h"
#include "Utils/CollectionWriteLocker.h"
@ -785,9 +786,9 @@ static int OpenIteratorHandleDocumentMarker(TRI_df_marker_t const* marker,
arangodb::Transaction* trx = state->_trx;
VPackSlice const slice(reinterpret_cast<char const*>(marker) + DatafileHelper::VPackOffset(TRI_DF_MARKER_VPACK_DOCUMENT));
VPackSlice const keySlice = slice.get(Transaction::KeyString);
VPackSlice const keySlice = slice.get(StaticStrings::KeyString);
std::string const key(keySlice.copyString());
TRI_voc_rid_t const rid = std::stoull(slice.get(Transaction::RevString).copyString());
TRI_voc_rid_t const rid = std::stoull(slice.get(StaticStrings::RevString).copyString());
SetRevision(document, rid, false);
document->_keyGenerator->track(key);
@ -889,9 +890,9 @@ static int OpenIteratorHandleDeletionMarker(TRI_df_marker_t const* marker,
arangodb::Transaction* trx = state->_trx;
VPackSlice const slice(reinterpret_cast<char const*>(marker) + DatafileHelper::VPackOffset(TRI_DF_MARKER_VPACK_REMOVE));
VPackSlice const keySlice = slice.get(Transaction::KeyString);
VPackSlice const keySlice = slice.get(StaticStrings::KeyString);
std::string const key(keySlice.copyString());
TRI_voc_rid_t const rid = std::stoull(slice.get(Transaction::RevString).copyString());
TRI_voc_rid_t const rid = std::stoull(slice.get(StaticStrings::RevString).copyString());
document->setLastRevision(rid, false);
document->_keyGenerator->track(key);
@ -3283,7 +3284,7 @@ int TRI_document_collection_t::insert(Transaction* trx, VPackSlice const slice,
if (isEdgeCollection) {
// _from:
fromSlice = slice.get(Transaction::FromString);
fromSlice = slice.get(StaticStrings::FromString);
if (!fromSlice.isString()) {
return TRI_ERROR_ARANGO_INVALID_EDGE_ATTRIBUTE;
}
@ -3294,7 +3295,7 @@ int TRI_document_collection_t::insert(Transaction* trx, VPackSlice const slice,
return TRI_ERROR_ARANGO_INVALID_EDGE_ATTRIBUTE;
}
// _to:
toSlice = slice.get(Transaction::ToString);
toSlice = slice.get(StaticStrings::ToString);
if (!toSlice.isString()) {
return TRI_ERROR_ARANGO_INVALID_EDGE_ATTRIBUTE;
}
@ -3321,7 +3322,7 @@ int TRI_document_collection_t::insert(Transaction* trx, VPackSlice const slice,
TRI_ASSERT(slice.isObject());
// we can get away with the fast hash function here, as key values are
// restricted to strings
hash = slice.get(Transaction::KeyString).hash();
hash = slice.get(StaticStrings::KeyString).hash();
newSlice = slice;
}
@ -3427,7 +3428,7 @@ int TRI_document_collection_t::update(Transaction* trx,
revisionId = TRI_NewTickServer();
}
VPackSlice key = newSlice.get(Transaction::KeyString);
VPackSlice key = newSlice.get(StaticStrings::KeyString);
if (key.isNone()) {
return TRI_ERROR_ARANGO_DOCUMENT_HANDLE_BAD;
}
@ -3463,7 +3464,7 @@ int TRI_document_collection_t::update(Transaction* trx,
// Check old revision:
if (!options.ignoreRevs) {
VPackSlice expectedRevSlice = newSlice.get(Transaction::RevString);
VPackSlice expectedRevSlice = newSlice.get(StaticStrings::RevString);
int res = checkRevision(trx, expectedRevSlice, prevRev);
if (res != TRI_ERROR_NO_ERROR) {
return res;
@ -3557,11 +3558,11 @@ int TRI_document_collection_t::replace(Transaction* trx,
bool const isEdgeCollection = (_info.type() == TRI_COL_TYPE_EDGE);
if (isEdgeCollection) {
fromSlice = newSlice.get(Transaction::FromString);
fromSlice = newSlice.get(StaticStrings::FromString);
if (!fromSlice.isString()) {
return TRI_ERROR_ARANGO_INVALID_EDGE_ATTRIBUTE;
}
toSlice = newSlice.get(Transaction::ToString);
toSlice = newSlice.get(StaticStrings::ToString);
if (!toSlice.isString()) {
return TRI_ERROR_ARANGO_INVALID_EDGE_ATTRIBUTE;
}
@ -3593,7 +3594,7 @@ int TRI_document_collection_t::replace(Transaction* trx,
// get the header pointer of the previous revision
TRI_doc_mptr_t* oldHeader;
VPackSlice key = newSlice.get(Transaction::KeyString);
VPackSlice key = newSlice.get(StaticStrings::KeyString);
if (key.isNone()) {
return TRI_ERROR_ARANGO_DOCUMENT_HANDLE_BAD;
}
@ -3617,7 +3618,7 @@ int TRI_document_collection_t::replace(Transaction* trx,
// Check old revision:
if (!options.ignoreRevs) {
VPackSlice expectedRevSlice = newSlice.get(Transaction::RevString);
VPackSlice expectedRevSlice = newSlice.get(StaticStrings::RevString);
int res = checkRevision(trx, expectedRevSlice, prevRev);
if (res != TRI_ERROR_NO_ERROR) {
return res;
@ -3751,7 +3752,7 @@ int TRI_document_collection_t::remove(arangodb::Transaction* trx,
if (slice.isString()) {
key = slice;
} else {
key = slice.get(Transaction::KeyString);
key = slice.get(StaticStrings::KeyString);
}
TRI_ASSERT(!key.isNone());
res = lookupDocument(trx, key, oldHeader);
@ -3765,7 +3766,7 @@ int TRI_document_collection_t::remove(arangodb::Transaction* trx,
// Check old revision:
if (!options.ignoreRevs && slice.isObject()) {
VPackSlice expectedRevSlice = slice.get(Transaction::RevString);
VPackSlice expectedRevSlice = slice.get(StaticStrings::RevString);
int res = checkRevision(trx, expectedRevSlice, prevRev);
if (res != TRI_ERROR_NO_ERROR) {
return res;
@ -4101,7 +4102,7 @@ int TRI_document_collection_t::deletePrimaryIndex(
auto found = primaryIndex()->removeKey(
trx,
VPackSlice(header->vpack()).get(Transaction::KeyString));
VPackSlice(header->vpack()).get(StaticStrings::KeyString));
if (found == nullptr) {
return TRI_ERROR_ARANGO_DOCUMENT_NOT_FOUND;
@ -4160,7 +4161,7 @@ int TRI_document_collection_t::newObjectForInsert(
// add system attributes first
// _key
VPackSlice s = value.get(Transaction::KeyString);
VPackSlice s = value.get(StaticStrings::KeyString);
if (s.isNone()) {
TRI_ASSERT(!isRestore); // need key in case of restore
newRev = TRI_NewTickServer();
@ -4168,7 +4169,7 @@ int TRI_document_collection_t::newObjectForInsert(
if (keyString.empty()) {
return TRI_ERROR_ARANGO_OUT_OF_KEYS;
}
uint8_t* where = builder.add(Transaction::KeyString,
uint8_t* where = builder.add(StaticStrings::KeyString,
VPackValue(keyString));
s = VPackSlice(where); // point to newly built value, the string
} else if (!s.isString()) {
@ -4179,11 +4180,11 @@ int TRI_document_collection_t::newObjectForInsert(
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
builder.add(Transaction::KeyString, s);
builder.add(StaticStrings::KeyString, s);
}
// _id
uint8_t* p = builder.add(Transaction::IdString,
uint8_t* p = builder.add(StaticStrings::IdString,
VPackValuePair(9ULL, VPackValueType::Custom));
*p++ = 0xf3; // custom type for _id
if (ServerState::isDBServer(trx->serverRole())) {
@ -4201,8 +4202,8 @@ int TRI_document_collection_t::newObjectForInsert(
if (isEdgeCollection) {
TRI_ASSERT(!fromSlice.isNone());
TRI_ASSERT(!toSlice.isNone());
builder.add(Transaction::FromString, fromSlice);
builder.add(Transaction::ToString, toSlice);
builder.add(StaticStrings::FromString, fromSlice);
builder.add(StaticStrings::ToString, toSlice);
}
// _rev
@ -4219,7 +4220,7 @@ int TRI_document_collection_t::newObjectForInsert(
}
newRevSt = std::to_string(newRev);
}
builder.add(Transaction::RevString, VPackValue(newRevSt));
builder.add(StaticStrings::RevString, VPackValue(newRevSt));
// add other attributes after the system attributes
TRI_SanitizeObjectWithEdges(value, builder);
@ -4248,25 +4249,25 @@ void TRI_document_collection_t::newObjectForReplace(
// add system attributes first
// _key
VPackSlice s = oldValue.get(Transaction::KeyString);
VPackSlice s = oldValue.get(StaticStrings::KeyString);
TRI_ASSERT(!s.isNone());
builder.add(Transaction::KeyString, s);
builder.add(StaticStrings::KeyString, s);
// _id
s = oldValue.get(Transaction::IdString);
s = oldValue.get(StaticStrings::IdString);
TRI_ASSERT(!s.isNone());
builder.add(Transaction::IdString, s);
builder.add(StaticStrings::IdString, s);
// _from and _to here
if (isEdgeCollection) {
TRI_ASSERT(!fromSlice.isNone());
TRI_ASSERT(!toSlice.isNone());
builder.add(Transaction::FromString, fromSlice);
builder.add(Transaction::ToString, toSlice);
builder.add(StaticStrings::FromString, fromSlice);
builder.add(StaticStrings::ToString, toSlice);
}
// _rev
builder.add(Transaction::RevString, VPackValue(rev));
builder.add(StaticStrings::RevString, VPackValue(rev));
// add other attributes after the system attributes
TRI_SanitizeObjectWithEdges(newValue, builder);
@ -4290,8 +4291,8 @@ void TRI_document_collection_t::mergeObjectsForUpdate(
b.openObject();
VPackSlice keySlice = oldValue.get(Transaction::KeyString);
VPackSlice idSlice = oldValue.get(Transaction::IdString);
VPackSlice keySlice = oldValue.get(StaticStrings::KeyString);
VPackSlice idSlice = oldValue.get(StaticStrings::IdString);
TRI_ASSERT(!keySlice.isNone());
TRI_ASSERT(!idSlice.isNone());
@ -4305,15 +4306,15 @@ void TRI_document_collection_t::mergeObjectsForUpdate(
while (it.valid()) {
std::string key = it.key().copyString();
if (!key.empty() && key[0] == '_' &&
(key == Transaction::KeyString ||
key == Transaction::IdString ||
key == Transaction::RevString ||
key == Transaction::FromString ||
key == Transaction::ToString)) {
(key == StaticStrings::KeyString ||
key == StaticStrings::IdString ||
key == StaticStrings::RevString ||
key == StaticStrings::FromString ||
key == StaticStrings::ToString)) {
// note _from and _to and ignore _id, _key and _rev
if (key == Transaction::FromString) {
if (key == StaticStrings::FromString) {
fromSlice = it.value();
} else if (key == Transaction::ToString) {
} else if (key == StaticStrings::ToString) {
toSlice = it.value();
}
} else {
@ -4327,31 +4328,31 @@ void TRI_document_collection_t::mergeObjectsForUpdate(
if (isEdgeCollection) {
if (fromSlice.isNone()) {
fromSlice = oldValue.get(Transaction::FromString);
fromSlice = oldValue.get(StaticStrings::FromString);
}
if (toSlice.isNone()) {
toSlice = oldValue.get(Transaction::ToString);
toSlice = oldValue.get(StaticStrings::ToString);
}
}
// add system attributes first
// _key
b.add(Transaction::KeyString, keySlice);
b.add(StaticStrings::KeyString, keySlice);
// _id
b.add(Transaction::IdString, idSlice);
b.add(StaticStrings::IdString, idSlice);
// _from, _to
if (isEdgeCollection) {
TRI_ASSERT(!fromSlice.isNone());
TRI_ASSERT(!toSlice.isNone());
b.add(Transaction::FromString, fromSlice);
b.add(Transaction::ToString, toSlice);
b.add(StaticStrings::FromString, fromSlice);
b.add(StaticStrings::ToString, toSlice);
}
// _rev
b.add(Transaction::RevString, VPackValue(rev));
b.add(StaticStrings::RevString, VPackValue(rev));
// add other attributes after the system attributes
{
@ -4360,11 +4361,11 @@ void TRI_document_collection_t::mergeObjectsForUpdate(
std::string key = it.key().copyString();
// exclude system attributes in old value now
if (!key.empty() && key[0] == '_' &&
(key == Transaction::KeyString ||
key == Transaction::IdString ||
key == Transaction::RevString ||
key == Transaction::FromString ||
key == Transaction::ToString)) {
(key == StaticStrings::KeyString ||
key == StaticStrings::IdString ||
key == StaticStrings::RevString ||
key == StaticStrings::FromString ||
key == StaticStrings::ToString)) {
it.next();
continue;
}
@ -4425,12 +4426,12 @@ void TRI_document_collection_t::newObjectForRemove(
builder.openObject();
if (oldValue.isString()) {
builder.add(Transaction::KeyString, oldValue);
builder.add(StaticStrings::KeyString, oldValue);
} else {
VPackSlice s = oldValue.get(Transaction::KeyString);
VPackSlice s = oldValue.get(StaticStrings::KeyString);
TRI_ASSERT(s.isString());
builder.add(Transaction::KeyString, s);
builder.add(StaticStrings::KeyString, s);
}
builder.add(Transaction::RevString, VPackValue(rev));
builder.add(StaticStrings::RevString, VPackValue(rev));
builder.close();
}

17
arangod/VocBase/vocbase.cpp
View File

@ -32,6 +32,7 @@
#include "Aql/QueryList.h"
#include "Basics/Exceptions.h"
#include "Basics/FileUtils.h"
#include "Basics/StaticStrings.h"
#include "Basics/VelocyPackHelper.h"
#include "Basics/WriteLocker.h"
#include "Basics/conversions.h"
@ -2359,9 +2360,9 @@ void TRI_SanitizeObject(VPackSlice const slice, VPackBuilder& builder) {
while (it.valid()) {
std::string key(it.key().copyString());
if (key.empty() || key[0] != '_' ||
(key != Transaction::KeyString &&
key != Transaction::IdString &&
key != Transaction::RevString)) {
(key != StaticStrings::KeyString &&
key != StaticStrings::IdString &&
key != StaticStrings::RevString)) {
builder.add(std::move(key), it.value());
}
it.next();
@ -2379,11 +2380,11 @@ void TRI_SanitizeObjectWithEdges(VPackSlice const slice, VPackBuilder& builder)
while (it.valid()) {
std::string key(it.key().copyString());
if (key.empty() || key[0] != '_' ||
(key != Transaction::KeyString &&
key != Transaction::IdString &&
key != Transaction::RevString &&
key != Transaction::FromString &&
key != Transaction::ToString)) {
(key != StaticStrings::KeyString &&
key != StaticStrings::IdString &&
key != StaticStrings::RevString &&
key != StaticStrings::FromString &&
key != StaticStrings::ToString)) {
builder.add(std::move(key), it.value());
}
it.next();

4
arangod/Wal/LogfileManager.cpp
View File

@ -140,6 +140,8 @@ LogfileManager::~LogfileManager() {
delete _slots;
_slots = nullptr;
}
Instance = nullptr;
}
void LogfileManager::collectOptions(std::shared_ptr<ProgramOptions> options) {
@ -528,8 +530,6 @@ void LogfileManager::stop() {
if (res != TRI_ERROR_NO_ERROR) {
LOG(ERR) << "could not write WAL shutdown info: " << TRI_errno_string(res);
}
Instance = nullptr;
}
// registers a transaction

2
js/apps/system/_api/gharial/APP/gharial.js
View File

@ -49,7 +49,7 @@ router.use((req, res, next) => {
} catch (e) {
if (e.isArangoError) {
const status = actions.arangoErrorToHttpCode(e.errorNum);
res.throw(status, e.errorMessage, {cause: e});
res.throw(status, e.errorMessage, {errorNum: e.errorNum, cause: e});
}
if (e.statusCode === NOT_MODIFIED) {
res.status(NOT_MODIFIED);

7
js/server/modules/@arangodb/actions.js
View File

@ -1831,8 +1831,8 @@ function indexNotFound (req, res, collection, index, headers) {
}
function arangoErrorToHttpCode(num) {
if (num === 0) {
num = arangodb.ERROR_INTERNAL;
if (!num) {
return exports.HTTP_SERVER_ERROR;
}
switch (num) {
@ -1926,7 +1926,8 @@ function resultException (req, res, err, headers, verbose) {
}
}
code = arangoErrorToHttpCode(err.errorNum);
num = err.errorNum || arangodb.ERROR_INTERNAL;
code = arangoErrorToHttpCode(num);
}
else if (err instanceof TypeError) {
num = arangodb.ERROR_TYPE_ERROR;

1
js/server/modules/@arangodb/foxx/service.js
View File

@ -37,7 +37,6 @@ const parameterTypes = require('@arangodb/foxx/manager-utils').parameterTypes;
const getReadableName = require('@arangodb/foxx/manager-utils').getReadableName;
const Router = require('@arangodb/foxx/router/router');
const Tree = require('@arangodb/foxx/router/tree');
const actions = require('@arangodb/actions');
const $_MODULE_ROOT = Symbol.for('@arangodb/module.root');
const $_MODULE_CONTEXT = Symbol.for('@arangodb/module.context');

21
lib/Basics/VelocyPackHelper.cpp
View File

@ -782,6 +782,27 @@ uint64_t VelocyPackHelper::hashByAttributes(
return hash;
}
void VelocyPackHelper::SanitizeExternals(VPackSlice const input, VPackBuilder& output) {
if (input.isExternal()) {
output.add(input.resolveExternal());
} else if (input.isObject()) {
output.openObject();
for (auto const& it : VPackObjectIterator(input)) {
output.add(VPackValue(it.key.copyString()));
SanitizeExternals(it.value, output);
}
output.close();
} else if (input.isArray()) {
output.openArray();
for (auto const& it : VPackArrayIterator(input)) {
SanitizeExternals(it, output);
}
output.close();
} else {
output.add(input);
}
}
arangodb::LoggerStream& operator<< (arangodb::LoggerStream& logger,
VPackSlice const& slice) {
size_t const cutoff = 100;

3
lib/Basics/VelocyPackHelper.h
View File

@ -284,6 +284,9 @@ class VelocyPackHelper {
static inline arangodb::velocypack::Slice IllegalValue() {
return arangodb::velocypack::Slice::illegalSlice();
}
static void SanitizeExternals(arangodb::velocypack::Slice const,
arangodb::velocypack::Builder&);
};
}
}