clang-format

arangodb · Dronplane · Feb 17, 2023 · Jan 24, 2023 · Jan 27, 2023 · Feb 6, 2023
commit b38c3e8d30213d0f144d7cffbc593f94f13cd6db
diff --git a/arangod/Aql/DocumentProducingHelper.cpp b/arangod/Aql/DocumentProducingHelper.cpp
@@ -347,7 +347,6 @@ RegisterId DocumentProducingFunctionContext::getOutputRegister()
   return _outputRegister;
 }
 
-
 ReadOwnWrites DocumentProducingFunctionContext::getReadOwnWrites()
     const noexcept {
   return _readOwnWrites;

diff --git a/arangod/Aql/ExecutionNode.cpp b/arangod/Aql/ExecutionNode.cpp
@@ -2932,9 +2932,8 @@ std::unique_ptr<ExecutionBlock> MaterializeMultiNode::createBlock(
   auto registerInfos = createRegisterInfos(std::move(readableInputRegisters),
                                            std::move(writableOutputRegisters));
 
-  auto executorInfos =
-      MaterializerExecutorInfos<void>(inNmDocIdRegId,
-                                      outDocumentRegId, engine.getQuery());
+  auto executorInfos = MaterializerExecutorInfos<void>(
+      inNmDocIdRegId, outDocumentRegId, engine.getQuery());
 
   return std::make_unique<ExecutionBlockImpl<MaterializeExecutor<void, false>>>(
       &engine, this, std::move(registerInfos), std::move(executorInfos));
@@ -2960,11 +2959,9 @@ ExecutionNode* MaterializeMultiNode::clone(ExecutionPlan* plan,
 }
 
 template<bool localDocumentId>
-MaterializeSingleNode<localDocumentId>::MaterializeSingleNode(ExecutionPlan* plan,
-                                             ExecutionNodeId id,
-                                             aql::Collection const* collection,
-                                             aql::Variable const& inDocId,
-                                             aql::Variable const& outVariable)
+MaterializeSingleNode<localDocumentId>::MaterializeSingleNode(
+    ExecutionPlan* plan, ExecutionNodeId id, aql::Collection const* collection,
+    aql::Variable const& inDocId, aql::Variable const& outVariable)
     : MaterializeNode(plan, id, inDocId, outVariable),
       CollectionAccessingNode(collection) {}
 
@@ -2974,8 +2971,8 @@ MaterializeSingleNode<localDocumentId>::MaterializeSingleNode(
     : MaterializeNode(plan, base), CollectionAccessingNode(plan, base) {}
 
 template<bool localDocumentId>
-void MaterializeSingleNode<localDocumentId>::doToVelocyPack(velocypack::Builder& nodes,
-                                           unsigned flags) const {
+void MaterializeSingleNode<localDocumentId>::doToVelocyPack(
+    velocypack::Builder& nodes, unsigned flags) const {
   // call base class method
   MaterializeNode::doToVelocyPack(nodes, flags);
 
@@ -2985,7 +2982,8 @@ void MaterializeSingleNode<localDocumentId>::doToVelocyPack(velocypack::Builder&
 }
 
 template<bool localDocumentId>
-std::unique_ptr<ExecutionBlock> MaterializeSingleNode<localDocumentId>::createBlock(
+std::unique_ptr<ExecutionBlock>
+MaterializeSingleNode<localDocumentId>::createBlock(
     ExecutionEngine& engine,
     std::unordered_map<ExecutionNode*, ExecutionBlock*> const&) const {
   ExecutionNode const* previousNode = getFirstDependency();
@@ -2998,7 +2996,7 @@ std::unique_ptr<ExecutionBlock> MaterializeSingleNode<localDocumentId>::createBl
   }
   auto const& name = collection()->name();
   RegisterId inNmDocIdRegId;
-  { 
+  {
     auto it = getRegisterPlan()->varInfo.find(_inNonMaterializedDocId->id);
     TRI_ASSERT(it != getRegisterPlan()->varInfo.end());
     inNmDocIdRegId = it->second.registerId;
@@ -3013,17 +3011,15 @@ std::unique_ptr<ExecutionBlock> MaterializeSingleNode<localDocumentId>::createBl
                                            std::move(writableOutputRegisters));
 
   auto executorInfos = MaterializerExecutorInfos<decltype(name)>(
-      inNmDocIdRegId, outDocumentRegId, engine.getQuery(),
-      name);
+      inNmDocIdRegId, outDocumentRegId, engine.getQuery(), name);
   return std::make_unique<
       ExecutionBlockImpl<MaterializeExecutor<decltype(name), localDocumentId>>>(
       &engine, this, std::move(registerInfos), std::move(executorInfos));
 }
 
 template<bool localDocumentId>
-ExecutionNode* MaterializeSingleNode<localDocumentId>::clone(ExecutionPlan* plan,
-                                            bool withDependencies,
-                                            bool withProperties) const {
+ExecutionNode* MaterializeSingleNode<localDocumentId>::clone(
+    ExecutionPlan* plan, bool withDependencies, bool withProperties) const {
   TRI_ASSERT(plan);
 
   auto* outVariable = _outVariable;
@@ -3036,8 +3032,7 @@ ExecutionNode* MaterializeSingleNode<localDocumentId>::clone(ExecutionPlan* plan
   }
 
   auto c = std::make_unique<MaterializeSingleNode<localDocumentId>>(
-      plan, _id, collection(), *inNonMaterializedDocId,
-      *outVariable);
+      plan, _id, collection(), *inNonMaterializedDocId, *outVariable);
   CollectionAccessingNode::cloneInto(*c);
   return cloneHelper(std::move(c), withDependencies, withProperties);
 }

diff --git a/arangod/Aql/ExecutionNode.h b/arangod/Aql/ExecutionNode.h
@@ -1225,7 +1225,7 @@ class MaterializeSingleNode : public MaterializeNode,
   ExecutionNode* clone(ExecutionPlan* plan, bool withDependencies,
                        bool withProperties) const override final;
 
-protected:
+ protected:
   /// @brief export to VelocyPack
   void doToVelocyPack(arangodb::velocypack::Builder& nodes,
                       unsigned flags) const override final;

diff --git a/arangod/Aql/IndexExecutor.cpp b/arangod/Aql/IndexExecutor.cpp
@@ -107,12 +107,13 @@ IndexIterator::CoveringCallback getCallback(
     IndexNode::IndexValuesVars const& outNonMaterializedIndVars,
     IndexNode::IndexValuesRegisters const& outNonMaterializedIndRegs) {
   auto impl = [&context, &index, &outNonMaterializedIndVars,
-          &outNonMaterializedIndRegs]<typename TokenType>(TokenType&& token,
-                                      IndexIteratorCoveringData& covering) {
-    constexpr bool isLocalDocumentId = std::is_same_v <LocalDocumentId,
-                   std::decay_t<TokenType>>;
+               &outNonMaterializedIndRegs]<typename TokenType>(
+                  TokenType&& token, IndexIteratorCoveringData& covering) {
+    constexpr bool isLocalDocumentId =
+        std::is_same_v<LocalDocumentId, std::decay_t<TokenType>>;
     // can't be a static_assert as this implementation is still possible
-    // just can't be used right now as for restriction in late materialization rule
+    // just can't be used right now as for restriction in late materialization
+    // rule
 #ifdef ARANGODB_ENABLE_MAINTAINER_MODE
     if constexpr (checkUniqueness && !isLocalDocumentId) {
       TRI_ASSERT(false);

diff --git a/arangod/Aql/IndexNode.cpp b/arangod/Aql/IndexNode.cpp
@@ -354,7 +354,6 @@ std::unique_ptr<ExecutionBlock> IndexNode::createBlock(
   auto const outVariable =
       isLateMaterialized() ? _outNonMaterializedDocId : _outVariable;
 
-
   auto const outRegister = variableToRegisterId(outVariable);
 
   auto numIndVarsRegisters =

diff --git a/arangod/Aql/IndexNodeOptimizerRules.cpp b/arangod/Aql/IndexNodeOptimizerRules.cpp
@@ -122,7 +122,7 @@ void arangodb::aql::lateDocumentMaterializationRule(
       auto& indexes = indexNode->getIndexes();
       TRI_ASSERT(!indexes.empty());
       if (indexes.size() != 1) {
-        // When enabling this please consider how inverted index would 
+        // When enabling this please consider how inverted index would
         // operate together with persistent as first produces
         // SearchDocs but latter LocalDocumentIds. Usage of
         // two separate variables might be the simplest solution
@@ -338,15 +338,13 @@ void arangodb::aql::lateDocumentMaterializationRule(
         // insert a materialize node
         auto makeMaterializer = [&]() -> std::unique_ptr<ExecutionNode> {
           if (index->type() == Index::TRI_IDX_TYPE_INVERTED_INDEX) {
-            return std::make_unique <materialize::MaterializeSingleNode<false>>(
-                                          plan.get(), plan->nextId(),
-                                          indexNode->collection(),
-                                          *localDocIdTmp, *var);
+            return std::make_unique<materialize::MaterializeSingleNode<false>>(
+                plan.get(), plan->nextId(), indexNode->collection(),
+                *localDocIdTmp, *var);
           }
-          return std::make_unique <materialize::MaterializeSingleNode<true>>(
-                                        plan.get(), plan->nextId(),
-                                        indexNode->collection(), *localDocIdTmp,
-                                        *var);
+          return std::make_unique<materialize::MaterializeSingleNode<true>>(
+              plan.get(), plan->nextId(), indexNode->collection(),
+              *localDocIdTmp, *var);
         };
         auto* materializeNode = plan->registerNode(makeMaterializer());
         TRI_ASSERT(materializeNode);

diff --git a/arangod/Aql/MaterializeExecutor.cpp b/arangod/Aql/MaterializeExecutor.cpp
@@ -40,7 +40,8 @@ using namespace arangodb::aql;
 
 template<typename T, bool localDocumentId>
 arangodb::IndexIterator::DocumentCallback
-MaterializeExecutor<T, localDocumentId>::ReadContext::copyDocumentCallback(ReadContext& ctx) {
+MaterializeExecutor<T, localDocumentId>::ReadContext::copyDocumentCallback(
+    ReadContext& ctx) {
   typedef std::function<arangodb::IndexIterator::DocumentCallback(ReadContext&)>
       CallbackFactory;
   static CallbackFactory const callbackFactory{[](ReadContext& ctx) {
@@ -74,7 +75,8 @@ MaterializeExecutor<T, localDocumentId>::MaterializeExecutor(
 }
 
 template<typename T, bool localDocumentId>
-void MaterializeExecutor<T, localDocumentId>::fillBuffer(AqlItemBlockInputRange& inputRange) {
+void MaterializeExecutor<T, localDocumentId>::fillBuffer(
+    AqlItemBlockInputRange& inputRange) {
   TRI_ASSERT(!localDocumentId);
   _bufferedDocs.clear();
   auto const block = inputRange.getBlock();
@@ -191,8 +193,8 @@ void MaterializeExecutor<T, localDocumentId>::fillBuffer(AqlItemBlockInputRange&
 
 template<typename T, bool localDocumentId>
 std::tuple<ExecutorState, MaterializeStats, AqlCall>
-MaterializeExecutor<T, localDocumentId>::produceRows(AqlItemBlockInputRange& inputRange,
-                                    OutputAqlItemRow& output) {
+MaterializeExecutor<T, localDocumentId>::produceRows(
+    AqlItemBlockInputRange& inputRange, OutputAqlItemRow& output) {
   MaterializeStats stats;
 
   AqlCall upstreamCall{};
@@ -277,8 +279,8 @@ MaterializeExecutor<T, localDocumentId>::produceRows(AqlItemBlockInputRange& inp
 
 template<typename T, bool localDocumentId>
 std::tuple<ExecutorState, MaterializeStats, size_t, AqlCall>
-MaterializeExecutor<T, localDocumentId>::skipRowsRange(AqlItemBlockInputRange& inputRange,
-                                      AqlCall& call) {
+MaterializeExecutor<T, localDocumentId>::skipRowsRange(
+    AqlItemBlockInputRange& inputRange, AqlCall& call) {
   size_t skipped = 0;
 
   // hasDataRow may only occur during fullCount due to previous overfetching

diff --git a/arangod/IResearch/IResearchInvertedIndex.cpp b/arangod/IResearch/IResearchInvertedIndex.cpp
@@ -455,11 +455,13 @@ template<bool emitLocalDocumentId>
 class IResearchInvertedIndexIterator final
     : public IResearchInvertedIndexIteratorBase {
  public:
-  IResearchInvertedIndexIterator(
-      ResourceMonitor& monitor, LogicalCollection* collection,
-      ViewSnapshot& state, transaction::Methods* trx,
-      aql::AstNode const* condition, IResearchInvertedIndexMeta const* meta,
-      aql::Variable const* variable, int mutableConditionIdx)
+  IResearchInvertedIndexIterator(ResourceMonitor& monitor,
+                                 LogicalCollection* collection,
+                                 ViewSnapshot& state, transaction::Methods* trx,
+                                 aql::AstNode const* condition,
+                                 IResearchInvertedIndexMeta const* meta,
+                                 aql::Variable const* variable,
+                                 int mutableConditionIdx)
       : IResearchInvertedIndexIteratorBase(collection, state, trx, condition,
                                            meta, variable, mutableConditionIdx),
         _projections(*meta) {}
@@ -484,20 +486,19 @@ class IResearchInvertedIndexIterator final
     nextImplInternal<decltype(skipped), false, false>(skipped, count);
   }
 
-  bool nextDocumentImpl(DocumentCallback const& cb,
-                                       uint64_t limit) override {
+  bool nextDocumentImpl(DocumentCallback const& cb, uint64_t limit) override {
     return nextImpl(
         [this, &cb](LocalDocumentId const& token) {
           // we use here just first snapshot as they are all the same here.
           // iterator operates only one iresearch datastore
           return _collection->getPhysical()
-              ->readFromSnapshot(_trx, token, cb, canReadOwnWrites(), _snapshot.snapshot(0))
+              ->readFromSnapshot(_trx, token, cb, canReadOwnWrites(),
+                                 _snapshot.snapshot(0))
               .ok();
         },
         limit);
   }
 
-
   // FIXME: Evaluate buffering iresearch reads
   template<typename Callback, bool withCovering, bool produce>
   bool nextImplInternal(Callback const& callback, uint64_t limit) {
@@ -668,18 +669,16 @@ class IResearchInvertedIndexMergeIterator final
         // Otherwise we read it only if required.
         constexpr bool needReadLocalDocumentId =
             !withCovering || emitLocalDocumentId;
-        if (!needReadLocalDocumentId || segment.doc->value ==
-            segment.pkDocItr->seek(segment.doc->value)) {
+        if (!needReadLocalDocumentId ||
+            segment.doc->value == segment.pkDocItr->seek(segment.doc->value)) {
           LocalDocumentId documentId;
           bool const readSuccess =
-              !needReadLocalDocumentId || 
+              !needReadLocalDocumentId ||
               DocumentPrimaryKey::read(documentId, segment.pkValue->value);
           if (readSuccess) {
             if constexpr (withCovering) {
               segment.projections.seek(segment.doc->value);
-              SearchDoc doc(
-                  _snapshot.segment(currentIdx),
-                  segment.doc->value);
+              SearchDoc doc(_snapshot.segment(currentIdx), segment.doc->value);
               TRI_ASSERT(documentId.isSet() == emitLocalDocumentId);
               bool emitRes{false};
               if constexpr (emitLocalDocumentId) {
@@ -991,7 +990,8 @@ std::unique_ptr<IndexIterator> IResearchInvertedIndex::iteratorForCondition(
       if (!selfLock) {
         THROW_ARANGO_EXCEPTION_MESSAGE(
             TRI_ERROR_INTERNAL,
-            absl::StrCat("Failed to lock datastore for index '", index().name(), "'"));
+            absl::StrCat("Failed to lock datastore for index '", index().name(),
+                         "'"));
       }
       // TODO(MBkkt) Move it to optimization stage
       if (opts.waitForSync &&
@@ -1004,7 +1004,7 @@ std::unique_ptr<IndexIterator> IResearchInvertedIndex::iteratorForCondition(
       ViewSnapshot::Links links;
       links.push_back(std::move(selfLock));
       ctx = makeViewSnapshot(*trx, key, opts.waitForSync, index().name(),
-                                  std::move(links));
+                             std::move(links));
     }
     return *ctx;
   }();

diff --git a/arangod/IResearch/IResearchInvertedIndex.h b/arangod/IResearch/IResearchInvertedIndex.h
@@ -69,7 +69,7 @@ class IResearchInvertedIndex : public IResearchDataStore {
   bool covers(aql::Projections& projections) const;
 
   std::vector<std::vector<basics::AttributeName>> const& coveredFields()
-    const noexcept {
+      const noexcept {
     return _coveredFields;
   }
 

diff --git a/arangod/Indexes/IndexIterator.h b/arangod/Indexes/IndexIterator.h
@@ -150,34 +150,30 @@ class IndexIterator {
     velocypack::ValueLength _storedValuesLength;
   };
 
-
   // TODO: Move to iresearch
   template<typename... Funcs>
   class CallbackImpl : private fu2::function<Funcs...> {
     using Base = fu2::function<Funcs...>;
 
     struct DummyRetval {
       template<typename T>
-      operator T() const{
+      operator T() const {
         TRI_ASSERT(false);
         throw std::bad_function_call{};
       }
     };
+
    public:
     using Base::operator();
     using Base::operator bool;
 
-    bool operator==(std::nullptr_t) {
-      return !bool(*this);
-    }
+    bool operator==(std::nullptr_t) { return !bool(*this); }
 
-    bool operator!=(std::nullptr_t) {
-      return bool(*this);
-    }
+    bool operator!=(std::nullptr_t) { return bool(*this); }
 
     CallbackImpl() noexcept = default;
 
-    template<typename...Fs>
+    template<typename... Fs>
     CallbackImpl(Fs&&... fs)
         : Base{fu2::overload(std::forward<Fs>(fs)...,
                              [](auto&&...) { return DummyRetval{}; })} {}
@@ -186,8 +182,8 @@ class IndexIterator {
   using LocalDocumentIdCallback =
       CallbackImpl<bool(LocalDocumentId const& token) const>;
 
-  using DocumentCallback =
-      CallbackImpl<bool(LocalDocumentId const& token, velocypack::Slice doc) const>;
+  using DocumentCallback = CallbackImpl<bool(LocalDocumentId const& token,
+                                             velocypack::Slice doc) const>;
 
   using CoveringCallback =
       CallbackImpl<bool(LocalDocumentId const& token,

diff --git a/tests/IResearch/IResearchInvertedIndexIteratorTest.cpp b/tests/IResearch/IResearchInvertedIndexIteratorTest.cpp
@@ -198,8 +198,7 @@ class IResearchInvertedIndexIteratorTestBase
       std::function<void(arangodb::IndexIterator* it)> const& test,
       std::string_view refName = "d",
       std::shared_ptr<arangodb::velocypack::Builder> bindVars = nullptr,
-      int mutableConditionIdx = -1,
-      bool forLateMaterialization = false) {
+      int mutableConditionIdx = -1, bool forLateMaterialization = false) {
     SCOPED_TRACE(testing::Message("ExecuteIteratorTest failed for query ")
                  << queryString);
     auto ctx =
@@ -406,7 +405,8 @@ TEST_F(IResearchInvertedIndexIteratorTest, test_skip_nextCovering) {
   executeIteratorTest(queryString, test);
 }
 
-TEST_F(IResearchInvertedIndexIteratorTest, test_skip_nextCovering_LateMaterialized) {
+TEST_F(IResearchInvertedIndexIteratorTest,
+       test_skip_nextCovering_LateMaterialized) {
   std::string queryString{
       R"(FOR d IN col FILTER d.a == "1" OR d.b == "2" RETURN d)"};
   auto test = [this](arangodb::IndexIterator* iterator) {
@@ -423,12 +423,11 @@ TEST_F(IResearchInvertedIndexIteratorTest, test_skip_nextCovering_LateMaterializ
     ASSERT_TRUE(iterator->hasMore());
     unsigned docs{0};
 
-    auto docCallback = [&docs](
-                           arangodb::aql::AqlValue&& token,
-                           arangodb::IndexIteratorCoveringData& data) {
+    auto docCallback = [&docs](arangodb::aql::AqlValue&& token,
+                               arangodb::IndexIteratorCoveringData& data) {
       ++docs;
-      auto searchDoc = arangodb::iresearch::SearchDoc::decode(
-          token.slice().stringView());
+      auto searchDoc =
+          arangodb::iresearch::SearchDoc::decode(token.slice().stringView());
       token.destroy();
       EXPECT_TRUE(searchDoc.isValid());
       EXPECT_TRUE(data.isArray());
@@ -454,7 +453,7 @@ TEST_F(IResearchInvertedIndexIteratorTest, test_skip_nextCovering_LateMaterializ
     ASSERT_EQ(docs, 2);
     ASSERT_FALSE(iterator->hasMore());
   };
-  executeIteratorTest(queryString, test, "d", nullptr, - 1, true);
+  executeIteratorTest(queryString, test, "d", nullptr, -1, true);
 }
 
 TEST_F(IResearchInvertedIndexIteratorTest, test_next_array) {