@nxtedition/rocksdb 8.2.0 → 8.2.2

package/deps/rocksdb/rocksdb/table/block_based/data_block_hash_index_test.cc

@@ -581,8 +581,9 @@ void TestBoundary(InternalKey& ik1, std::string& v1, InternalKey& ik2,
   const bool kImmortal = true;
   ASSERT_OK(ioptions.table_factory->NewTableReader(
       TableReaderOptions(ioptions, moptions.prefix_extractor, soptions,
-                         internal_comparator, !kSkipFilters, !kImmortal,
-                         level_),
+                         internal_comparator,
+                         0 /* block_protection_bytes_per_key */, !kSkipFilters,
+                         !kImmortal, level_),
       std::move(file_reader), sink->contents().size(), &table_reader));
   // Search using Get()
   ReadOptions ro;

package/deps/rocksdb/rocksdb/table/block_based/filter_block.h

@@ -113,17 +113,17 @@ class FilterBlockReader {
                            const Slice* const const_ikey_ptr,
                            GetContext* get_context,
                            BlockCacheLookupContext* lookup_context,
-                           Env::IOPriority rate_limiter_priority) = 0;
+                           const ReadOptions& read_options) = 0;
 
   virtual void KeysMayMatch(MultiGetRange* range, const bool no_io,
                             BlockCacheLookupContext* lookup_context,
-                            Env::IOPriority rate_limiter_priority) {
+                            const ReadOptions& read_options) {
     for (auto iter = range->begin(); iter != range->end(); ++iter) {
       const Slice ukey_without_ts = iter->ukey_without_ts;
       const Slice ikey = iter->ikey;
       GetContext* const get_context = iter->get_context;
       if (!KeyMayMatch(ukey_without_ts, no_io, &ikey, get_context,
-                       lookup_context, rate_limiter_priority)) {
+                       lookup_context, read_options)) {
         range->SkipKey(iter);
       }
     }
@@ -136,21 +136,20 @@ class FilterBlockReader {
                               const Slice* const const_ikey_ptr,
                               GetContext* get_context,
                               BlockCacheLookupContext* lookup_context,
-                              Env::IOPriority rate_limiter_priority) = 0;
+                              const ReadOptions& read_options) = 0;
 
   virtual void PrefixesMayMatch(MultiGetRange* range,
                                 const SliceTransform* prefix_extractor,
                                 const bool no_io,
                                 BlockCacheLookupContext* lookup_context,
-                                Env::IOPriority rate_limiter_priority) {
+                                const ReadOptions& read_options) {
     for (auto iter = range->begin(); iter != range->end(); ++iter) {
       const Slice ukey_without_ts = iter->ukey_without_ts;
       const Slice ikey = iter->ikey;
       GetContext* const get_context = iter->get_context;
       if (prefix_extractor->InDomain(ukey_without_ts) &&
           !PrefixMayMatch(prefix_extractor->Transform(ukey_without_ts), no_io,
-                          &ikey, get_context, lookup_context,
-                          rate_limiter_priority)) {
+                          &ikey, get_context, lookup_context, read_options)) {
         range->SkipKey(iter);
       }
     }
@@ -164,7 +163,9 @@ class FilterBlockReader {
     return error_msg;
   }
 
-  virtual Status CacheDependencies(const ReadOptions& /*ro*/, bool /*pin*/) {
+  virtual Status CacheDependencies(
+      const ReadOptions& /*ro*/, bool /*pin*/,
+      FilePrefetchBuffer* /* tail_prefetch_buffer */) {
     return Status::OK();
   }
 
@@ -176,7 +177,7 @@ class FilterBlockReader {
                              bool* filter_checked, bool need_upper_bound_check,
                              bool no_io,
                              BlockCacheLookupContext* lookup_context,
-                             Env::IOPriority rate_limiter_priority) = 0;
+                             const ReadOptions& read_options) = 0;
 };
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/table/block_based/filter_block_reader_common.cc

