bugfixes

arangod/Aql/Expression.cpp

@@ -139,10 +139,10 @@ void Expression::variables(std::unordered_set<Variable const*>& result) const {
 ////////////////////////////////////////////////////////////////////////////////
 
 AqlValue Expression::execute(arangodb::AqlTransaction* trx,
-                              AqlItemBlock const* argv, size_t startPos,
-                              std::vector<Variable const*> const& vars,
-                              std::vector<RegisterId> const& regs,
-                              bool& mustDestroy) {
+                             AqlItemBlock const* argv, size_t startPos,
+                             std::vector<Variable const*> const& vars,
+                             std::vector<RegisterId> const& regs,
+                             bool& mustDestroy) {
   if (!_built) {
     buildExpression();
   }
@@ -153,7 +153,7 @@ AqlValue Expression::execute(arangodb::AqlTransaction* trx,
   // and execute
   switch (_type) {
     case JSON: {
-      // TODO
+      mustDestroy = false;
       TRI_ASSERT(_data != nullptr);
       return AqlValue(_data);
     }
@@ -445,7 +445,7 @@ AqlValue Expression::executeSimpleExpression(
       return executeSimpleExpressionValue(node, mustDestroy);
     case NODE_TYPE_REFERENCE:
       return executeSimpleExpressionReference(node, trx, argv, startPos,
-                                              vars, regs, doCopy, mustDestroy);
+                                              vars, regs, mustDestroy, doCopy);
     case NODE_TYPE_FCALL:
       return executeSimpleExpressionFCall(node, trx, argv, startPos, vars,
                                           regs, mustDestroy);
@@ -454,6 +454,7 @@ AqlValue Expression::executeSimpleExpression(
                                           regs, mustDestroy);
     case NODE_TYPE_OPERATOR_UNARY_NOT:
       return executeSimpleExpressionNot(node, trx, argv, startPos, vars, regs, mustDestroy);
+
     case NODE_TYPE_OPERATOR_BINARY_AND:
     case NODE_TYPE_OPERATOR_BINARY_OR:
       return executeSimpleExpressionAndOr(node, trx, argv, startPos, vars,
@@ -562,7 +563,6 @@ AqlValue Expression::executeSimpleExpressionAttributeAccess(
 
   AqlValue result = executeSimpleExpression(member, trx, argv,
                                             startPos, vars, regs, mustDestroy, false);
-
   AqlValueGuard guard(result, mustDestroy);
 
   AqlValue a = result.get(trx, name, mustDestroy, true);
@@ -596,7 +596,7 @@ AqlValue Expression::executeSimpleExpressionIndexedAccess(
 
   mustDestroy = false; 
   AqlValue result = executeSimpleExpression(member, trx, argv,
-                                             startPos, vars, regs, mustDestroy, false);
+                                            startPos, vars, regs, mustDestroy, false);
 
   AqlValueGuard guard(result, mustDestroy);
 

arangod/Aql/V8Expression.cpp

@@ -63,11 +63,11 @@ V8Expression::~V8Expression() {
 ////////////////////////////////////////////////////////////////////////////////
 
 AqlValue V8Expression::execute(v8::Isolate* isolate, Query* query,
-                                arangodb::AqlTransaction* trx,
-                                AqlItemBlock const* argv, size_t startPos,
-                                std::vector<Variable const*> const& vars,
-                                std::vector<RegisterId> const& regs,
-                                bool& mustDestroy) {
+                               arangodb::AqlTransaction* trx,
+                               AqlItemBlock const* argv, size_t startPos,
+                               std::vector<Variable const*> const& vars,
+                               std::vector<RegisterId> const& regs,
+                               bool& mustDestroy) {
   size_t const n = vars.size();
   TRI_ASSERT(regs.size() == n);  // assert same vector length
 

arangod/V8Server/v8-query.cpp

@@ -120,17 +120,39 @@ static void EdgesQuery(TRI_edge_direction_e direction,
 
   TRI_THROW_SHARDING_COLLECTION_NOT_YET_IMPLEMENTED(collection);
   
+  auto addOne = [](v8::Isolate* isolate, VPackBuilder* builder, v8::Handle<v8::Value> const val) {
+    if (val->IsString() || val->IsStringObject()) {
+      builder->add(VPackValue(TRI_ObjectToString(val)));
+    } else if (val->IsObject()) {
+      v8::Handle<v8::Object> obj = val->ToObject();
+      if (obj->Has(TRI_V8_ASCII_STRING(TRI_VOC_ATTRIBUTE_ID))) {
+        builder->add(VPackValue(TRI_ObjectToString(obj->Get(TRI_V8_ASCII_STRING(TRI_VOC_ATTRIBUTE_ID)))));
+      } else {
+        THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, "object does not have _id attribute"); 
+      }
+    } else {
+      THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, "invalid value type. expecting string or object value");
+    }
+  };
+  
   auto bindVars = std::make_shared<VPackBuilder>();
   bindVars->openObject();
   bindVars->add("@collection", VPackValue(collection->name()));
   bindVars->add(VPackValue("value"));
-  int res = TRI_V8ToVPack(isolate, *(bindVars.get()), args[0], false);
-  bindVars->close();
 
-  if (res != TRI_ERROR_NO_ERROR) {
-    TRI_V8_THROW_EXCEPTION(res);
+  if (args[0]->IsArray()) {
+    bindVars->openArray();
+    v8::Handle<v8::Array> arr = v8::Handle<v8::Array>::Cast(args[0]);
+    uint32_t n = arr->Length();
+    for (uint32_t i = 0; i < n; ++i) {
+      addOne(isolate, bindVars.get(), arr->Get(i));
+    }
+    bindVars->close();
   }
-
+  else {
+    addOne(isolate, bindVars.get(), args[0]);
+  }
+  bindVars->close();
 
   std::string filter;
   // argument is a list of vertices

arangod/VocBase/DatafileHelper.h

@@ -259,8 +259,6 @@ static inline void InitMarker(TRI_df_marker_t* marker,
   TRI_ASSERT(type > TRI_DF_MARKER_MIN && type < TRI_DF_MARKER_MAX);
   TRI_ASSERT(size > 0);
 
-  // memset the last 8 bytes of the marker, as they might be uninitialized otherwise
-  memset(reinterpret_cast<char*>(marker) + DatafileHelper::AlignedSize(size) - 8, 0, 8); 
   marker->setSize(size);
   marker->setType(type);
   marker->setCrc(0);