Added support for nested fields - excluding expansions. (#13681)

* Added support for nested fields - excluding expansions. * Added tests for nested attributes.
arangodb · mchacki · Sep 10, 2021 · Mar 3, 2021 · Mar 4, 2021 · Mar 4, 2021
commit 3d1ce4b25db3b31d6408f01f80ac6224e6ec9210
diff --git a/arangod/Indexes/IndexFactory.cpp b/arangod/Indexes/IndexFactory.cpp
@@ -204,7 +204,7 @@ Result IndexFactory::emplace(std::string const& type, IndexTypeFactory const& fa
   return arangodb::Result();
 }
 
-Result IndexFactory::enhanceIndexDefinition(  // normalizze deefinition
+Result IndexFactory::enhanceIndexDefinition(  // normalize definition
     velocypack::Slice const definition,       // source definition
     velocypack::Builder& normalized,  // normalized definition (out-param)
     bool isCreation,                  // definition for index creation

diff --git a/arangod/RocksDBEngine/RocksDBZkdIndex.cpp b/arangod/RocksDBEngine/RocksDBZkdIndex.cpp
@@ -167,20 +167,31 @@ auto nodeExtractDouble(aql::AstNode const* node) -> std::optional<zkd::byte_stri
   return std::nullopt;
 }
 
+auto accessDocumentPath(VPackSlice doc, std::vector<basics::AttributeName> const& path) -> VPackSlice {
+  for (auto&& attrib : path) {
+    TRI_ASSERT(attrib.shouldExpand == false);
+    if (!doc.isObject()) {
+      return VPackSlice::noneSlice();
+    }
+
+    doc = doc.get(attrib.name);
+  }
+
+  return doc;
+}
+
 auto readDocumentKey(VPackSlice doc,
                      std::vector<std::vector<basics::AttributeName>> const& fields)
     -> zkd::byte_string {
   std::vector<zkd::byte_string> v;
   v.reserve(fields.size());
 
   for (auto const& path : fields) {
-    TRI_ASSERT(path.size() == 1);
-    TRI_ASSERT(path[0].shouldExpand == false);
-    VPackSlice value = doc.get(path[0].name);
+    VPackSlice value = accessDocumentPath(doc, path);
     if (!value.isNumber<double>()) {
       THROW_ARANGO_EXCEPTION(TRI_ERROR_QUERY_INVALID_ARITHMETIC_VALUE);
     }
-    double dv = value.getNumericValue<double>();
+    auto dv = value.getNumericValue<double>();
     if (std::isnan(dv)) {
       THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, "NaN is not allowed");
     }
@@ -238,39 +249,30 @@ void zkd::extractBoundsFromCondition(
       return false;
     }
 
-    auto& path = attributeData.second;
-    // TODO -- make this more generic
-    TRI_ASSERT(path.size() == 1 && !path[0].shouldExpand);
-
-    auto& name = path[0].name;
     for (auto&& [idx, field] : enumerate(index->fields())) {
-      TRI_ASSERT(field.size() == 1);
-
-      if (name != field[0].name) {
+      if (attributeData.second != field) {
         continue;
       }
 
-      if (name == field[0].name) {
-        switch (op->type) {
-          case arangodb::aql::NODE_TYPE_OPERATOR_BINARY_EQ:
-            useAsBound(idx, op, access, other, true, false);
-            useAsB
8000
ound(idx, op, access, other, false, false);
-            return true;
-          case arangodb::aql::NODE_TYPE_OPERATOR_BINARY_LE:
-            useAsBound(idx, op, access, other, reverse, false);
-            return true;
-          case arangodb::aql::NODE_TYPE_OPERATOR_BINARY_GE:
-            useAsBound(idx, op, access, other, !reverse, false);
-            return true;
-          case arangodb::aql::NODE_TYPE_OPERATOR_BINARY_LT:
-            useAsBound(idx, op, access, other, reverse, true);
-            return true;
-          case arangodb::aql::NODE_TYPE_OPERATOR_BINARY_GT:
-            useAsBound(idx, op, access, other, !reverse, true);
-            return true;
-          default:
-            break;
-        }
+      switch (op->type) {
+        case arangodb::aql::NODE_TYPE_OPERATOR_BINARY_EQ:
+          useAsBound(idx, op, access, other, true, false);
+          useAsBound(idx, op, access, other, false, false);
+          return true;
+        case arangodb::aql::NODE_TYPE_OPERATOR_BINARY_LE:
+          useAsBound(idx, op, access, other, reverse, false);
+          return true;
+        case arangodb::aql::NODE_TYPE_OPERATOR_BINARY_GE:
+          useAsBound(idx, op, access, other, !reverse, false);
+          return true;
+        case arangodb::aql::NODE_TYPE_OPERATOR_BINARY_LT:
+          useAsBound(idx, op, access, other, reverse, true);
+          return true;
+        case arangodb::aql::NODE_TYPE_OPERATOR_BINARY_GT:
+          useAsBound(idx, op, access, other, !reverse, true);
+          return true;
+        default:
+          break;
       }
     }
 

diff --git a/tests/Zkd/Conversion.cpp b/tests/Zkd/Conversion.cpp
@@ -72,16 +72,6 @@ TEST(Zkd_byte_string_conversion, int64_compare) {
   }
 }
 
-TEST(Zkd_byte_string_conversion, double_float) {
-  auto tests = {std::pair{0.0, byte_string{0b10111111_b, 0b11110000_b, 0_b, 0_b,
-                                           0_b, 0_b, 0_b, 0_b}}};
-
-  for (auto&& [v, bs] : tests) {
-    auto result = to_byte_string_fixed_length(v);
-    EXPECT_EQ(result, bs);
-  }
-}
-
 auto const doubles_worth_testing = {0.0,
                                     0.1,
                                     0.2,

diff --git a/tests/js/server/aql/aql-optimizer-zkdindex-multi.js b/tests/js/server/aql/aql-optimizer-zkdindex-multi.js
@@ -100,13 +100,13 @@ function optimizerRuleZkd2dIndexTestSuite() {
     let testObject = {
         setUpAll: function () {
             col = db._create(colName);
-            col.ensureIndex({type: 'zkd', name: 'zkdIndex', fields: ['x', 'y', 'z', 'w']});
+            col.ensureIndex({type: 'zkd', name: 'zkdIndex', fields: ['x', 'y', 'z', 'a.w']});
             db._query(aql`
                 FOR x IN 0..10
                 FOR y IN 0..10
                 FOR z IN 0..10
                 FOR w IN 0..10
-                  INSERT {x, y, z, w} INTO ${col}
+                  INSERT {x, y, z, a: {w}} INTO ${col}
               `);
         },
 
@@ -131,8 +131,8 @@ function optimizerRuleZkd2dIndexTestSuite() {
                               FILTER ${conditionForVariable(x, "d.x")}
                               FILTER ${conditionForVariable(y, "d.y")}
                               FILTER ${conditionForVariable(z, "d.z")}
-                              FILTER ${conditionForVariable(w, "d.w")}
-                              RETURN [d.x, d.y, d.z, d.w]
+                              FILTER ${conditionForVariable(w, "d.a.w")}
+                              RETURN [d.x, d.y, d.z, d.a.w]
                           `;
                         const explainRes = AQL_EXPLAIN(query);
                         const appliedRules = explainRes.plan.rules;