@@ -70,7 +70,7 @@ Status FilterBlockReaderCommon<TBlocklike>::GetOrReadFilterBlock(
     bool no_io, GetContext* get_context,
     BlockCacheLookupContext* lookup_context,
     CachableEntry<TBlocklike>* filter_block,
-    Env::IOPriority rate_limiter_priority) const {
+    const ReadOptions& read_options) const {
   assert(filter_block);
 
   if (!filter_block_.IsEmpty()) {
@@ -78,13 +78,12 @@ Status FilterBlockReaderCommon<TBlocklike>::GetOrReadFilterBlock(
     return Status::OK();
   }
 
-  ReadOptions read_options;
-  read_options.rate_limiter_priority = rate_limiter_priority;
+  ReadOptions ro = read_options;
   if (no_io) {
-    read_options.read_tier = kBlockCacheTier;
+    ro.read_tier = kBlockCacheTier;
   }
 
-  return ReadFilterBlock(table_, nullptr /* prefetch_buffer */, read_options,
+  return ReadFilterBlock(table_, nullptr /* prefetch_buffer */, ro,
                          cache_filter_blocks(), get_context, lookup_context,
                          filter_block);
 }
@@ -104,8 +103,7 @@ bool FilterBlockReaderCommon<TBlocklike>::RangeMayExist(
     const SliceTransform* prefix_extractor, const Comparator* comparator,
     const Slice* const const_ikey_ptr, bool* filter_checked,
     bool need_upper_bound_check, bool no_io,
-    BlockCacheLookupContext* lookup_context,
-    Env::IOPriority rate_limiter_priority) {
+    BlockCacheLookupContext* lookup_context, const ReadOptions& read_options) {
   if (!prefix_extractor || !prefix_extractor->InDomain(user_key_without_ts)) {
     *filter_checked = false;
     return true;
@@ -119,7 +117,7 @@ bool FilterBlockReaderCommon<TBlocklike>::RangeMayExist(
     *filter_checked = true;
     return PrefixMayMatch(prefix, no_io, const_ikey_ptr,
                           /* get_context */ nullptr, lookup_context,
-                          rate_limiter_priority);
+                          read_options);
   }
 }
 

package/deps/rocksdb/rocksdb/table/block_based/filter_block_reader_common.h

@@ -40,7 +40,7 @@ class FilterBlockReaderCommon : public FilterBlockReader {
                      const Slice* const const_ikey_ptr, bool* filter_checked,
                      bool need_upper_bound_check, bool no_io,
                      BlockCacheLookupContext* lookup_context,
-                     Env::IOPriority rate_limiter_priority) override;
+                     const ReadOptions& read_options) override;
 
  protected:
   static Status ReadFilterBlock(const BlockBasedTable* table,
@@ -58,7 +58,7 @@ class FilterBlockReaderCommon : public FilterBlockReader {
   Status GetOrReadFilterBlock(bool no_io, GetContext* get_context,
                               BlockCacheLookupContext* lookup_context,
                               CachableEntry<TBlocklike>* filter_block,
-                              Env::IOPriority rate_limiter_priority) const;
+                              const ReadOptions& read_options) const;
 
   size_t ApproximateFilterBlockMemoryUsage() const;
 

package/deps/rocksdb/rocksdb/table/block_based/flush_block_policy.cc

@@ -13,7 +13,7 @@
 #include "rocksdb/utilities/customizable_util.h"
 #include "table/block_based/block_based_table_reader.h"
 #include "table/block_based/block_builder.h"
-#include "table/block_based/flush_block_policy.h"
+#include "table/block_based/flush_block_policy_impl.h"
 #include "table/format.h"
 
 namespace ROCKSDB_NAMESPACE {

package/deps/rocksdb/rocksdb/table/block_based/full_filter_block.cc

@@ -127,12 +127,11 @@ bool FullFilterBlockReader::KeyMayMatch(const Slice& key, const bool no_io,
                                         const Slice* const /*const_ikey_ptr*/,
                                         GetContext* get_context,
                                         BlockCacheLookupContext* lookup_context,
-                                        Env::IOPriority rate_limiter_priority) {
+                                        const ReadOptions& read_options) {
   if (!whole_key_filtering()) {
     return true;
   }
-  return MayMatch(key, no_io, get_context, lookup_context,
-                  rate_limiter_priority);
+  return MayMatch(key, no_io, get_context, lookup_context, read_options);
 }
 
 std::unique_ptr<FilterBlockReader> FullFilterBlockReader::Create(
@@ -165,20 +164,18 @@ std::unique_ptr<FilterBlockReader> FullFilterBlockReader::Create(
 bool FullFilterBlockReader::PrefixMayMatch(
     const Slice& prefix, const bool no_io,
     const Slice* const /*const_ikey_ptr*/, GetContext* get_context,
-    BlockCacheLookupContext* lookup_context,
-    Env::IOPriority rate_limiter_priority) {
-  return MayMatch(prefix, no_io, get_context, lookup_context,
-                  rate_limiter_priority);
+    BlockCacheLookupContext* lookup_context, const ReadOptions& read_options) {
+  return MayMatch(prefix, no_io, get_context, lookup_context, read_options);
 }
 
-bool FullFilterBlockReader::MayMatch(
-    const Slice& entry, bool no_io, GetContext* get_context,
-    BlockCacheLookupContext* lookup_context,
-    Env::IOPriority rate_limiter_priority) const {
+bool FullFilterBlockReader::MayMatch(const Slice& entry, bool no_io,
+                                     GetContext* get_context,
+                                     BlockCacheLookupContext* lookup_context,
+                                     const ReadOptions& read_options) const {
   CachableEntry<ParsedFullFilterBlock> filter_block;
 
   const Status s = GetOrReadFilterBlock(no_io, get_context, lookup_context,
-                                        &filter_block, rate_limiter_priority);
+                                        &filter_block, read_options);
   if (!s.ok()) {
     IGNORE_STATUS_IF_ERROR(s);
     return true;
@@ -203,33 +200,31 @@ bool FullFilterBlockReader::MayMatch(
 
 void FullFilterBlockReader::KeysMayMatch(
     MultiGetRange* range, const bool no_io,
-    BlockCacheLookupContext* lookup_context,
-    Env::IOPriority rate_limiter_priority) {
+    BlockCacheLookupContext* lookup_context, const ReadOptions& read_options) {
   if (!whole_key_filtering()) {
     // Simply return. Don't skip any key - consider all keys as likely to be
     // present
     return;
   }
-  MayMatch(range, no_io, nullptr, lookup_context, rate_limiter_priority);
+  MayMatch(range, no_io, nullptr, lookup_context, read_options);
 }
 
 void FullFilterBlockReader::PrefixesMayMatch(
     MultiGetRange* range, const SliceTransform* prefix_extractor,
     const bool no_io, BlockCacheLookupContext* lookup_context,
-    Env::IOPriority rate_limiter_priority) {
-  MayMatch(range, no_io, prefix_extractor, lookup_context,
-           rate_limiter_priority);
+    const ReadOptions& read_options) {
+  MayMatch(range, no_io, prefix_extractor, lookup_context, read_options);
 }
 
-void FullFilterBlockReader::MayMatch(
-    MultiGetRange* range, bool no_io, const SliceTransform* prefix_extractor,
-    BlockCacheLookupContext* lookup_context,
-    Env::IOPriority rate_limiter_priority) const {
+void FullFilterBlockReader::MayMatch(MultiGetRange* range, bool no_io,
+                                     const SliceTransform* prefix_extractor,
+                                     BlockCacheLookupContext* lookup_context,
+                                     const ReadOptions& read_options) const {
   CachableEntry<ParsedFullFilterBlock> filter_block;
 
   const Status s =
       GetOrReadFilterBlock(no_io, range->begin()->get_context, lookup_context,
-                           &filter_block, rate_limiter_priority);
+                           &filter_block, read_options);
   if (!s.ok()) {
     IGNORE_STATUS_IF_ERROR(s);
     return;

package/deps/rocksdb/rocksdb/table/block_based/full_filter_block.h

@@ -108,40 +108,40 @@ class FullFilterBlockReader
   bool KeyMayMatch(const Slice& key, const bool no_io,
                    const Slice* const const_ikey_ptr, GetContext* get_context,
                    BlockCacheLookupContext* lookup_context,
-                   Env::IOPriority rate_limiter_priority) override;
+                   const ReadOptions& read_options) override;
 
   bool PrefixMayMatch(const Slice& prefix, const bool no_io,
                       const Slice* const const_ikey_ptr,
                       GetContext* get_context,
                       BlockCacheLookupContext* lookup_context,
-                      Env::IOPriority rate_limiter_priority) override;
+                      const ReadOptions& read_options) override;
 
   void KeysMayMatch(MultiGetRange* range, const bool no_io,
                     BlockCacheLookupContext* lookup_context,
-                    Env::IOPriority rate_limiter_priority) override;
+                    const ReadOptions& read_options) override;
   // Used in partitioned filter code
   void KeysMayMatch2(MultiGetRange* range,
                      const SliceTransform* /*prefix_extractor*/,
                      const bool no_io, BlockCacheLookupContext* lookup_context,
-                     Env::IOPriority rate_limiter_priority) {
-    KeysMayMatch(range, no_io, lookup_context, rate_limiter_priority);
+                     const ReadOptions& read_options) {
+    KeysMayMatch(range, no_io, lookup_context, read_options);
   }
 
   void PrefixesMayMatch(MultiGetRange* range,
                         const SliceTransform* prefix_extractor,
                         const bool no_io,
                         BlockCacheLookupContext* lookup_context,
-                        Env::IOPriority rate_limiter_priority) override;
+                        const ReadOptions& read_options) override;
   size_t ApproximateMemoryUsage() const override;
 
  private:
   bool MayMatch(const Slice& entry, bool no_io, GetContext* get_context,
                 BlockCacheLookupContext* lookup_context,
-                Env::IOPriority rate_limiter_priority) const;
+                const ReadOptions& read_options) const;
   void MayMatch(MultiGetRange* range, bool no_io,
                 const SliceTransform* prefix_extractor,
                 BlockCacheLookupContext* lookup_context,
-                Env::IOPriority rate_limiter_priority) const;
+                const ReadOptions& read_options) const;
 };
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/table/block_based/full_filter_block_test.cc

@@ -117,7 +117,7 @@ TEST_F(PluginFullFilterBlockTest, PluginEmptyBuilder) {
   ASSERT_TRUE(reader.KeyMayMatch("foo",
                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
-                                 /*lookup_context=*/nullptr, Env::IO_TOTAL));
+                                 /*lookup_context=*/nullptr, ReadOptions()));
 }
 
 TEST_F(PluginFullFilterBlockTest, PluginSingleChunk) {
@@ -135,42 +135,34 @@ TEST_F(PluginFullFilterBlockTest, PluginSingleChunk) {
       nullptr /* cache */, nullptr /* cache_handle */, true /* own_value */);
 
   FullFilterBlockReader reader(table_.get(), std::move(block));
-  Env::IOPriority rate_limiter_priority = Env::IO_TOTAL;
   ASSERT_TRUE(reader.KeyMayMatch("foo",
                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
-                                 /*lookup_context=*/nullptr,
-                                 rate_limiter_priority));
+                                 /*lookup_context=*/nullptr, ReadOptions()));
   ASSERT_TRUE(reader.KeyMayMatch("bar",
                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
-                                 /*lookup_context=*/nullptr,
-                                 rate_limiter_priority));
+                                 /*lookup_context=*/nullptr, ReadOptions()));
   ASSERT_TRUE(reader.KeyMayMatch("box",
                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
-                                 /*lookup_context=*/nullptr,
-                                 rate_limiter_priority));
+                                 /*lookup_context=*/nullptr, ReadOptions()));
   ASSERT_TRUE(reader.KeyMayMatch("hello",
                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
-                                 /*lookup_context=*/nullptr,
-                                 rate_limiter_priority));
+                                 /*lookup_context=*/nullptr, ReadOptions()));
   ASSERT_TRUE(reader.KeyMayMatch("foo",
                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
-                                 /*lookup_context=*/nullptr,
-                                 rate_limiter_priority));
+                                 /*lookup_context=*/nullptr, ReadOptions()));
   ASSERT_TRUE(!reader.KeyMayMatch("missing",
                                   /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                   /*get_context=*/nullptr,
-                                  /*lookup_context=*/nullptr,
-                                  rate_limiter_priority));
+                                  /*lookup_context=*/nullptr, ReadOptions()));
   ASSERT_TRUE(!reader.KeyMayMatch("other",
                                   /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                   /*get_context=*/nullptr,
-                                  /*lookup_context=*/nullptr,
-                                  rate_limiter_priority));
+                                  /*lookup_context=*/nullptr, ReadOptions()));
 }
 
 class FullFilterBlockTest : public mock::MockBlockBasedTableTester,
