/// @brief get the _id attribute from an object/document
AqlValue AqlValue::getIdAttribute(arangodb::AqlTransaction* trx,
bool& mustDestroy, bool doCopy) const {
mustDestroy = false;
switch (type()) {
case VPACK_SLICE_POINTER:
doCopy = false;
case VPACK_INLINE:
// fall-through intentional
case VPACK_MANAGED: {
VPackSlice s(slice());
if (s.isObject()) {
VPackSlice found = Transaction::extractIdFromDocument(s);
if (found.isCustom()) {
// _id as a custom type needs special treatment
mustDestroy = true;
return AqlValue(trx->extractIdString(trx->resolver(), found, s));
}
if (!found.isNone()) {
if (doCopy) {
mustDestroy = true;
return AqlValue(found);
}
// return a reference to an existing slice
return AqlValue(found.begin());
}
}
// fall-through intentional
break;
}
case DOCVEC:
case RANGE: {
// will return null
break;
}
}
// default is to return null
return AqlValue(arangodb::basics::VelocyPackHelper::NullValue());
}
bool TraverserExpression::matchesCheck(arangodb::Transaction* trx,
VPackSlice const& element) const {
TRI_ASSERT(trx != nullptr);
VPackSlice base = arangodb::basics::VelocyPackHelper::EmptyObjectValue();
VPackSlice value = element.resolveExternal();
// initialize compare value to Null
VPackSlice result = arangodb::basics::VelocyPackHelper::NullValue();
// perform recursive check. this may modify value
if (recursiveCheck(varAccess, value, base)) {
result = value;
}
// hack for _id attribute
TransactionBuilderLeaser builder(trx);
if (result.isCustom() && base.isObject()) {
builder->add(VPackValue(trx->extractIdString(base)));
result = builder->slice();
}
TRI_ASSERT(compareTo != nullptr);
VPackOptions* options = trx->transactionContext()->getVPackOptions();
switch (comparisonType) {
case arangodb::aql::NODE_TYPE_OPERATOR_BINARY_EQ:
return arangodb::basics::VelocyPackHelper::compare(result, compareTo->slice(), false, options) == 0;
case arangodb::aql::NODE_TYPE_OPERATOR_BINARY_NE:
return arangodb::basics::VelocyPackHelper::compare(result, compareTo->slice(), false, options) != 0;
case arangodb::aql::NODE_TYPE_OPERATOR_BINARY_LT:
return arangodb::basics::VelocyPackHelper::compare(result, compareTo->slice(), true, options) < 0;
case arangodb::aql::NODE_TYPE_OPERATOR_BINARY_LE:
return arangodb::basics::VelocyPackHelper::compare(result, compareTo->slice(), true, options) <= 0;
case arangodb::aql::NODE_TYPE_OPERATOR_BINARY_GE:
return arangodb::basics::VelocyPackHelper::compare(result, compareTo->slice(), true, options) >= 0;
case arangodb::aql::NODE_TYPE_OPERATOR_BINARY_GT:
return arangodb::basics::VelocyPackHelper::compare(result, compareTo->slice(), true, options) > 0;
case arangodb::aql::NODE_TYPE_OPERATOR_BINARY_IN: {
// In means any of the elements in compareTo is identical
VPackSlice compareArray = compareTo->slice();
for (auto const& cmp : VPackArrayIterator(compareArray)) {
if (arangodb::basics::VelocyPackHelper::compare(result, cmp, false, options) == 0) {
// One is identical
return true;
}
}
// If we get here non is identical
return false;
}
case arangodb::aql::NODE_TYPE_OPERATOR_BINARY_NIN: {
// NIN means none of the elements in compareTo is identical
VPackSlice compareArray = compareTo->slice();
for (auto const& cmp : VPackArrayIterator(compareArray)) {
if (arangodb::basics::VelocyPackHelper::compare(result, cmp, false, options) == 0) {
// One is identical
return false;
}
}
// If we get here non is identical
return true;
}
default:
TRI_ASSERT(false);
}
return false;
}
int VelocyPackHelper::compare(VPackSlice lhs, VPackSlice rhs,
bool useUTF8, VPackOptions const* options,
VPackSlice const* lhsBase, VPackSlice const* rhsBase) {
{
// will resolve externals...
int lWeight = TypeWeight(lhs);
int rWeight = TypeWeight(rhs);
if (lWeight < rWeight) {
return -1;
}
if (lWeight > rWeight) {
return 1;
}
TRI_ASSERT(lWeight == rWeight);
}
lhs = lhs.resolveExternal(); // follow externals
rhs = rhs.resolveExternal(); // follow externals
// lhs and rhs have equal weights
if (lhs.isNone() || rhs.isNone()) {
// either lhs or rhs is none. we cannot be sure here that both are
// nones.
// there can also exist the situation that lhs is a none and rhs is a
// null value
// (or vice versa). Anyway, the compare value is the same for both,
return 0;
}
auto lhsType = lhs.type();
switch (lhsType) {
case VPackValueType::Illegal:
case VPackValueType::MinKey:
case VPackValueType::MaxKey:
case VPackValueType::None:
case VPackValueType::Null:
return 0;
case VPackValueType::Bool: {
bool left = lhs.getBoolean();
bool right = rhs.getBoolean();
if (left == right) {
return 0;
}
if (!left && right) {
return -1;
}
return 1;
}
case VPackValueType::Double:
case VPackValueType::Int:
case VPackValueType::UInt:
case VPackValueType::SmallInt: {
return compareNumberValues(lhsType, lhs, rhs);
}
case VPackValueType::Custom:
case VPackValueType::String: {
std::string lhsString;
VPackValueLength nl;
char const* left;
if (lhs.isCustom()) {
if (lhsBase == nullptr || options == nullptr || options->customTypeHandler == nullptr) {
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_INTERNAL,
"Could not extract custom attribute.");
}
lhsString.assign(options->customTypeHandler->toString(lhs, options, *lhsBase));
left = lhsString.c_str();
nl = lhsString.size();
} else {
left = lhs.getString(nl);
}
TRI_ASSERT(left != nullptr);
std::string rhsString;
VPackValueLength nr;
char const* right;
if (rhs.isCustom()) {
if (rhsBase == nullptr || options == nullptr || options->customTypeHandler == nullptr) {
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_INTERNAL,
"Could not extract custom attribute.");
}
rhsString.assign(options->customTypeHandler->toString(rhs, options, *rhsBase));
right = rhsString.c_str();
nr = rhsString.size();
} else {
right = rhs.getString(nr);
}
TRI_ASSERT(right != nullptr);
int res;
if (useUTF8) {
res = TRI_compare_utf8(left, static_cast<size_t>(nl), right, static_cast<size_t>(nr));
} else {
size_t len = static_cast<size_t>(nl < nr ? nl : nr);
res = memcmp(left, right, len);
}
if (res < 0) {
return -1;
}
if (res > 0) {
return 1;
}
// res == 0
if (nl == nr) {
return 0;
}
// res == 0, but different string lengths
return nl < nr ? -1 : 1;
}
case VPackValueType::Array: {
VPackValueLength const nl = lhs.length();
VPackValueLength const nr = rhs.length();
VPackValueLength const n = (std::max)(nr, nl);
for (VPackValueLength i = 0; i < n; ++i) {
VPackSlice lhsValue;
if (i < nl) {
lhsValue = lhs.at(i).resolveExternal();
}
VPackSlice rhsValue;
if (i < nr) {
rhsValue = rhs.at(i).resolveExternal();
}
int result = compare(lhsValue, rhsValue, useUTF8, options, &lhs, &rhs);
if (result != 0) {
return result;
}
}
return 0;
}
case VPackValueType::Object: {
std::set<std::string, AttributeSorterUTF8> keys;
VPackCollection::keys(lhs, keys);
VPackCollection::keys(rhs, keys);
for (auto const& key : keys) {
VPackSlice lhsValue = lhs.get(key).resolveExternal();
if (lhsValue.isNone()) {
// not present => null
lhsValue = VPackSlice::nullSlice();
}
VPackSlice rhsValue = rhs.get(key).resolveExternal();
if (rhsValue.isNone()) {
// not present => null
rhsValue = VPackSlice::nullSlice();
}
int result = compare(lhsValue, rhsValue, useUTF8, options, &lhs, &rhs);
if (result != 0) {
return result;
}
}
return 0;
}
default:
// Contains all other ValueTypes of VelocyPack.
// They are not used in ArangoDB so this cannot occur
TRI_ASSERT(false);
return 0;
}
}
