arangodb · KVS85 · Nov 12, 2019 · Nov 5, 2019 · Nov 6, 2019 · Nov 6, 2019
diff --git a/arangod/Aql/QueryString.h b/arangod/Aql/QueryString.h
@@ -55,6 +55,7 @@ class QueryString {
   ~QueryString() = default;
 
  public:
+  std::string const& string() const noexcept { return _queryString; }
   char const* data() const { return _queryString.data(); }
   size_t size() const { return _queryString.size(); }
   size_t length() const { return _queryString.size(); }

diff --git a/arangod/IResearch/IResearchAnalyzerFeature.cpp b/arangod/IResearch/IResearchAnalyzerFeature.cpp
diff --git a/arangod/IResearch/IResearchAnalyzerFeature.h b/arangod/IResearch/IResearchAnalyzerFeature.h
diff --git a/arangod/IResearch/IResearchDocument.cpp b/arangod/IResearch/IResearchDocument.cpp
@@ -158,8 +158,9 @@ inline bool keyFromSlice(VPackSlice keySlice, irs::string_ref& key) {
   }
 }
 
-inline bool canHandleValue(std::string const& key, VPackSlice const& value,
-                           arangodb::iresearch::IResearchLinkMeta const& context) noexcept {
+inline bool canHandleValue(std::string const& key,
+                           VPackSlice const& value,
+                           arangodb::iresearch::FieldMeta const& context) noexcept {
   switch (value.type()) {
     case VPackValueType::None:
     case VPackValueType::Illegal:
@@ -190,16 +191,17 @@ inline bool canHandleValue(std::string const& key, VPackSlice const& value,
 }
 
 // returns 'context' in case if can't find the specified 'field'
-inline arangodb::iresearch::IResearchLinkMeta const* findMeta(
-    irs::string_ref const& key, arangodb::iresearch::IResearchLinkMeta const* context) {
+inline arangodb::iresearch::FieldMeta const* findMeta(
+    irs::string_ref const& key,
+    arangodb::iresearch::FieldMeta const* context) {
   TRI_ASSERT(context);
 
   auto const* meta = context->_fields.findPtr(key);
   return meta ? meta->get() : context;
 }
 
 inline bool inObjectFiltered(std::string& buffer,
-                             arangodb::iresearch::IResearchLinkMeta const*& context,
+                             arangodb::iresearch::FieldMeta const*& context,
                              arangodb::iresearch::IteratorValue const& value) {
   irs::string_ref key;
 
@@ -220,7 +222,7 @@ inline bool inObjectFiltered(std::string& buffer,
 }
 
 inline bool inObject(std::string& buffer,
-                     arangodb::iresearch::IResearchLinkMeta const*& context,
+                     arangodb::iresearch::FieldMeta const*& context,
                      arangodb::iresearch::IteratorValue const& value) {
   irs::string_ref key;
 
@@ -235,7 +237,7 @@ inline bool inObject(std::string& buffer,
 }
 
 inline bool inArrayOrdered(std::string& buffer,
-                           arangodb::iresearch::IResearchLinkMeta const*& context,
+                           arangodb::iresearch::FieldMeta const*& context,
                            arangodb::iresearch::IteratorValue const& value) {
   buffer += arangodb::iresearch::NESTING_LIST_OFFSET_PREFIX;
   append(buffer, value.pos);
@@ -245,36 +247,36 @@ inline bool inArrayOrdered(std::string& buffer,
 }
 
 inline bool inArray(std::string& buffer,
-                    arangodb::iresearch::IResearchLinkMeta const*& context,
+                    arangodb::iresearch::FieldMeta const*& context,
                     arangodb::iresearch::IteratorValue const& value) noexcept {
   return canHandleValue(buffer, value.value, *context);
 }
 
 typedef bool (*Filter)(std::string& buffer,
-                       arangodb::iresearch::IResearchLinkMeta const*& context,
+                       arangodb::iresearch::FieldMeta const*& context,
                        arangodb::iresearch::IteratorValue const& value);
 
 Filter const valueAcceptors[] = {
-    &inObjectFiltered,  // type == Object, nestListValues == false,
-                        // includeAllValues == false
-    &inObject,  // type == Object, nestListValues == false, includeAllValues ==
-                // true
-    &inObjectFiltered,  // type == Object, nestListValues == true ,
-                        // includeAllValues == false
-    &inObject,  // type == Object, nestListValues == true , includeAllValues ==
-                // true
-    &inArray,   // type == Array , nestListValues == flase, includeAllValues ==
-                // false
-    &inArray,   // type == Array , nestListValues == flase, includeAllValues ==
-                // true
-    &inArrayOrdered,  // type == Array , nestListValues == true,
-                      // includeAllValues == false
-    &inArrayOrdered  // type == Array , nestListValues == true, includeAllValues
-                     // == true
+  // type == Object, nestListValues == false, // includeAllValues == false
+  &inObjectFiltered,
+  // type == Object, nestListValues == false, includeAllValues == // true
+  &inObject,
+  // type == Object, nestListValues == true , // includeAllValues == false
+  &inObjectFiltered,
+  // type == Object, nestListValues == true , includeAllValues == // true
+  &inObject,
+  // type == Array , nestListValues == flase, includeAllValues == // false
+  &inArray,
+  // type == Array , nestListValues == flase, includeAllValues == // true
+  &inArray,
+  // type == Array , nestListValues == true, // includeAllValues == false
+  &inArrayOrdered,
+  // type == Array , nestListValues == true, includeAllValues // == true
+  &inArrayOrdered
 };
 
 inline Filter getFilter(VPackSlice value,
-                        arangodb::iresearch::IResearchLinkMeta const& meta) noexcept {
+                        arangodb::iresearch::FieldMeta const& meta) noexcept {
   TRI_ASSERT(arangodb::iresearch::isArrayOrObject(value));
 
   return valueAcceptors[4 * value.isArray() + 2 * meta._trackListPositions + meta._includeAllFields];
@@ -292,7 +294,7 @@ namespace iresearch {
 /*static*/ void Field::setPkValue(Field& field, LocalDocumentId::BaseType const& pk) {
   field._name = PK_COLUMN;
   field._features = &irs::flags::empty_instance();
-  field._storeValues = ValueStorage::FULL;
+  field._storeValues = ValueStorage::VALUE;
   field._value =
       irs::bytes_ref(reinterpret_cast<irs::byte_type const*>(&pk), sizeof(pk));
   field._analyzer = StringStreamPool.emplace().release();  // FIXME don't use shared_ptr
@@ -342,7 +344,7 @@ std::string& FieldIterator::valueBuffer() {
   return *_valueBuffer;
 }
 
-void FieldIterator::reset(VPackSlice const& doc, IResearchLinkMeta const& linkMeta) {
+void FieldIterator::reset(VPackSlice const& doc, FieldMeta const& linkMeta) {
   // set surrogate analyzers
   _begin = nullptr;
   _end = 1 + _begin;
@@ -419,13 +421,11 @@ void FieldIterator::setNullValue(VPackSlice const value) {
 }
 
 bool FieldIterator::setStringValue(
-    arangodb::velocypack::Slice const value, // value
-    IResearchLinkMeta::Analyzer const& valueAnalyzer // analyzer to use
-) {
+    arangodb::velocypack::Slice const value,
+    FieldMeta::Analyzer const& valueAnalyzer) {
   TRI_ASSERT( // assert
     (value.isCustom() && nameBuffer() == arangodb::StaticStrings::IdString) // custom string
-    || value.isString() // verbatim string
-  );
+    || value.isString()); // verbatim string
 
   irs::string_ref valueRef;
 
@@ -483,7 +483,7 @@ bool FieldIterator::setStringValue(
   return true;
 }
 
-bool FieldIterator::pushAndSetValue(VPackSlice slice, IResearchLinkMeta const*& context) {
+bool FieldIterator::pushAndSetValue(VPackSlice slice, FieldMeta const*& context) {
   auto& name = nameBuffer();
 
   while (isArrayOrObject(slice)) {
@@ -522,7 +522,7 @@ bool FieldIterator::pushAndSetValue(VPackSlice slice, IResearchLinkMeta const*&
   return setAttributeValue(*context);
 }
 
-bool FieldIterator::setAttributeValue(IResearchLinkMeta const& context) {
+bool FieldIterator::setAttributeValue(FieldMeta const& context) {
   auto const value = topValue().value;
 
   _value._storeValues = context._storeValues;
@@ -580,7 +580,7 @@ void FieldIterator::next() {
     }
   }
 
-  IResearchLinkMeta const* context;
+  FieldMeta const* context;
 
   auto& name = nameBuffer();
 
@@ -651,4 +651,4 @@ void FieldIterator::next() {
 
 // -----------------------------------------------------------------------------
 // --SECTION--                                                       END-OF-FILE
-// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
diff --git a/arangod/IResearch/IResearchDocument.h b/arangod/IResearch/IResearchDocument.h
@@ -141,35 +141,33 @@ class FieldIterator : public std::iterator<std::forward_iterator_tag, Field cons
   bool valid() const noexcept { return !_stack.empty(); }
 
   bool operator==(FieldIterator const& rhs) const noexcept {
-    TRI_ASSERT(_trx == rhs._trx);  // compatibility
+    TRI_ASSERT(_trx == rhs._trx); // compatibility
     return _stack == rhs._stack;
   }
 
   bool operator!=(FieldIterator const& rhs) const noexcept {
     return !(*this == rhs);
   }
 
-  void reset( // reset
-    arangodb::velocypack::Slice const& doc, // doc
-    IResearchLinkMeta const& linkMeta // link meta
-  );
+  void reset(velocypack::Slice const& doc,
+             FieldMeta const& linkMeta);
 
  private:
-  typedef IResearchLinkMeta::Analyzer const* AnalyzerIterator;
+  typedef FieldMeta::Analyzer const* AnalyzerIterator;
 
   typedef bool(*Filter)( // filter
     std::string& buffer,  // buffer
-    IResearchLinkMeta const*& rootMeta, // root link meta
+    FieldMeta const*& rootMeta, // root link meta
     IteratorValue const& value // value
   );
 
   struct Level {
-    Level( // constructor
-        arangodb::velocypack::Slice slice, // slice
-        size_t nameLength, // name length
-        IResearchLinkMeta const& meta, // link meta
-        Filter filter // filter
-    ): it(slice), nameLength(nameLength), meta(&meta), filter(filter) {
+    Level(velocypack::Slice slice,
+          size_t nameLength,
+          FieldMeta const& meta,
+          Filter filter)
+      : it(slice), nameLength(nameLength),
+        meta(&meta), filter(filter) {
     }
 
     bool operator==(Level const& rhs) const noexcept { return it == rhs.it; }
@@ -178,7 +176,7 @@ class FieldIterator : public std::iterator<std::forward_iterator_tag, Field cons
 
     Iterator it;
     size_t nameLength;              // length of the name at the current level
-    IResearchLinkMeta const* meta;  // metadata
+    FieldMeta const* meta;  // metadata
     Filter filter;
   };  // Level
 
@@ -201,17 +199,17 @@ class FieldIterator : public std::iterator<std::forward_iterator_tag, Field cons
   FieldIterator& operator=(FieldIterator const&) = delete;
 
   void next();
-  bool pushAndSetValue(arangodb::velocypack::Slice slice, IResearchLinkMeta const*& topMeta);
-  bool setAttributeValue(IResearchLinkMeta const& context);
+  bool pushAndSetValue(arangodb::velocypack::Slice slice, FieldMeta const*& topMeta);
+  bool setAttributeValue(FieldMeta const& context);
   bool setStringValue( // set value
     arangodb::velocypack::Slice const value, // value
-    IResearchLinkMeta::Analyzer const& valueAnalyzer // analyzer to use
+    FieldMeta::Analyzer const& valueAnalyzer // analyzer to use
   );
   void setNullValue(VPackSlice const value);
   void setNumericValue(VPackSlice const value);
   void setBoolValue(VPackSlice const value);
 
-  void resetAnalyzers(IResearchLinkMeta const& context) noexcept {
+  void resetAnalyzers(FieldMeta const& context) noexcept {
     auto const& analyzers = context._analyzers;
 
     _begin = analyzers.data();
@@ -253,4 +251,4 @@ struct DocumentPrimaryKey {
 }  // namespace iresearch
 }  // namespace arangodb
 
-#endif
+#endif
diff --git a/arangod/IResearch/IResearchFilterFactory.cpp b/arangod/IResearch/IResearchFilterFactory.cpp
@@ -62,7 +62,7 @@ namespace {
 
 struct FilterContext {
   FilterContext( // constructor
-      arangodb::iresearch::IResearchLinkMeta::Analyzer const& analyzer, // analyzer
+      arangodb::iresearch::FieldMeta::Analyzer const& analyzer, // analyzer
                 irs::boost_t boost) noexcept
       : analyzer(analyzer), boost(boost) {
     TRI_ASSERT(analyzer._pool);
@@ -72,7 +72,7 @@ struct FilterContext {
   FilterContext& operator=(FilterContext const&) = delete;
 
   // need shared_ptr since pool could be deleted from the feature
-  arangodb::iresearch::IResearchLinkMeta::Analyzer const& analyzer;
+  arangodb::iresearch::FieldMeta::Analyzer const& analyzer;
   irs::boost_t boost;
 };  // FilterContext
 
@@ -141,10 +141,10 @@ FORCE_INLINE void appendExpression(irs::boolean_filter& filter,
   exprFilter.boost(filterCtx.boost);
 }
 
-arangodb::iresearch::IResearchLinkMeta::Analyzer extractAnalyzerFromArg(
+arangodb::iresearch::FieldMeta::Analyzer extractAnalyzerFromArg(
     irs::boolean_filter const* filter, arangodb::aql::AstNode const* analyzerArg,
     QueryContext const& ctx, size_t argIdx, irs::string_ref const& functionName) {
-  static const arangodb::iresearch::IResearchLinkMeta::Analyzer invalid( // invalid analyzer
+  static const arangodb::iresearch::FieldMeta::Analyzer invalid( // invalid analyzer
     nullptr, ""
   );
 
@@ -170,7 +170,7 @@ arangodb::iresearch::IResearchLinkMeta::Analyzer extractAnalyzerFromArg(
   ScopedAqlValue analyzerValue(*analyzerArg);
 
   if (!filter && !analyzerValue.isConstant()) {
-    return arangodb::iresearch::IResearchLinkMeta::Analyzer();
+    return arangodb::iresearch::FieldMeta::Analyzer();
   }
 
   if (!analyzerValue.execute(ctx)) {
@@ -196,7 +196,7 @@ arangodb::iresearch::IResearchLinkMeta::Analyzer extractAnalyzerFromArg(
     return invalid;
   }
 
-  arangodb::iresearch::IResearchLinkMeta::Analyzer result(nullptr, analyzerId);
+  arangodb::iresearch::FieldMeta::Analyzer result(nullptr, analyzerId);
   auto& analyzer = result._pool;
   auto& shortName = result._shortName;
 
@@ -1134,7 +1134,7 @@ arangodb::Result fromFuncAnalyzer(irs::boolean_filter* filter, QueryContext cons
   }
 
   ScopedAqlValue analyzerId(*analyzerArg);
-  arangodb::iresearch::IResearchLinkMeta::Analyzer analyzerValue; // default analyzer
+  arangodb::iresearch::FieldMeta::Analyzer analyzerValue; // default analyzer
   auto& analyzer = analyzerValue._pool;
   auto& shortName = analyzerValue._shortName;
 
@@ -1349,44 +1349,44 @@ arangodb::Result fromFuncExists(irs::boolean_filter* filter, QueryContext const&
       arangodb::basics::StringUtils::tolowerInPlace(&strArg);  // normalize user input
       irs::string_ref const TypeAnalyzer("analyzer");
 
-      typedef bool (*TypeHandler)(std::string&, arangodb::iresearch::IResearchLinkMeta::Analyzer const&);
+      typedef bool (*TypeHandler)(std::string&, arangodb::iresearch::FieldMeta::Analyzer const&);
 
       static std::map<irs::string_ref, TypeHandler> const TypeHandlers{
           // any string
           {irs::string_ref("string"),
-           [](std::string& name, arangodb::iresearch::IResearchLinkMeta::Analyzer const&)->bool {
+           [](std::string& name, arangodb::iresearch::FieldMeta::Analyzer const&)->bool {
              kludge::mangleAnalyzer(name);
              return true;  // a prefix match
            }},
           // any non-string type
           {irs::string_ref("type"),
-           [](std::string& name, arangodb::iresearch::IResearchLinkMeta::Analyzer const&)->bool {
+           [](std::string& name, arangodb::iresearch::FieldMeta::Analyzer const&)->bool {
              kludge::mangleType(name);
              return true;  // a prefix match
            }},
           // concrete analyzer from the context
           {TypeAnalyzer,
-           [](std::string& name, arangodb::iresearch::IResearchLinkMeta::Analyzer const& analyzer)->bool {
+           [](std::string& name, arangodb::iresearch::FieldMeta::Analyzer const& analyzer)->bool {
              kludge::mangleStringField(name, analyzer);
              return false;  // not a prefix match
            }},
           {irs::string_ref("numeric"),
-           [](std::string& name, arangodb::iresearch::IResearchLinkMeta::Analyzer const&)->bool {
+           [](std::string& name, arangodb::iresearch::FieldMeta::Analyzer const&)->bool {
              kludge::mangleNumeric(name);
              return false;  // not a prefix match
            }},
           {irs::string_ref("bool"),
-           [](std::string& name, arangodb::iresearch::IResearchLinkMeta::Analyzer const&)->bool {
+           [](std::string& name, arangodb::iresearch::FieldMeta::Analyzer const&)->bool {
              kludge::mangleBool(name);
              return false;  // not a prefix match
            }},
           {irs::string_ref("boolean"),
-           [](std::string& name, arangodb::iresearch::IResearchLinkMeta::Analyzer const&)->bool {
+           [](std::string& name, arangodb::iresearch::FieldMeta::Analyzer const&)->bool {
              kludge::mangleBool(name);
              return false;  // not a prefix match
            }},
           {irs::string_ref("null"),
-           [](std::string& name, arangodb::iresearch::IResearchLinkMeta::Analyzer const&)->bool {
+           [](std::string& name, arangodb::iresearch::FieldMeta::Analyzer const&)->bool {
              kludge::mangleNull(name);
              return false;  // not a prefix match
            }}};
@@ -2082,7 +2082,7 @@ namespace iresearch {
                                       arangodb::aql::AstNode const& node) {
   // The analyzer is referenced in the FilterContext and used during the
   // following ::filter() call, so may not be a temporary.
-  IResearchLinkMeta::Analyzer analyzer = IResearchLinkMeta::Analyzer();
+  FieldMeta::Analyzer analyzer = FieldMeta::Analyzer();
   FilterContext const filterCtx(analyzer, irs::no_boost());
 
   return ::filter(filter, ctx, filterCtx, node);