@@ -195,7 +187,7 @@ TEST_F(FullFilterBlockTest, EmptyBuilder) {
   ASSERT_TRUE(reader.KeyMayMatch("foo",
                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
-                                 /*lookup_context=*/nullptr, Env::IO_TOTAL));
+                                 /*lookup_context=*/nullptr, ReadOptions()));
 }
 
 class CountUniqueFilterBitsBuilderWrapper : public FilterBitsBuilder {
@@ -292,42 +284,34 @@ TEST_F(FullFilterBlockTest, SingleChunk) {
       nullptr /* cache */, nullptr /* cache_handle */, true /* own_value */);
 
   FullFilterBlockReader reader(table_.get(), std::move(block));
-  Env::IOPriority rate_limiter_priority = Env::IO_TOTAL;
   ASSERT_TRUE(reader.KeyMayMatch("foo",
                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
-                                 /*lookup_context=*/nullptr,
-                                 rate_limiter_priority));
+                                 /*lookup_context=*/nullptr, ReadOptions()));
   ASSERT_TRUE(reader.KeyMayMatch("bar",
                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
-                                 /*lookup_context=*/nullptr,
-                                 rate_limiter_priority));
+                                 /*lookup_context=*/nullptr, ReadOptions()));
   ASSERT_TRUE(reader.KeyMayMatch("box",
                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
-                                 /*lookup_context=*/nullptr,
-                                 rate_limiter_priority));
+                                 /*lookup_context=*/nullptr, ReadOptions()));
   ASSERT_TRUE(reader.KeyMayMatch("hello",
                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
-                                 /*lookup_context=*/nullptr,
-                                 rate_limiter_priority));
+                                 /*lookup_context=*/nullptr, ReadOptions()));
   ASSERT_TRUE(reader.KeyMayMatch("foo",
                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
-                                 /*lookup_context=*/nullptr,
-                                 rate_limiter_priority));
+                                 /*lookup_context=*/nullptr, ReadOptions()));
   ASSERT_TRUE(!reader.KeyMayMatch("missing",
                                   /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                   /*get_context=*/nullptr,
-                                  /*lookup_context=*/nullptr,
-                                  rate_limiter_priority));
+                                  /*lookup_context=*/nullptr, ReadOptions()));
   ASSERT_TRUE(!reader.KeyMayMatch("other",
                                   /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                   /*get_context=*/nullptr,
-                                  /*lookup_context=*/nullptr,
-                                  rate_limiter_priority));
+                                  /*lookup_context=*/nullptr, ReadOptions()));
 }
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/table/block_based/hash_index_reader.cc

@@ -74,17 +74,17 @@ Status HashIndexReader::Create(const BlockBasedTable* table,
   // Read contents for the blocks
   BlockContents prefixes_contents;
   BlockFetcher prefixes_block_fetcher(
-      file, prefetch_buffer, footer, ReadOptions(), prefixes_handle,
-      &prefixes_contents, ioptions, true /*decompress*/,
-      true /*maybe_compressed*/, BlockType::kHashIndexPrefixes,
-      UncompressionDict::GetEmptyDict(), cache_options, memory_allocator);
+      file, prefetch_buffer, footer, ro, prefixes_handle, &prefixes_contents,
+      ioptions, true /*decompress*/, true /*maybe_compressed*/,
+      BlockType::kHashIndexPrefixes, UncompressionDict::GetEmptyDict(),
+      cache_options, memory_allocator);
   s = prefixes_block_fetcher.ReadBlockContents();
   if (!s.ok()) {
     return s;
   }
   BlockContents prefixes_meta_contents;
   BlockFetcher prefixes_meta_block_fetcher(
-      file, prefetch_buffer, footer, ReadOptions(), prefixes_meta_handle,
+      file, prefetch_buffer, footer, ro, prefixes_meta_handle,
       &prefixes_meta_contents, ioptions, true /*decompress*/,
       true /*maybe_compressed*/, BlockType::kHashIndexMetadata,
       UncompressionDict::GetEmptyDict(), cache_options, memory_allocator);
@@ -116,9 +116,8 @@ InternalIteratorBase<IndexValue>* HashIndexReader::NewIterator(
   const BlockBasedTable::Rep* rep = table()->get_rep();
   const bool no_io = (read_options.read_tier == kBlockCacheTier);
   CachableEntry<Block> index_block;
-  const Status s =
-      GetOrReadIndexBlock(no_io, read_options.rate_limiter_priority,
-                          get_context, lookup_context, &index_block);
+  const Status s = GetOrReadIndexBlock(no_io, get_context, lookup_context,
+                                       &index_block, read_options);
   if (!s.ok()) {
     if (iter != nullptr) {
       iter->Invalidate(s);

package/deps/rocksdb/rocksdb/table/block_based/index_reader_common.cc

@@ -35,9 +35,9 @@ Status BlockBasedTable::IndexReaderCommon::ReadIndexBlock(
 }
 
 Status BlockBasedTable::IndexReaderCommon::GetOrReadIndexBlock(
-    bool no_io, Env::IOPriority rate_limiter_priority, GetContext* get_context,
-    BlockCacheLookupContext* lookup_context,
-    CachableEntry<Block>* index_block) const {
+    bool no_io, GetContext* get_context,
+    BlockCacheLookupContext* lookup_context, CachableEntry<Block>* index_block,
+    const ReadOptions& ro) const {
   assert(index_block != nullptr);
 
   if (!index_block_.IsEmpty()) {
@@ -45,8 +45,7 @@ Status BlockBasedTable::IndexReaderCommon::GetOrReadIndexBlock(
     return Status::OK();
   }
 
-  ReadOptions read_options;
-  read_options.rate_limiter_priority = rate_limiter_priority;
+  ReadOptions read_options = ro;
   if (no_io) {
     read_options.read_tier = kBlockCacheTier;
   }

package/deps/rocksdb/rocksdb/table/block_based/index_reader_common.h

@@ -65,10 +65,10 @@ class BlockBasedTable::IndexReaderCommon : public BlockBasedTable::IndexReader {
     return table_->get_rep()->table_options.cache_index_and_filter_blocks;
   }
 
-  Status GetOrReadIndexBlock(bool no_io, Env::IOPriority rate_limiter_priority,
-                             GetContext* get_context,
+  Status GetOrReadIndexBlock(bool no_io, GetContext* get_context,
                              BlockCacheLookupContext* lookup_context,
-                             CachableEntry<Block>* index_block) const;
+                             CachableEntry<Block>* index_block,
+                             const ReadOptions& read_options) const;
 
   size_t ApproximateIndexBlockMemoryUsage() const {
     assert(!index_block_.GetOwnValue() || index_block_.GetValue() != nullptr);