README

storage

Storage related documentation.

Flush consistency model

Flush occurs in the following steps:

  • data warm flush
  • rotate commit log
  • data cold flush
    • rotate cold mutable index segments
    • flush cold tsdb data and write most files to disk (except checkpoint files)
    • flush cold index data to disk and reload
    • evict rotated cold mutable index segments
    • write tsdb checkpoint files (completes the tsdb cold flush lifecycle)
  • data snapshot
    • drops rotated commit log when we are done
  • index flush

Since we rotate the commit log before we perform a data cold flush and only drop the rotate commit log after data snapshotting is done we guarantee that no writes will be lost if the node crashes. After data cold flush completes, any new cold writes will exist in the active commit log (and not be dropped) when data snapshotting finishes. This is why data snapshotting only needs to snapshot warm data blocks (that need to be flushed).

Expand ▾ Collapse ▴

Documentation

Overview

    Package storage is a generated GoMock package.

    Index

    Constants

    This section is empty.

    Variables

    View Source
    var (
    
    	// ErrDatabaseLoadLimitHit is the error returned when the database load limit
    	// is hit or exceeded.
    	ErrDatabaseLoadLimitHit = errors.New("error loading series, database load limit hit")
    )

    Functions

    func NewDatabaseNamespaceDataAccumulator

    func NewDatabaseNamespaceDataAccumulator(
    	namespace databaseNamespace,
    ) bootstrap.NamespaceDataAccumulator

      NewDatabaseNamespaceDataAccumulator creates a data accumulator for the namespace.

      func NewLeaseVerifier

      func NewLeaseVerifier(retriever flushStateRetriever) *leaseVerifier

        NewLeaseVerifier creates a new LeaseVerifier.

        func NewSeriesOptionsFromOptions

        func NewSeriesOptionsFromOptions(opts Options, ropts retention.Options) series.Options

          NewSeriesOptionsFromOptions creates a new set of database series options from provided options.

          Types

          type AggregateTilesOptions

          type AggregateTilesOptions struct {
          	// Start and End specify the aggregation window.
          	Start, End time.Time
          	// Step is the downsampling step.
          	Step       time.Duration
          	InsOptions instrument.Options
          }

            AggregateTilesOptions is the options for large tile aggregation.

            func NewAggregateTilesOptions

            func NewAggregateTilesOptions(
            	start, end time.Time,
            	step time.Duration,
            	targetNsID ident.ID,
            	insOpts instrument.Options,
            ) (AggregateTilesOptions, error)

              NewAggregateTilesOptions creates new AggregateTilesOptions.

              type BackgroundProcess

              type BackgroundProcess interface {
              	// Start launches the BackgroundProcess to run asynchronously.
              	Start()
              
              	// Stop stops the BackgroundProcess.
              	Stop()
              
              	// Report reports runtime information.
              	Report()
              }

                BackgroundProcess is a background process that is run by the database.

                type BootstrapResult

                type BootstrapResult struct {
                	ErrorsBootstrap      []error
                	AlreadyBootstrapping bool
                }

                  BootstrapResult is a bootstrap result.

                  type BootstrapState

                  type BootstrapState int

                    BootstrapState is an enum representing the possible bootstrap states for a shard.

                    const (
                    	// BootstrapNotStarted indicates bootstrap has not been started yet.
                    	BootstrapNotStarted BootstrapState = iota
                    	// Bootstrapping indicates bootstrap process is in progress.
                    	Bootstrapping
                    	// Bootstrapped indicates a bootstrap process has completed.
                    	Bootstrapped
                    )

                    type Database

                    type Database interface {
                    	// Options returns the database options.
                    	Options() Options
                    
                    	// AssignShardSet sets the shard set assignment and returns immediately.
                    	AssignShardSet(shardSet sharding.ShardSet)
                    
                    	// Namespaces returns the namespaces.
                    	Namespaces() []Namespace
                    
                    	// Namespace returns the specified namespace.
                    	Namespace(ns ident.ID) (Namespace, bool)
                    
                    	// Open will open the database for writing and reading.
                    	Open() error
                    
                    	// Close will close the database for writing and reading. Close releases
                    	// release resources held by owned namespaces.
                    	Close() error
                    
                    	// ShardSet returns the set of shards currently associated with
                    	// this namespace.
                    	ShardSet() sharding.ShardSet
                    
                    	// Terminate will close the database for writing and reading. Terminate does
                    	// NOT release any resources held by owned namespaces, instead relying upon
                    	// the GC to do so.
                    	Terminate() error
                    
                    	// Write value to the database for an ID.
                    	Write(
                    		ctx context.Context,
                    		namespace ident.ID,
                    		id ident.ID,
                    		timestamp time.Time,
                    		value float64,
                    		unit xtime.Unit,
                    		annotation []byte,
                    	) error
                    
                    	// WriteTagged values to the database for an ID.
                    	WriteTagged(
                    		ctx context.Context,
                    		namespace ident.ID,
                    		id ident.ID,
                    		tags ident.TagIterator,
                    		timestamp time.Time,
                    		value float64,
                    		unit xtime.Unit,
                    		annotation []byte,
                    	) error
                    
                    	// BatchWriter returns a batch writer for the provided namespace that can
                    	// be used to issue a batch of writes to either WriteBatch
                    	// or WriteTaggedBatch.
                    	//
                    	// Note that when using the BatchWriter the caller owns the lifecycle of the series
                    	// IDs if they're being pooled its the callers responsibility to return them to the
                    	// appropriate pool, but the encoded tags and annotations are owned by the
                    	// writes.WriteBatch itself and will be finalized when the entire writes.WriteBatch is finalized
                    	// due to their lifecycle being more complicated.
                    	// Callers can still control the pooling of the encoded tags and annotations by using
                    	// the SetFinalizeEncodedTagsFn and SetFinalizeAnnotationFn on the WriteBatch itself.
                    	BatchWriter(namespace ident.ID, batchSize int) (writes.BatchWriter, error)
                    
                    	// WriteBatch is the same as Write, but in batch.
                    	WriteBatch(
                    		ctx context.Context,
                    		namespace ident.ID,
                    		writes writes.BatchWriter,
                    		errHandler IndexedErrorHandler,
                    	) error
                    
                    	// WriteTaggedBatch is the same as WriteTagged, but in batch.
                    	WriteTaggedBatch(
                    		ctx context.Context,
                    		namespace ident.ID,
                    		writes writes.BatchWriter,
                    		errHandler IndexedErrorHandler,
                    	) error
                    
                    	// QueryIDs resolves the given query into known IDs.
                    	QueryIDs(
                    		ctx context.Context,
                    		namespace ident.ID,
                    		query index.Query,
                    		opts index.QueryOptions,
                    	) (index.QueryResult, error)
                    
                    	// AggregateQuery resolves the given query into aggregated tags.
                    	AggregateQuery(
                    		ctx context.Context,
                    		namespace ident.ID,
                    		query index.Query,
                    		opts index.AggregationOptions,
                    	) (index.AggregateQueryResult, error)
                    
                    	// ReadEncoded retrieves encoded segments for an ID.
                    	ReadEncoded(
                    		ctx context.Context,
                    		namespace ident.ID,
                    		id ident.ID,
                    		start, end time.Time,
                    	) ([][]xio.BlockReader, error)
                    
                    	// WideQuery performs a wide blockwise query that provides batched results
                    	// that can exceed query limits.
                    	WideQuery(
                    		ctx context.Context,
                    		namespace ident.ID,
                    		query index.Query,
                    		start time.Time,
                    		shards []uint32,
                    		iterOpts index.IterationOptions,
                    	) ([]xio.WideEntry, error) // FIXME: change when exact type known.
                    
                    	// BatchProcessWideQuery runs the given query against the namespace index,
                    	// iterating in a batchwise fashion across all matching IDs, applying the given
                    	// IDBatchProcessor batch processing function to each ID discovered.
                    	BatchProcessWideQuery(
                    		ctx context.Context,
                    		n Namespace,
                    		query index.Query,
                    		batchProcessor IDBatchProcessor,
                    		opts index.WideQueryOptions,
                    	) error
                    
                    	// FetchBlocks retrieves data blocks for a given id and a list of block
                    	// start times.
                    	FetchBlocks(
                    		ctx context.Context,
                    		namespace ident.ID,
                    		shard uint32,
                    		id ident.ID,
                    		starts []time.Time,
                    	) ([]block.FetchBlockResult, error)
                    
                    	// FetchBlocksMetadata retrieves blocks metadata for a given shard, returns the
                    	// fetched block metadata results, the next page token, and any error encountered.
                    	// If we have fetched all the block metadata, we return nil as the next page token.
                    	FetchBlocksMetadataV2(
                    		ctx context.Context,
                    		namespace ident.ID,
                    		shard uint32,
                    		start, end time.Time,
                    		limit int64,
                    		pageToken PageToken,
                    		opts block.FetchBlocksMetadataOptions,
                    	) (block.FetchBlocksMetadataResults, PageToken, error)
                    
                    	// Bootstrap bootstraps the database.
                    	Bootstrap() error
                    
                    	// IsBootstrapped determines whether the database is bootstrapped.
                    	IsBootstrapped() bool
                    
                    	// IsBootstrappedAndDurable determines whether the database is bootstrapped
                    	// and durable, meaning that it could recover all data in memory using only
                    	// the local disk.
                    	IsBootstrappedAndDurable() bool
                    
                    	// IsOverloaded determines whether the database is overloaded.
                    	IsOverloaded() bool
                    
                    	// Repair will issue a repair and return nil on success or error on error.
                    	Repair() error
                    
                    	// Truncate truncates data for the given namespace.
                    	Truncate(namespace ident.ID) (int64, error)
                    
                    	// BootstrapState captures and returns a snapshot of the databases'
                    	// bootstrap state.
                    	BootstrapState() DatabaseBootstrapState
                    
                    	// FlushState returns the flush state for the specified shard and block start.
                    	FlushState(namespace ident.ID, shardID uint32, blockStart time.Time) (fileOpState, error)
                    
                    	// AggregateTiles does large tile aggregation from source namespace to target namespace.
                    	AggregateTiles(ctx context.Context, sourceNsID, targetNsID ident.ID, opts AggregateTilesOptions) (int64, error)
                    }

                      Database is a time series database.

                      func NewDatabase

                      func NewDatabase(
                      	shardSet sharding.ShardSet,
                      	opts Options,
                      ) (Database, error)

                        NewDatabase creates a new time series database.

                        type DatabaseBootstrapState

                        type DatabaseBootstrapState struct {
                        	NamespaceBootstrapStates NamespaceBootstrapStates
                        }

                          DatabaseBootstrapState stores a snapshot of the bootstrap state for all shards across all namespaces at a given moment in time.

                          type DebugMemorySegmentsOptions

                          type DebugMemorySegmentsOptions struct {
                          	OutputDirectory string
                          }

                            DebugMemorySegmentsOptions is a set of options to debug memory segments.

                            type GetNamespaceFn

                            type GetNamespaceFn func(id ident.ID) (Namespace, bool)

                              GetNamespaceFn will return a namespace for a given ID if present.

                              type IDBatchProcessor

                              type IDBatchProcessor func(batch *ident.IDBatch) error

                                IDBatchProcessor is a function that processes a batch.

                                type IndexedErrorHandler

                                type IndexedErrorHandler interface {
                                	HandleError(index int, err error)
                                }

                                  IndexedErrorHandler can handle individual errors based on their index. It is used primarily in cases where we need to handle errors in batches, but want to avoid an intermediary allocation of []error.

                                  type MemoryTracker

                                  type MemoryTracker interface {
                                  	// IncNumLoadedBytes increments the number of bytes that have been loaded
                                  	// into memory via the "Load()" API.
                                  	IncNumLoadedBytes(x int64) (okToLoad bool)
                                  
                                  	// NumLoadedBytes returns the number of bytes that have been loaded into memory via the
                                  	// "Load()" API.
                                  	NumLoadedBytes() int64
                                  
                                  	// MarkLoadedAsPending marks the current number of loaded bytes as pending
                                  	// so that a subsequent call to DecPendingLoadedBytes() will decrement the
                                  	// number of loaded bytes by the number that was set when this function was
                                  	// last executed.
                                  	MarkLoadedAsPending()
                                  
                                  	// DecPendingLoadedBytes decrements the number of loaded bytes by the number
                                  	// of pending bytes that were captured by the last call to MarkLoadedAsPending().
                                  	DecPendingLoadedBytes()
                                  
                                  	// WaitForDec waits for the next call to DecPendingLoadedBytes before returning.
                                  	WaitForDec()
                                  }

                                    MemoryTracker tracks memory.

                                    func NewMemoryTracker

                                    func NewMemoryTracker(opts MemoryTrackerOptions) MemoryTracker

                                      NewMemoryTracker creates a new MemoryTracker.

                                      type MemoryTrackerOptions

                                      type MemoryTrackerOptions struct {
                                      	// contains filtered or unexported fields
                                      }

                                        MemoryTrackerOptions are the options for the MemoryTracker.

                                        func NewMemoryTrackerOptions

                                        func NewMemoryTrackerOptions(numLoadedBytesLimit int64) MemoryTrackerOptions

                                          NewMemoryTrackerOptions creates a new MemoryTrackerOptions.

                                          type MockBackgroundProcess

                                          type MockBackgroundProcess struct {
                                          	// contains filtered or unexported fields
                                          }

                                            MockBackgroundProcess is a mock of BackgroundProcess interface

                                            func NewMockBackgroundProcess

                                            func NewMockBackgroundProcess(ctrl *gomock.Controller) *MockBackgroundProcess

                                              NewMockBackgroundProcess creates a new mock instance

                                              func (*MockBackgroundProcess) EXPECT

                                                EXPECT returns an object that allows the caller to indicate expected use

                                                func (*MockBackgroundProcess) Report

                                                func (m *MockBackgroundProcess) Report()

                                                  Report mocks base method

                                                  func (*MockBackgroundProcess) Start

                                                  func (m *MockBackgroundProcess) Start()

                                                    Start mocks base method

                                                    func (*MockBackgroundProcess) Stop

                                                    func (m *MockBackgroundProcess) Stop()

                                                      Stop mocks base method

                                                      type MockBackgroundProcessMockRecorder

                                                      type MockBackgroundProcessMockRecorder struct {
                                                      	// contains filtered or unexported fields
                                                      }

                                                        MockBackgroundProcessMockRecorder is the mock recorder for MockBackgroundProcess

                                                        func (*MockBackgroundProcessMockRecorder) Report

                                                          Report indicates an expected call of Report

                                                          func (*MockBackgroundProcessMockRecorder) Start

                                                            Start indicates an expected call of Start

                                                            func (*MockBackgroundProcessMockRecorder) Stop

                                                              Stop indicates an expected call of Stop

                                                              type MockDatabase

                                                              type MockDatabase struct {
                                                              	// contains filtered or unexported fields
                                                              }

                                                                MockDatabase is a mock of Database interface

                                                                func NewMockDatabase

                                                                func NewMockDatabase(ctrl *gomock.Controller) *MockDatabase

                                                                  NewMockDatabase creates a new mock instance

                                                                  func (*MockDatabase) AggregateQuery

                                                                  func (m *MockDatabase) AggregateQuery(ctx context.Context, namespace ident.ID, query index.Query, opts index.AggregationOptions) (index.AggregateQueryResult, error)

                                                                    AggregateQuery mocks base method

                                                                    func (*MockDatabase) AggregateTiles

                                                                    func (m *MockDatabase) AggregateTiles(ctx context.Context, sourceNsID, targetNsID ident.ID, opts AggregateTilesOptions) (int64, error)

                                                                      AggregateTiles mocks base method

                                                                      func (*MockDatabase) AssignShardSet

                                                                      func (m *MockDatabase) AssignShardSet(shardSet sharding.ShardSet)

                                                                        AssignShardSet mocks base method

                                                                        func (*MockDatabase) BatchProcessWideQuery

                                                                        func (m *MockDatabase) BatchProcessWideQuery(ctx context.Context, n Namespace, query index.Query, batchProcessor IDBatchProcessor, opts index.WideQueryOptions) error

                                                                          BatchProcessWideQuery mocks base method

                                                                          func (*MockDatabase) BatchWriter

                                                                          func (m *MockDatabase) BatchWriter(namespace ident.ID, batchSize int) (writes.BatchWriter, error)

                                                                            BatchWriter mocks base method

                                                                            func (*MockDatabase) Bootstrap

                                                                            func (m *MockDatabase) Bootstrap() error

                                                                              Bootstrap mocks base method

                                                                              func (*MockDatabase) BootstrapState

                                                                              func (m *MockDatabase) BootstrapState() DatabaseBootstrapState

                                                                                BootstrapState mocks base method

                                                                                func (*MockDatabase) Close

                                                                                func (m *MockDatabase) Close() error

                                                                                  Close mocks base method

                                                                                  func (*MockDatabase) EXPECT

                                                                                    EXPECT returns an object that allows the caller to indicate expected use

                                                                                    func (*MockDatabase) FetchBlocks

                                                                                    func (m *MockDatabase) FetchBlocks(ctx context.Context, namespace ident.ID, shard uint32, id ident.ID, starts []time.Time) ([]block.FetchBlockResult, error)

                                                                                      FetchBlocks mocks base method

                                                                                      func (*MockDatabase) FetchBlocksMetadataV2

                                                                                      func (m *MockDatabase) FetchBlocksMetadataV2(ctx context.Context, namespace ident.ID, shard uint32, start, end time.Time, limit int64, pageToken PageToken, opts block.FetchBlocksMetadataOptions) (block.FetchBlocksMetadataResults, PageToken, error)

                                                                                        FetchBlocksMetadataV2 mocks base method

                                                                                        func (*MockDatabase) FlushState

                                                                                        func (m *MockDatabase) FlushState(namespace ident.ID, shardID uint32, blockStart time.Time) (fileOpState, error)

                                                                                          FlushState mocks base method

                                                                                          func (*MockDatabase) IsBootstrapped

                                                                                          func (m *MockDatabase) IsBootstrapped() bool

                                                                                            IsBootstrapped mocks base method

                                                                                            func (*MockDatabase) IsBootstrappedAndDurable

                                                                                            func (m *MockDatabase) IsBootstrappedAndDurable() bool

                                                                                              IsBootstrappedAndDurable mocks base method

                                                                                              func (*MockDatabase) IsOverloaded

                                                                                              func (m *MockDatabase) IsOverloaded() bool

                                                                                                IsOverloaded mocks base method

                                                                                                func (*MockDatabase) Namespace

                                                                                                func (m *MockDatabase) Namespace(ns ident.ID) (Namespace, bool)

                                                                                                  Namespace mocks base method

                                                                                                  func (*MockDatabase) Namespaces

                                                                                                  func (m *MockDatabase) Namespaces() []Namespace

                                                                                                    Namespaces mocks base method

                                                                                                    func (*MockDatabase) Open

                                                                                                    func (m *MockDatabase) Open() error

                                                                                                      Open mocks base method

                                                                                                      func (*MockDatabase) Options

                                                                                                      func (m *MockDatabase) Options() Options

                                                                                                        Options mocks base method

                                                                                                        func (*MockDatabase) QueryIDs

                                                                                                        func (m *MockDatabase) QueryIDs(ctx context.Context, namespace ident.ID, query index.Query, opts index.QueryOptions) (index.QueryResult, error)

                                                                                                          QueryIDs mocks base method

                                                                                                          func (*MockDatabase) ReadEncoded

                                                                                                          func (m *MockDatabase) ReadEncoded(ctx context.Context, namespace, id ident.ID, start, end time.Time) ([][]xio.BlockReader, error)

                                                                                                            ReadEncoded mocks base method

                                                                                                            func (*MockDatabase) Repair

                                                                                                            func (m *MockDatabase) Repair() error

                                                                                                              Repair mocks base method

                                                                                                              func (*MockDatabase) ShardSet

                                                                                                              func (m *MockDatabase) ShardSet() sharding.ShardSet

                                                                                                                ShardSet mocks base method

                                                                                                                func (*MockDatabase) Terminate

                                                                                                                func (m *MockDatabase) Terminate() error

                                                                                                                  Terminate mocks base method

                                                                                                                  func (*MockDatabase) Truncate

                                                                                                                  func (m *MockDatabase) Truncate(namespace ident.ID) (int64, error)

                                                                                                                    Truncate mocks base method

                                                                                                                    func (*MockDatabase) WideQuery

                                                                                                                    func (m *MockDatabase) WideQuery(ctx context.Context, namespace ident.ID, query index.Query, start time.Time, shards []uint32, iterOpts index.IterationOptions) ([]xio.WideEntry, error)

                                                                                                                      WideQuery mocks base method

                                                                                                                      func (*MockDatabase) Write

                                                                                                                      func (m *MockDatabase) Write(ctx context.Context, namespace, id ident.ID, timestamp time.Time, value float64, unit time0.Unit, annotation []byte) error

                                                                                                                        Write mocks base method

                                                                                                                        func (*MockDatabase) WriteBatch

                                                                                                                        func (m *MockDatabase) WriteBatch(ctx context.Context, namespace ident.ID, writes writes.BatchWriter, errHandler IndexedErrorHandler) error

                                                                                                                          WriteBatch mocks base method

                                                                                                                          func (*MockDatabase) WriteTagged

                                                                                                                          func (m *MockDatabase) WriteTagged(ctx context.Context, namespace, id ident.ID, tags ident.TagIterator, timestamp time.Time, value float64, unit time0.Unit, annotation []byte) error

                                                                                                                            WriteTagged mocks base method

                                                                                                                            func (*MockDatabase) WriteTaggedBatch

                                                                                                                            func (m *MockDatabase) WriteTaggedBatch(ctx context.Context, namespace ident.ID, writes writes.BatchWriter, errHandler IndexedErrorHandler) error

                                                                                                                              WriteTaggedBatch mocks base method

                                                                                                                              type MockDatabaseMockRecorder

                                                                                                                              type MockDatabaseMockRecorder struct {
                                                                                                                              	// contains filtered or unexported fields
                                                                                                                              }

                                                                                                                                MockDatabaseMockRecorder is the mock recorder for MockDatabase

                                                                                                                                func (*MockDatabaseMockRecorder) AggregateQuery

                                                                                                                                func (mr *MockDatabaseMockRecorder) AggregateQuery(ctx, namespace, query, opts interface{}) *gomock.Call

                                                                                                                                  AggregateQuery indicates an expected call of AggregateQuery

                                                                                                                                  func (*MockDatabaseMockRecorder) AggregateTiles

                                                                                                                                  func (mr *MockDatabaseMockRecorder) AggregateTiles(ctx, sourceNsID, targetNsID, opts interface{}) *gomock.Call

                                                                                                                                    AggregateTiles indicates an expected call of AggregateTiles

                                                                                                                                    func (*MockDatabaseMockRecorder) AssignShardSet

                                                                                                                                    func (mr *MockDatabaseMockRecorder) AssignShardSet(shardSet interface{}) *gomock.Call

                                                                                                                                      AssignShardSet indicates an expected call of AssignShardSet

                                                                                                                                      func (*MockDatabaseMockRecorder) BatchProcessWideQuery

                                                                                                                                      func (mr *MockDatabaseMockRecorder) BatchProcessWideQuery(ctx, n, query, batchProcessor, opts interface{}) *gomock.Call

                                                                                                                                        BatchProcessWideQuery indicates an expected call of BatchProcessWideQuery

                                                                                                                                        func (*MockDatabaseMockRecorder) BatchWriter

                                                                                                                                        func (mr *MockDatabaseMockRecorder) BatchWriter(namespace, batchSize interface{}) *gomock.Call

                                                                                                                                          BatchWriter indicates an expected call of BatchWriter

                                                                                                                                          func (*MockDatabaseMockRecorder) Bootstrap

                                                                                                                                          func (mr *MockDatabaseMockRecorder) Bootstrap() *gomock.Call

                                                                                                                                            Bootstrap indicates an expected call of Bootstrap

                                                                                                                                            func (*MockDatabaseMockRecorder) BootstrapState

                                                                                                                                            func (mr *MockDatabaseMockRecorder) BootstrapState() *gomock.Call

                                                                                                                                              BootstrapState indicates an expected call of BootstrapState

                                                                                                                                              func (*MockDatabaseMockRecorder) Close

                                                                                                                                              func (mr *MockDatabaseMockRecorder) Close() *gomock.Call

                                                                                                                                                Close indicates an expected call of Close

                                                                                                                                                func (*MockDatabaseMockRecorder) FetchBlocks

                                                                                                                                                func (mr *MockDatabaseMockRecorder) FetchBlocks(ctx, namespace, shard, id, starts interface{}) *gomock.Call

                                                                                                                                                  FetchBlocks indicates an expected call of FetchBlocks

                                                                                                                                                  func (*MockDatabaseMockRecorder) FetchBlocksMetadataV2

                                                                                                                                                  func (mr *MockDatabaseMockRecorder) FetchBlocksMetadataV2(ctx, namespace, shard, start, end, limit, pageToken, opts interface{}) *gomock.Call

                                                                                                                                                    FetchBlocksMetadataV2 indicates an expected call of FetchBlocksMetadataV2

                                                                                                                                                    func (*MockDatabaseMockRecorder) FlushState

                                                                                                                                                    func (mr *MockDatabaseMockRecorder) FlushState(namespace, shardID, blockStart interface{}) *gomock.Call

                                                                                                                                                      FlushState indicates an expected call of FlushState

                                                                                                                                                      func (*MockDatabaseMockRecorder) IsBootstrapped

                                                                                                                                                      func (mr *MockDatabaseMockRecorder) IsBootstrapped() *gomock.Call

                                                                                                                                                        IsBootstrapped indicates an expected call of IsBootstrapped

                                                                                                                                                        func (*MockDatabaseMockRecorder) IsBootstrappedAndDurable

                                                                                                                                                        func (mr *MockDatabaseMockRecorder) IsBootstrappedAndDurable() *gomock.Call

                                                                                                                                                          IsBootstrappedAndDurable indicates an expected call of IsBootstrappedAndDurable

                                                                                                                                                          func (*MockDatabaseMockRecorder) IsOverloaded

                                                                                                                                                          func (mr *MockDatabaseMockRecorder) IsOverloaded() *gomock.Call

                                                                                                                                                            IsOverloaded indicates an expected call of IsOverloaded

                                                                                                                                                            func (*MockDatabaseMockRecorder) Namespace

                                                                                                                                                            func (mr *MockDatabaseMockRecorder) Namespace(ns interface{}) *gomock.Call

                                                                                                                                                              Namespace indicates an expected call of Namespace

                                                                                                                                                              func (*MockDatabaseMockRecorder) Namespaces

                                                                                                                                                              func (mr *MockDatabaseMockRecorder) Namespaces() *gomock.Call

                                                                                                                                                                Namespaces indicates an expected call of Namespaces

                                                                                                                                                                func (*MockDatabaseMockRecorder) Open

                                                                                                                                                                func (mr *MockDatabaseMockRecorder) Open() *gomock.Call

                                                                                                                                                                  Open indicates an expected call of Open

                                                                                                                                                                  func (*MockDatabaseMockRecorder) Options

                                                                                                                                                                  func (mr *MockDatabaseMockRecorder) Options() *gomock.Call

                                                                                                                                                                    Options indicates an expected call of Options

                                                                                                                                                                    func (*MockDatabaseMockRecorder) QueryIDs

                                                                                                                                                                    func (mr *MockDatabaseMockRecorder) QueryIDs(ctx, namespace, query, opts interface{}) *gomock.Call

                                                                                                                                                                      QueryIDs indicates an expected call of QueryIDs

                                                                                                                                                                      func (*MockDatabaseMockRecorder) ReadEncoded

                                                                                                                                                                      func (mr *MockDatabaseMockRecorder) ReadEncoded(ctx, namespace, id, start, end interface{}) *gomock.Call

                                                                                                                                                                        ReadEncoded indicates an expected call of ReadEncoded

                                                                                                                                                                        func (*MockDatabaseMockRecorder) Repair

                                                                                                                                                                        func (mr *MockDatabaseMockRecorder) Repair() *gomock.Call

                                                                                                                                                                          Repair indicates an expected call of Repair

                                                                                                                                                                          func (*MockDatabaseMockRecorder) ShardSet

                                                                                                                                                                          func (mr *MockDatabaseMockRecorder) ShardSet() *gomock.Call

                                                                                                                                                                            ShardSet indicates an expected call of ShardSet

                                                                                                                                                                            func (*MockDatabaseMockRecorder) Terminate

                                                                                                                                                                            func (mr *MockDatabaseMockRecorder) Terminate() *gomock.Call

                                                                                                                                                                              Terminate indicates an expected call of Terminate

                                                                                                                                                                              func (*MockDatabaseMockRecorder) Truncate

                                                                                                                                                                              func (mr *MockDatabaseMockRecorder) Truncate(namespace interface{}) *gomock.Call

                                                                                                                                                                                Truncate indicates an expected call of Truncate

                                                                                                                                                                                func (*MockDatabaseMockRecorder) WideQuery

                                                                                                                                                                                func (mr *MockDatabaseMockRecorder) WideQuery(ctx, namespace, query, start, shards, iterOpts interface{}) *gomock.Call

                                                                                                                                                                                  WideQuery indicates an expected call of WideQuery

                                                                                                                                                                                  func (*MockDatabaseMockRecorder) Write

                                                                                                                                                                                  func (mr *MockDatabaseMockRecorder) Write(ctx, namespace, id, timestamp, value, unit, annotation interface{}) *gomock.Call

                                                                                                                                                                                    Write indicates an expected call of Write

                                                                                                                                                                                    func (*MockDatabaseMockRecorder) WriteBatch

                                                                                                                                                                                    func (mr *MockDatabaseMockRecorder) WriteBatch(ctx, namespace, writes, errHandler interface{}) *gomock.Call

                                                                                                                                                                                      WriteBatch indicates an expected call of WriteBatch

                                                                                                                                                                                      func (*MockDatabaseMockRecorder) WriteTagged

                                                                                                                                                                                      func (mr *MockDatabaseMockRecorder) WriteTagged(ctx, namespace, id, tags, timestamp, value, unit, annotation interface{}) *gomock.Call

                                                                                                                                                                                        WriteTagged indicates an expected call of WriteTagged

                                                                                                                                                                                        func (*MockDatabaseMockRecorder) WriteTaggedBatch

                                                                                                                                                                                        func (mr *MockDatabaseMockRecorder) WriteTaggedBatch(ctx, namespace, writes, errHandler interface{}) *gomock.Call

                                                                                                                                                                                          WriteTaggedBatch indicates an expected call of WriteTaggedBatch

                                                                                                                                                                                          type MockIndexedErrorHandler

                                                                                                                                                                                          type MockIndexedErrorHandler struct {
                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                          }

                                                                                                                                                                                            MockIndexedErrorHandler is a mock of IndexedErrorHandler interface

                                                                                                                                                                                            func NewMockIndexedErrorHandler

                                                                                                                                                                                            func NewMockIndexedErrorHandler(ctrl *gomock.Controller) *MockIndexedErrorHandler

                                                                                                                                                                                              NewMockIndexedErrorHandler creates a new mock instance

                                                                                                                                                                                              func (*MockIndexedErrorHandler) EXPECT

                                                                                                                                                                                                EXPECT returns an object that allows the caller to indicate expected use

                                                                                                                                                                                                func (*MockIndexedErrorHandler) HandleError

                                                                                                                                                                                                func (m *MockIndexedErrorHandler) HandleError(index int, err error)

                                                                                                                                                                                                  HandleError mocks base method

                                                                                                                                                                                                  type MockIndexedErrorHandlerMockRecorder

                                                                                                                                                                                                  type MockIndexedErrorHandlerMockRecorder struct {
                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                  }

                                                                                                                                                                                                    MockIndexedErrorHandlerMockRecorder is the mock recorder for MockIndexedErrorHandler

                                                                                                                                                                                                    func (*MockIndexedErrorHandlerMockRecorder) HandleError

                                                                                                                                                                                                    func (mr *MockIndexedErrorHandlerMockRecorder) HandleError(index, err interface{}) *gomock.Call

                                                                                                                                                                                                      HandleError indicates an expected call of HandleError

                                                                                                                                                                                                      type MockMemoryTracker

                                                                                                                                                                                                      type MockMemoryTracker struct {
                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                      }

                                                                                                                                                                                                        MockMemoryTracker is a mock of MemoryTracker interface

                                                                                                                                                                                                        func NewMockMemoryTracker

                                                                                                                                                                                                        func NewMockMemoryTracker(ctrl *gomock.Controller) *MockMemoryTracker

                                                                                                                                                                                                          NewMockMemoryTracker creates a new mock instance

                                                                                                                                                                                                          func (*MockMemoryTracker) DecPendingLoadedBytes

                                                                                                                                                                                                          func (m *MockMemoryTracker) DecPendingLoadedBytes()

                                                                                                                                                                                                            DecPendingLoadedBytes mocks base method

                                                                                                                                                                                                            func (*MockMemoryTracker) EXPECT

                                                                                                                                                                                                              EXPECT returns an object that allows the caller to indicate expected use

                                                                                                                                                                                                              func (*MockMemoryTracker) IncNumLoadedBytes

                                                                                                                                                                                                              func (m *MockMemoryTracker) IncNumLoadedBytes(x int64) bool

                                                                                                                                                                                                                IncNumLoadedBytes mocks base method

                                                                                                                                                                                                                func (*MockMemoryTracker) MarkLoadedAsPending

                                                                                                                                                                                                                func (m *MockMemoryTracker) MarkLoadedAsPending()

                                                                                                                                                                                                                  MarkLoadedAsPending mocks base method

                                                                                                                                                                                                                  func (*MockMemoryTracker) NumLoadedBytes

                                                                                                                                                                                                                  func (m *MockMemoryTracker) NumLoadedBytes() int64

                                                                                                                                                                                                                    NumLoadedBytes mocks base method

                                                                                                                                                                                                                    func (*MockMemoryTracker) WaitForDec

                                                                                                                                                                                                                    func (m *MockMemoryTracker) WaitForDec()

                                                                                                                                                                                                                      WaitForDec mocks base method

                                                                                                                                                                                                                      type MockMemoryTrackerMockRecorder

                                                                                                                                                                                                                      type MockMemoryTrackerMockRecorder struct {
                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                      }

                                                                                                                                                                                                                        MockMemoryTrackerMockRecorder is the mock recorder for MockMemoryTracker

                                                                                                                                                                                                                        func (*MockMemoryTrackerMockRecorder) DecPendingLoadedBytes

                                                                                                                                                                                                                        func (mr *MockMemoryTrackerMockRecorder) DecPendingLoadedBytes() *gomock.Call

                                                                                                                                                                                                                          DecPendingLoadedBytes indicates an expected call of DecPendingLoadedBytes

                                                                                                                                                                                                                          func (*MockMemoryTrackerMockRecorder) IncNumLoadedBytes

                                                                                                                                                                                                                          func (mr *MockMemoryTrackerMockRecorder) IncNumLoadedBytes(x interface{}) *gomock.Call

                                                                                                                                                                                                                            IncNumLoadedBytes indicates an expected call of IncNumLoadedBytes

                                                                                                                                                                                                                            func (*MockMemoryTrackerMockRecorder) MarkLoadedAsPending

                                                                                                                                                                                                                            func (mr *MockMemoryTrackerMockRecorder) MarkLoadedAsPending() *gomock.Call

                                                                                                                                                                                                                              MarkLoadedAsPending indicates an expected call of MarkLoadedAsPending

                                                                                                                                                                                                                              func (*MockMemoryTrackerMockRecorder) NumLoadedBytes

                                                                                                                                                                                                                              func (mr *MockMemoryTrackerMockRecorder) NumLoadedBytes() *gomock.Call

                                                                                                                                                                                                                                NumLoadedBytes indicates an expected call of NumLoadedBytes

                                                                                                                                                                                                                                func (*MockMemoryTrackerMockRecorder) WaitForDec

                                                                                                                                                                                                                                func (mr *MockMemoryTrackerMockRecorder) WaitForDec() *gomock.Call

                                                                                                                                                                                                                                  WaitForDec indicates an expected call of WaitForDec

                                                                                                                                                                                                                                  type MockNamespace

                                                                                                                                                                                                                                  type MockNamespace struct {
                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                    MockNamespace is a mock of Namespace interface

                                                                                                                                                                                                                                    func NewMockNamespace

                                                                                                                                                                                                                                    func NewMockNamespace(ctrl *gomock.Controller) *MockNamespace

                                                                                                                                                                                                                                      NewMockNamespace creates a new mock instance

                                                                                                                                                                                                                                      func (*MockNamespace) DocRef

                                                                                                                                                                                                                                      func (m *MockNamespace) DocRef(id ident.ID) (doc.Document, bool, error)

                                                                                                                                                                                                                                        DocRef mocks base method

                                                                                                                                                                                                                                        func (*MockNamespace) EXPECT

                                                                                                                                                                                                                                          EXPECT returns an object that allows the caller to indicate expected use

                                                                                                                                                                                                                                          func (*MockNamespace) FetchWideEntry

                                                                                                                                                                                                                                          func (m *MockNamespace) FetchWideEntry(ctx context.Context, id ident.ID, blockStart time.Time, filter schema.WideEntryFilter) (block.StreamedWideEntry, error)

                                                                                                                                                                                                                                            FetchWideEntry mocks base method

                                                                                                                                                                                                                                            func (*MockNamespace) ID

                                                                                                                                                                                                                                            func (m *MockNamespace) ID() ident.ID

                                                                                                                                                                                                                                              ID mocks base method

                                                                                                                                                                                                                                              func (*MockNamespace) Index

                                                                                                                                                                                                                                              func (m *MockNamespace) Index() (NamespaceIndex, error)

                                                                                                                                                                                                                                                Index mocks base method

                                                                                                                                                                                                                                                func (*MockNamespace) Metadata

                                                                                                                                                                                                                                                func (m *MockNamespace) Metadata() namespace.Metadata

                                                                                                                                                                                                                                                  Metadata mocks base method

                                                                                                                                                                                                                                                  func (*MockNamespace) NumSeries

                                                                                                                                                                                                                                                  func (m *MockNamespace) NumSeries() int64

                                                                                                                                                                                                                                                    NumSeries mocks base method

                                                                                                                                                                                                                                                    func (*MockNamespace) Options

                                                                                                                                                                                                                                                    func (m *MockNamespace) Options() namespace.Options

                                                                                                                                                                                                                                                      Options mocks base method

                                                                                                                                                                                                                                                      func (*MockNamespace) ReadOnly

                                                                                                                                                                                                                                                      func (m *MockNamespace) ReadOnly() bool

                                                                                                                                                                                                                                                        ReadOnly mocks base method

                                                                                                                                                                                                                                                        func (*MockNamespace) Schema

                                                                                                                                                                                                                                                        func (m *MockNamespace) Schema() namespace.SchemaDescr

                                                                                                                                                                                                                                                          Schema mocks base method

                                                                                                                                                                                                                                                          func (*MockNamespace) SetIndex

                                                                                                                                                                                                                                                          func (m *MockNamespace) SetIndex(reverseIndex NamespaceIndex) error

                                                                                                                                                                                                                                                            SetIndex mocks base method

                                                                                                                                                                                                                                                            func (*MockNamespace) SetReadOnly

                                                                                                                                                                                                                                                            func (m *MockNamespace) SetReadOnly(value bool)

                                                                                                                                                                                                                                                              SetReadOnly mocks base method

                                                                                                                                                                                                                                                              func (*MockNamespace) Shards

                                                                                                                                                                                                                                                              func (m *MockNamespace) Shards() []Shard

                                                                                                                                                                                                                                                                Shards mocks base method

                                                                                                                                                                                                                                                                func (*MockNamespace) StorageOptions

                                                                                                                                                                                                                                                                func (m *MockNamespace) StorageOptions() Options

                                                                                                                                                                                                                                                                  StorageOptions mocks base method

                                                                                                                                                                                                                                                                  func (*MockNamespace) WideQueryIDs

                                                                                                                                                                                                                                                                  func (m *MockNamespace) WideQueryIDs(ctx context.Context, query index.Query, collector chan *ident.IDBatch, opts index.WideQueryOptions) error

                                                                                                                                                                                                                                                                    WideQueryIDs mocks base method

                                                                                                                                                                                                                                                                    type MockNamespaceHooks

                                                                                                                                                                                                                                                                    type MockNamespaceHooks struct {
                                                                                                                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                      MockNamespaceHooks is a mock of NamespaceHooks interface

                                                                                                                                                                                                                                                                      func NewMockNamespaceHooks

                                                                                                                                                                                                                                                                      func NewMockNamespaceHooks(ctrl *gomock.Controller) *MockNamespaceHooks

                                                                                                                                                                                                                                                                        NewMockNamespaceHooks creates a new mock instance

                                                                                                                                                                                                                                                                        func (*MockNamespaceHooks) EXPECT

                                                                                                                                                                                                                                                                          EXPECT returns an object that allows the caller to indicate expected use

                                                                                                                                                                                                                                                                          func (*MockNamespaceHooks) OnCreatedNamespace

                                                                                                                                                                                                                                                                          func (m *MockNamespaceHooks) OnCreatedNamespace(arg0 Namespace, arg1 GetNamespaceFn) error

                                                                                                                                                                                                                                                                            OnCreatedNamespace mocks base method

                                                                                                                                                                                                                                                                            type MockNamespaceHooksMockRecorder

                                                                                                                                                                                                                                                                            type MockNamespaceHooksMockRecorder struct {
                                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                              MockNamespaceHooksMockRecorder is the mock recorder for MockNamespaceHooks

                                                                                                                                                                                                                                                                              func (*MockNamespaceHooksMockRecorder) OnCreatedNamespace

                                                                                                                                                                                                                                                                              func (mr *MockNamespaceHooksMockRecorder) OnCreatedNamespace(arg0, arg1 interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                OnCreatedNamespace indicates an expected call of OnCreatedNamespace

                                                                                                                                                                                                                                                                                type MockNamespaceIndex

                                                                                                                                                                                                                                                                                type MockNamespaceIndex struct {
                                                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                  MockNamespaceIndex is a mock of NamespaceIndex interface

                                                                                                                                                                                                                                                                                  func NewMockNamespaceIndex

                                                                                                                                                                                                                                                                                  func NewMockNamespaceIndex(ctrl *gomock.Controller) *MockNamespaceIndex

                                                                                                                                                                                                                                                                                    NewMockNamespaceIndex creates a new mock instance

                                                                                                                                                                                                                                                                                    func (*MockNamespaceIndex) AggregateQuery

                                                                                                                                                                                                                                                                                      AggregateQuery mocks base method

                                                                                                                                                                                                                                                                                      func (*MockNamespaceIndex) AssignShardSet

                                                                                                                                                                                                                                                                                      func (m *MockNamespaceIndex) AssignShardSet(shardSet sharding.ShardSet)

                                                                                                                                                                                                                                                                                        AssignShardSet mocks base method

                                                                                                                                                                                                                                                                                        func (*MockNamespaceIndex) BlockForBlockStart

                                                                                                                                                                                                                                                                                        func (m *MockNamespaceIndex) BlockForBlockStart(blockStart time.Time) (index.Block, error)

                                                                                                                                                                                                                                                                                          BlockForBlockStart mocks base method

                                                                                                                                                                                                                                                                                          func (*MockNamespaceIndex) BlockStartForWriteTime

                                                                                                                                                                                                                                                                                          func (m *MockNamespaceIndex) BlockStartForWriteTime(writeTime time.Time) time0.UnixNano

                                                                                                                                                                                                                                                                                            BlockStartForWriteTime mocks base method

                                                                                                                                                                                                                                                                                            func (*MockNamespaceIndex) Bootstrap

                                                                                                                                                                                                                                                                                            func (m *MockNamespaceIndex) Bootstrap(bootstrapResults result.IndexResults) error

                                                                                                                                                                                                                                                                                              Bootstrap mocks base method

                                                                                                                                                                                                                                                                                              func (*MockNamespaceIndex) Bootstrapped

                                                                                                                                                                                                                                                                                              func (m *MockNamespaceIndex) Bootstrapped() bool

                                                                                                                                                                                                                                                                                                Bootstrapped mocks base method

                                                                                                                                                                                                                                                                                                func (*MockNamespaceIndex) CleanupDuplicateFileSets

                                                                                                                                                                                                                                                                                                func (m *MockNamespaceIndex) CleanupDuplicateFileSets() error

                                                                                                                                                                                                                                                                                                  CleanupDuplicateFileSets mocks base method

                                                                                                                                                                                                                                                                                                  func (*MockNamespaceIndex) CleanupExpiredFileSets

                                                                                                                                                                                                                                                                                                  func (m *MockNamespaceIndex) CleanupExpiredFileSets(t time.Time) error

                                                                                                                                                                                                                                                                                                    CleanupExpiredFileSets mocks base method

                                                                                                                                                                                                                                                                                                    func (*MockNamespaceIndex) Close

                                                                                                                                                                                                                                                                                                    func (m *MockNamespaceIndex) Close() error

                                                                                                                                                                                                                                                                                                      Close mocks base method

                                                                                                                                                                                                                                                                                                      func (*MockNamespaceIndex) ColdFlush

                                                                                                                                                                                                                                                                                                      func (m *MockNamespaceIndex) ColdFlush(shards []databaseShard) (OnColdFlushDone, error)

                                                                                                                                                                                                                                                                                                        ColdFlush mocks base method

                                                                                                                                                                                                                                                                                                        func (*MockNamespaceIndex) DebugMemorySegments

                                                                                                                                                                                                                                                                                                        func (m *MockNamespaceIndex) DebugMemorySegments(opts DebugMemorySegmentsOptions) error

                                                                                                                                                                                                                                                                                                          DebugMemorySegments mocks base method

                                                                                                                                                                                                                                                                                                          func (*MockNamespaceIndex) EXPECT

                                                                                                                                                                                                                                                                                                            EXPECT returns an object that allows the caller to indicate expected use

                                                                                                                                                                                                                                                                                                            func (*MockNamespaceIndex) Query

                                                                                                                                                                                                                                                                                                              Query mocks base method

                                                                                                                                                                                                                                                                                                              func (*MockNamespaceIndex) SetExtendedRetentionPeriod

                                                                                                                                                                                                                                                                                                              func (m *MockNamespaceIndex) SetExtendedRetentionPeriod(period time.Duration)

                                                                                                                                                                                                                                                                                                                SetExtendedRetentionPeriod mocks base method

                                                                                                                                                                                                                                                                                                                func (*MockNamespaceIndex) Tick

                                                                                                                                                                                                                                                                                                                func (m *MockNamespaceIndex) Tick(c context.Cancellable, startTime time.Time) (namespaceIndexTickResult, error)

                                                                                                                                                                                                                                                                                                                  Tick mocks base method

                                                                                                                                                                                                                                                                                                                  func (*MockNamespaceIndex) WarmFlush

                                                                                                                                                                                                                                                                                                                  func (m *MockNamespaceIndex) WarmFlush(flush persist.IndexFlush, shards []databaseShard) error

                                                                                                                                                                                                                                                                                                                    WarmFlush mocks base method

                                                                                                                                                                                                                                                                                                                    func (*MockNamespaceIndex) WideQuery

                                                                                                                                                                                                                                                                                                                    func (m *MockNamespaceIndex) WideQuery(ctx context.Context, query index.Query, collector chan *ident.IDBatch, opts index.WideQueryOptions) error

                                                                                                                                                                                                                                                                                                                      WideQuery mocks base method

                                                                                                                                                                                                                                                                                                                      func (*MockNamespaceIndex) WriteBatch

                                                                                                                                                                                                                                                                                                                      func (m *MockNamespaceIndex) WriteBatch(batch *index.WriteBatch) error

                                                                                                                                                                                                                                                                                                                        WriteBatch mocks base method

                                                                                                                                                                                                                                                                                                                        func (*MockNamespaceIndex) WritePending

                                                                                                                                                                                                                                                                                                                        func (m *MockNamespaceIndex) WritePending(pending []writes.PendingIndexInsert) error

                                                                                                                                                                                                                                                                                                                          WritePending mocks base method

                                                                                                                                                                                                                                                                                                                          type MockNamespaceIndexMockRecorder

                                                                                                                                                                                                                                                                                                                          type MockNamespaceIndexMockRecorder struct {
                                                                                                                                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                            MockNamespaceIndexMockRecorder is the mock recorder for MockNamespaceIndex

                                                                                                                                                                                                                                                                                                                            func (*MockNamespaceIndexMockRecorder) AggregateQuery

                                                                                                                                                                                                                                                                                                                            func (mr *MockNamespaceIndexMockRecorder) AggregateQuery(ctx, query, opts interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                              AggregateQuery indicates an expected call of AggregateQuery

                                                                                                                                                                                                                                                                                                                              func (*MockNamespaceIndexMockRecorder) AssignShardSet

                                                                                                                                                                                                                                                                                                                              func (mr *MockNamespaceIndexMockRecorder) AssignShardSet(shardSet interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                AssignShardSet indicates an expected call of AssignShardSet

                                                                                                                                                                                                                                                                                                                                func (*MockNamespaceIndexMockRecorder) BlockForBlockStart

                                                                                                                                                                                                                                                                                                                                func (mr *MockNamespaceIndexMockRecorder) BlockForBlockStart(blockStart interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                  BlockForBlockStart indicates an expected call of BlockForBlockStart

                                                                                                                                                                                                                                                                                                                                  func (*MockNamespaceIndexMockRecorder) BlockStartForWriteTime

                                                                                                                                                                                                                                                                                                                                  func (mr *MockNamespaceIndexMockRecorder) BlockStartForWriteTime(writeTime interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                    BlockStartForWriteTime indicates an expected call of BlockStartForWriteTime

                                                                                                                                                                                                                                                                                                                                    func (*MockNamespaceIndexMockRecorder) Bootstrap

                                                                                                                                                                                                                                                                                                                                    func (mr *MockNamespaceIndexMockRecorder) Bootstrap(bootstrapResults interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                      Bootstrap indicates an expected call of Bootstrap

                                                                                                                                                                                                                                                                                                                                      func (*MockNamespaceIndexMockRecorder) Bootstrapped

                                                                                                                                                                                                                                                                                                                                      func (mr *MockNamespaceIndexMockRecorder) Bootstrapped() *gomock.Call

                                                                                                                                                                                                                                                                                                                                        Bootstrapped indicates an expected call of Bootstrapped

                                                                                                                                                                                                                                                                                                                                        func (*MockNamespaceIndexMockRecorder) CleanupDuplicateFileSets

                                                                                                                                                                                                                                                                                                                                        func (mr *MockNamespaceIndexMockRecorder) CleanupDuplicateFileSets() *gomock.Call

                                                                                                                                                                                                                                                                                                                                          CleanupDuplicateFileSets indicates an expected call of CleanupDuplicateFileSets

                                                                                                                                                                                                                                                                                                                                          func (*MockNamespaceIndexMockRecorder) CleanupExpiredFileSets

                                                                                                                                                                                                                                                                                                                                          func (mr *MockNamespaceIndexMockRecorder) CleanupExpiredFileSets(t interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                            CleanupExpiredFileSets indicates an expected call of CleanupExpiredFileSets

                                                                                                                                                                                                                                                                                                                                            func (*MockNamespaceIndexMockRecorder) Close

                                                                                                                                                                                                                                                                                                                                              Close indicates an expected call of Close

                                                                                                                                                                                                                                                                                                                                              func (*MockNamespaceIndexMockRecorder) ColdFlush

                                                                                                                                                                                                                                                                                                                                              func (mr *MockNamespaceIndexMockRecorder) ColdFlush(shards interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                ColdFlush indicates an expected call of ColdFlush

                                                                                                                                                                                                                                                                                                                                                func (*MockNamespaceIndexMockRecorder) DebugMemorySegments

                                                                                                                                                                                                                                                                                                                                                func (mr *MockNamespaceIndexMockRecorder) DebugMemorySegments(opts interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                  DebugMemorySegments indicates an expected call of DebugMemorySegments

                                                                                                                                                                                                                                                                                                                                                  func (*MockNamespaceIndexMockRecorder) Query

                                                                                                                                                                                                                                                                                                                                                  func (mr *MockNamespaceIndexMockRecorder) Query(ctx, query, opts interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                    Query indicates an expected call of Query

                                                                                                                                                                                                                                                                                                                                                    func (*MockNamespaceIndexMockRecorder) SetExtendedRetentionPeriod

                                                                                                                                                                                                                                                                                                                                                    func (mr *MockNamespaceIndexMockRecorder) SetExtendedRetentionPeriod(period interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                      SetExtendedRetentionPeriod indicates an expected call of SetExtendedRetentionPeriod

                                                                                                                                                                                                                                                                                                                                                      func (*MockNamespaceIndexMockRecorder) Tick

                                                                                                                                                                                                                                                                                                                                                      func (mr *MockNamespaceIndexMockRecorder) Tick(c, startTime interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                        Tick indicates an expected call of Tick

                                                                                                                                                                                                                                                                                                                                                        func (*MockNamespaceIndexMockRecorder) WarmFlush

                                                                                                                                                                                                                                                                                                                                                        func (mr *MockNamespaceIndexMockRecorder) WarmFlush(flush, shards interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                          WarmFlush indicates an expected call of WarmFlush

                                                                                                                                                                                                                                                                                                                                                          func (*MockNamespaceIndexMockRecorder) WideQuery

                                                                                                                                                                                                                                                                                                                                                          func (mr *MockNamespaceIndexMockRecorder) WideQuery(ctx, query, collector, opts interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                            WideQuery indicates an expected call of WideQuery

                                                                                                                                                                                                                                                                                                                                                            func (*MockNamespaceIndexMockRecorder) WriteBatch

                                                                                                                                                                                                                                                                                                                                                            func (mr *MockNamespaceIndexMockRecorder) WriteBatch(batch interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                              WriteBatch indicates an expected call of WriteBatch

                                                                                                                                                                                                                                                                                                                                                              func (*MockNamespaceIndexMockRecorder) WritePending

                                                                                                                                                                                                                                                                                                                                                              func (mr *MockNamespaceIndexMockRecorder) WritePending(pending interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                WritePending indicates an expected call of WritePending

                                                                                                                                                                                                                                                                                                                                                                type MockNamespaceMockRecorder

                                                                                                                                                                                                                                                                                                                                                                type MockNamespaceMockRecorder struct {
                                                                                                                                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                  MockNamespaceMockRecorder is the mock recorder for MockNamespace

                                                                                                                                                                                                                                                                                                                                                                  func (*MockNamespaceMockRecorder) DocRef

                                                                                                                                                                                                                                                                                                                                                                  func (mr *MockNamespaceMockRecorder) DocRef(id interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                    DocRef indicates an expected call of DocRef

                                                                                                                                                                                                                                                                                                                                                                    func (*MockNamespaceMockRecorder) FetchWideEntry

                                                                                                                                                                                                                                                                                                                                                                    func (mr *MockNamespaceMockRecorder) FetchWideEntry(ctx, id, blockStart, filter interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                      FetchWideEntry indicates an expected call of FetchWideEntry

                                                                                                                                                                                                                                                                                                                                                                      func (*MockNamespaceMockRecorder) ID

                                                                                                                                                                                                                                                                                                                                                                        ID indicates an expected call of ID

                                                                                                                                                                                                                                                                                                                                                                        func (*MockNamespaceMockRecorder) Index

                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockNamespaceMockRecorder) Index() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                          Index indicates an expected call of Index

                                                                                                                                                                                                                                                                                                                                                                          func (*MockNamespaceMockRecorder) Metadata

                                                                                                                                                                                                                                                                                                                                                                          func (mr *MockNamespaceMockRecorder) Metadata() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                            Metadata indicates an expected call of Metadata

                                                                                                                                                                                                                                                                                                                                                                            func (*MockNamespaceMockRecorder) NumSeries

                                                                                                                                                                                                                                                                                                                                                                            func (mr *MockNamespaceMockRecorder) NumSeries() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                              NumSeries indicates an expected call of NumSeries

                                                                                                                                                                                                                                                                                                                                                                              func (*MockNamespaceMockRecorder) Options

                                                                                                                                                                                                                                                                                                                                                                              func (mr *MockNamespaceMockRecorder) Options() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                Options indicates an expected call of Options

                                                                                                                                                                                                                                                                                                                                                                                func (*MockNamespaceMockRecorder) ReadOnly

                                                                                                                                                                                                                                                                                                                                                                                func (mr *MockNamespaceMockRecorder) ReadOnly() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                  ReadOnly indicates an expected call of ReadOnly

                                                                                                                                                                                                                                                                                                                                                                                  func (*MockNamespaceMockRecorder) Schema

                                                                                                                                                                                                                                                                                                                                                                                  func (mr *MockNamespaceMockRecorder) Schema() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                    Schema indicates an expected call of Schema

                                                                                                                                                                                                                                                                                                                                                                                    func (*MockNamespaceMockRecorder) SetIndex

                                                                                                                                                                                                                                                                                                                                                                                    func (mr *MockNamespaceMockRecorder) SetIndex(reverseIndex interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                      SetIndex indicates an expected call of SetIndex

                                                                                                                                                                                                                                                                                                                                                                                      func (*MockNamespaceMockRecorder) SetReadOnly

                                                                                                                                                                                                                                                                                                                                                                                      func (mr *MockNamespaceMockRecorder) SetReadOnly(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                        SetReadOnly indicates an expected call of SetReadOnly

                                                                                                                                                                                                                                                                                                                                                                                        func (*MockNamespaceMockRecorder) Shards

                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockNamespaceMockRecorder) Shards() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                          Shards indicates an expected call of Shards

                                                                                                                                                                                                                                                                                                                                                                                          func (*MockNamespaceMockRecorder) StorageOptions

                                                                                                                                                                                                                                                                                                                                                                                          func (mr *MockNamespaceMockRecorder) StorageOptions() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                            StorageOptions indicates an expected call of StorageOptions

                                                                                                                                                                                                                                                                                                                                                                                            func (*MockNamespaceMockRecorder) WideQueryIDs

                                                                                                                                                                                                                                                                                                                                                                                            func (mr *MockNamespaceMockRecorder) WideQueryIDs(ctx, query, collector, opts interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                              WideQueryIDs indicates an expected call of WideQueryIDs

                                                                                                                                                                                                                                                                                                                                                                                              type MockOnColdFlush

                                                                                                                                                                                                                                                                                                                                                                                              type MockOnColdFlush struct {
                                                                                                                                                                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                MockOnColdFlush is a mock of OnColdFlush interface

                                                                                                                                                                                                                                                                                                                                                                                                func NewMockOnColdFlush

                                                                                                                                                                                                                                                                                                                                                                                                func NewMockOnColdFlush(ctrl *gomock.Controller) *MockOnColdFlush

                                                                                                                                                                                                                                                                                                                                                                                                  NewMockOnColdFlush creates a new mock instance

                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOnColdFlush) ColdFlushNamespace

                                                                                                                                                                                                                                                                                                                                                                                                  func (m *MockOnColdFlush) ColdFlushNamespace(ns Namespace) (OnColdFlushNamespace, error)

                                                                                                                                                                                                                                                                                                                                                                                                    ColdFlushNamespace mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOnColdFlush) EXPECT

                                                                                                                                                                                                                                                                                                                                                                                                      EXPECT returns an object that allows the caller to indicate expected use

                                                                                                                                                                                                                                                                                                                                                                                                      type MockOnColdFlushMockRecorder

                                                                                                                                                                                                                                                                                                                                                                                                      type MockOnColdFlushMockRecorder struct {
                                                                                                                                                                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                        MockOnColdFlushMockRecorder is the mock recorder for MockOnColdFlush

                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOnColdFlushMockRecorder) ColdFlushNamespace

                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockOnColdFlushMockRecorder) ColdFlushNamespace(ns interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                          ColdFlushNamespace indicates an expected call of ColdFlushNamespace

                                                                                                                                                                                                                                                                                                                                                                                                          type MockOnColdFlushNamespace

                                                                                                                                                                                                                                                                                                                                                                                                          type MockOnColdFlushNamespace struct {
                                                                                                                                                                                                                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                            MockOnColdFlushNamespace is a mock of OnColdFlushNamespace interface

                                                                                                                                                                                                                                                                                                                                                                                                            func NewMockOnColdFlushNamespace

                                                                                                                                                                                                                                                                                                                                                                                                            func NewMockOnColdFlushNamespace(ctrl *gomock.Controller) *MockOnColdFlushNamespace

                                                                                                                                                                                                                                                                                                                                                                                                              NewMockOnColdFlushNamespace creates a new mock instance

                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOnColdFlushNamespace) CheckpointAndMaybeCompact

                                                                                                                                                                                                                                                                                                                                                                                                              func (m *MockOnColdFlushNamespace) CheckpointAndMaybeCompact() error

                                                                                                                                                                                                                                                                                                                                                                                                                CheckpointAndMaybeCompact mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOnColdFlushNamespace) Done

                                                                                                                                                                                                                                                                                                                                                                                                                func (m *MockOnColdFlushNamespace) Done() error

                                                                                                                                                                                                                                                                                                                                                                                                                  Done mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOnColdFlushNamespace) EXPECT

                                                                                                                                                                                                                                                                                                                                                                                                                    EXPECT returns an object that allows the caller to indicate expected use

                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOnColdFlushNamespace) OnFlushNewSeries

                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *MockOnColdFlushNamespace) OnFlushNewSeries(arg0 persist.OnFlushNewSeriesEvent) error

                                                                                                                                                                                                                                                                                                                                                                                                                      OnFlushNewSeries mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                      type MockOnColdFlushNamespaceMockRecorder

                                                                                                                                                                                                                                                                                                                                                                                                                      type MockOnColdFlushNamespaceMockRecorder struct {
                                                                                                                                                                                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                        MockOnColdFlushNamespaceMockRecorder is the mock recorder for MockOnColdFlushNamespace

                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOnColdFlushNamespaceMockRecorder) CheckpointAndMaybeCompact

                                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockOnColdFlushNamespaceMockRecorder) CheckpointAndMaybeCompact() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                          CheckpointAndMaybeCompact indicates an expected call of CheckpointAndMaybeCompact

                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOnColdFlushNamespaceMockRecorder) Done

                                                                                                                                                                                                                                                                                                                                                                                                                            Done indicates an expected call of Done

                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOnColdFlushNamespaceMockRecorder) OnFlushNewSeries

                                                                                                                                                                                                                                                                                                                                                                                                                            func (mr *MockOnColdFlushNamespaceMockRecorder) OnFlushNewSeries(arg0 interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                              OnFlushNewSeries indicates an expected call of OnFlushNewSeries

                                                                                                                                                                                                                                                                                                                                                                                                                              type MockOptions

                                                                                                                                                                                                                                                                                                                                                                                                                              type MockOptions struct {
                                                                                                                                                                                                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                MockOptions is a mock of Options interface

                                                                                                                                                                                                                                                                                                                                                                                                                                func NewMockOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                func NewMockOptions(ctrl *gomock.Controller) *MockOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                  NewMockOptions creates a new mock instance

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptions) AdminClient

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *MockOptions) AdminClient() client.AdminClient

                                                                                                                                                                                                                                                                                                                                                                                                                                    AdminClient mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptions) BackgroundProcessFns

                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *MockOptions) BackgroundProcessFns() []NewBackgroundProcessFn

                                                                                                                                                                                                                                                                                                                                                                                                                                      BackgroundProcessFns mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptions) BlockLeaseManager

                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *MockOptions) BlockLeaseManager() block.LeaseManager

                                                                                                                                                                                                                                                                                                                                                                                                                                        BlockLeaseManager mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptions) BootstrapProcessProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *MockOptions) BootstrapProcessProvider() bootstrap.ProcessProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                          BootstrapProcessProvider mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptions) BufferBucketPool

                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *MockOptions) BufferBucketPool() *series.BufferBucketPool

                                                                                                                                                                                                                                                                                                                                                                                                                                            BufferBucketPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptions) BufferBucketVersionsPool

                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *MockOptions) BufferBucketVersionsPool() *series.BufferBucketVersionsPool

                                                                                                                                                                                                                                                                                                                                                                                                                                              BufferBucketVersionsPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptions) BytesPool

                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *MockOptions) BytesPool() pool.CheckedBytesPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                BytesPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptions) CheckedBytesWrapperPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *MockOptions) CheckedBytesWrapperPool() xpool.CheckedBytesWrapperPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                  CheckedBytesWrapperPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptions) ClockOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *MockOptions) ClockOptions() clock.Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                    ClockOptions mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptions) CommitLogOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *MockOptions) CommitLogOptions() commitlog.Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                      CommitLogOptions mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptions) ContextPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *MockOptions) ContextPool() context.Pool

                                                                                                                                                                                                                                                                                                                                                                                                                                                        ContextPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptions) DatabaseBlockOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *MockOptions) DatabaseBlockOptions() block.Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                          DatabaseBlockOptions mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptions) DatabaseBlockRetrieverManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *MockOptions) DatabaseBlockRetrieverManager() block.DatabaseBlockRetrieverManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                            DatabaseBlockRetrieverManager mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptions) DatabaseSeriesPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *MockOptions) DatabaseSeriesPool() series.DatabaseSeriesPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                              DatabaseSeriesPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptions) DoNotIndexWithFieldsMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *MockOptions) DoNotIndexWithFieldsMap() map[string]string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                DoNotIndexWithFieldsMap mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptions) EXPECT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *MockOptions) EXPECT() *MockOptionsMockRecorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  EXPECT returns an object that allows the caller to indicate expected use

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptions) EncoderPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *MockOptions) EncoderPool() encoding.EncoderPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    EncoderPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptions) ErrorThresholdForLoad

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *MockOptions) ErrorThresholdForLoad() int64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ErrorThresholdForLoad mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptions) ErrorWindowForLoad

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *MockOptions) ErrorWindowForLoad() time.Duration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ErrorWindowForLoad mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptions) FetchBlockMetadataResultsPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *MockOptions) FetchBlockMetadataResultsPool() block.FetchBlockMetadataResultsPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          FetchBlockMetadataResultsPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptions) FetchBlocksMetadataResultsPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *MockOptions) FetchBlocksMetadataResultsPool() block.FetchBlocksMetadataResultsPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FetchBlocksMetadataResultsPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptions) ForceColdWritesEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *MockOptions) ForceColdWritesEnabled() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ForceColdWritesEnabled mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptions) IdentifierPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *MockOptions) IdentifierPool() ident.Pool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                IdentifierPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptions) IndexClaimsManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *MockOptions) IndexClaimsManager() fs.IndexClaimsManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  IndexClaimsManager mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptions) IndexOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *MockOptions) IndexOptions() index.Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    IndexOptions mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptions) InstrumentOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *MockOptions) InstrumentOptions() instrument.Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      InstrumentOptions mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptions) IterationOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *MockOptions) IterationOptions() index.IterationOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        IterationOptions mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptions) MediatorTickInterval

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *MockOptions) MediatorTickInterval() time.Duration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          MediatorTickInterval mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptions) MemoryTracker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *MockOptions) MemoryTracker() MemoryTracker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            MemoryTracker mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptions) MmapReporter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *MockOptions) MmapReporter() mmap.Reporter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              MmapReporter mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptions) MultiReaderIteratorPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *MockOptions) MultiReaderIteratorPool() encoding.MultiReaderIteratorPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                MultiReaderIteratorPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptions) NamespaceHooks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *MockOptions) NamespaceHooks() NamespaceHooks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NamespaceHooks mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptions) NamespaceInitializer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *MockOptions) NamespaceInitializer() namespace.Initializer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NamespaceInitializer mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptions) NamespaceRuntimeOptionsManagerRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *MockOptions) NamespaceRuntimeOptionsManagerRegistry() namespace.RuntimeOptionsManagerRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NamespaceRuntimeOptionsManagerRegistry mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptions) OnColdFlush

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *MockOptions) OnColdFlush() OnColdFlush

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        OnColdFlush mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptions) PersistManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *MockOptions) PersistManager() persist.Manager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          PersistManager mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptions) QueryIDsWorkerPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *MockOptions) QueryIDsWorkerPool() sync0.WorkerPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            QueryIDsWorkerPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptions) ReaderIteratorPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *MockOptions) ReaderIteratorPool() encoding.ReaderIteratorPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ReaderIteratorPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptions) RepairEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *MockOptions) RepairEnabled() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                RepairEnabled mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptions) RepairOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *MockOptions) RepairOptions() repair.Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  RepairOptions mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptions) RetrieveRequestPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *MockOptions) RetrieveRequestPool() fs.RetrieveRequestPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    RetrieveRequestPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptions) RuntimeOptionsManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *MockOptions) RuntimeOptionsManager() runtime.OptionsManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      RuntimeOptionsManager mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptions) SchemaRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *MockOptions) SchemaRegistry() namespace.SchemaRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SchemaRegistry mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptions) SegmentReaderPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *MockOptions) SegmentReaderPool() xio.SegmentReaderPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SegmentReaderPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptions) SeriesCachePolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *MockOptions) SeriesCachePolicy() series.CachePolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SeriesCachePolicy mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptions) SeriesOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *MockOptions) SeriesOptions() series.Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SeriesOptions mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptions) SetAdminClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *MockOptions) SetAdminClient(value client.AdminClient) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetAdminClient mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptions) SetBackgroundProcessFns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *MockOptions) SetBackgroundProcessFns(arg0 []NewBackgroundProcessFn) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetBackgroundProcessFns mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptions) SetBlockLeaseManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *MockOptions) SetBlockLeaseManager(leaseMgr block.LeaseManager) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetBlockLeaseManager mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptions) SetBootstrapProcessProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *MockOptions) SetBootstrapProcessProvider(value bootstrap.ProcessProvider) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetBootstrapProcessProvider mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptions) SetBufferBucketPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *MockOptions) SetBufferBucketPool(value *series.BufferBucketPool) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetBufferBucketPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptions) SetBufferBucketVersionsPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *MockOptions) SetBufferBucketVersionsPool(value *series.BufferBucketVersionsPool) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetBufferBucketVersionsPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptions) SetBytesPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *MockOptions) SetBytesPool(value pool.CheckedBytesPool) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetBytesPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptions) SetCheckedBytesWrapperPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *MockOptions) SetCheckedBytesWrapperPool(value xpool.CheckedBytesWrapperPool) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetCheckedBytesWrapperPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptions) SetClockOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *MockOptions) SetClockOptions(value clock.Options) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetClockOptions mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptions) SetCommitLogOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *MockOptions) SetCommitLogOptions(value commitlog.Options) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetCommitLogOptions mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptions) SetContextPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *MockOptions) SetContextPool(value context.Pool) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetContextPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptions) SetDatabaseBlockOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *MockOptions) SetDatabaseBlockOptions(value block.Options) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetDatabaseBlockOptions mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptions) SetDatabaseBlockRetrieverManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *MockOptions) SetDatabaseBlockRetrieverManager(value block.DatabaseBlockRetrieverManager) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetDatabaseBlockRetrieverManager mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptions) SetDatabaseSeriesPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *MockOptions) SetDatabaseSeriesPool(value series.DatabaseSeriesPool) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetDatabaseSeriesPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptions) SetDoNotIndexWithFieldsMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *MockOptions) SetDoNotIndexWithFieldsMap(value map[string]string) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetDoNotIndexWithFieldsMap mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptions) SetEncoderPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *MockOptions) SetEncoderPool(value encoding.EncoderPool) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetEncoderPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptions) SetEncodingM3TSZPooled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *MockOptions) SetEncodingM3TSZPooled() Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetEncodingM3TSZPooled mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptions) SetErrorThresholdForLoad

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *MockOptions) SetErrorThresholdForLoad(value int64) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetErrorThresholdForLoad mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptions) SetErrorWindowForLoad

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *MockOptions) SetErrorWindowForLoad(value time.Duration) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetErrorWindowForLoad mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptions) SetFetchBlockMetadataResultsPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *MockOptions) SetFetchBlockMetadataResultsPool(value block.FetchBlockMetadataResultsPool) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetFetchBlockMetadataResultsPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptions) SetFetchBlocksMetadataResultsPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *MockOptions) SetFetchBlocksMetadataResultsPool(value block.FetchBlocksMetadataResultsPool) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetFetchBlocksMetadataResultsPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptions) SetForceColdWritesEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *MockOptions) SetForceColdWritesEnabled(value bool) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetForceColdWritesEnabled mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptions) SetIdentifierPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *MockOptions) SetIdentifierPool(value ident.Pool) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetIdentifierPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptions) SetIndexClaimsManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *MockOptions) SetIndexClaimsManager(value fs.IndexClaimsManager) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetIndexClaimsManager mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptions) SetIndexOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *MockOptions) SetIndexOptions(value index.Options) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetIndexOptions mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptions) SetInstrumentOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *MockOptions) SetInstrumentOptions(value instrument.Options) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetInstrumentOptions mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptions) SetIterationOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *MockOptions) SetIterationOptions(arg0 index.IterationOptions) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetIterationOptions mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptions) SetMediatorTickInterval

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *MockOptions) SetMediatorTickInterval(value time.Duration) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetMediatorTickInterval mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptions) SetMemoryTracker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *MockOptions) SetMemoryTracker(memTracker MemoryTracker) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetMemoryTracker mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptions) SetMmapReporter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *MockOptions) SetMmapReporter(mmapReporter mmap.Reporter) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetMmapReporter mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptions) SetMultiReaderIteratorPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *MockOptions) SetMultiReaderIteratorPool(value encoding.MultiReaderIteratorPool) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetMultiReaderIteratorPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptions) SetNamespaceHooks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *MockOptions) SetNamespaceHooks(hooks NamespaceHooks) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetNamespaceHooks mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptions) SetNamespaceInitializer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *MockOptions) SetNamespaceInitializer(value namespace.Initializer) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetNamespaceInitializer mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptions) SetNamespaceRuntimeOptionsManagerRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *MockOptions) SetNamespaceRuntimeOptionsManagerRegistry(value namespace.RuntimeOptionsManagerRegistry) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetNamespaceRuntimeOptionsManagerRegistry mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptions) SetOnColdFlush

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *MockOptions) SetOnColdFlush(value OnColdFlush) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetOnColdFlush mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptions) SetPersistManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *MockOptions) SetPersistManager(value persist.Manager) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetPersistManager mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptions) SetQueryIDsWorkerPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *MockOptions) SetQueryIDsWorkerPool(value sync0.WorkerPool) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetQueryIDsWorkerPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptions) SetReaderIteratorPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *MockOptions) SetReaderIteratorPool(value encoding.ReaderIteratorPool) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetReaderIteratorPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptions) SetRepairEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *MockOptions) SetRepairEnabled(b bool) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetRepairEnabled mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptions) SetRepairOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *MockOptions) SetRepairOptions(value repair.Options) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetRepairOptions mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptions) SetRetrieveRequestPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *MockOptions) SetRetrieveRequestPool(value fs.RetrieveRequestPool) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetRetrieveRequestPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptions) SetRuntimeOptionsManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *MockOptions) SetRuntimeOptionsManager(value runtime.OptionsManager) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetRuntimeOptionsManager mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptions) SetSchemaRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *MockOptions) SetSchemaRegistry(registry namespace.SchemaRegistry) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetSchemaRegistry mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptions) SetSegmentReaderPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *MockOptions) SetSegmentReaderPool(value xio.SegmentReaderPool) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetSegmentReaderPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptions) SetSeriesCachePolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *MockOptions) SetSeriesCachePolicy(value series.CachePolicy) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetSeriesCachePolicy mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptions) SetSeriesOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *MockOptions) SetSeriesOptions(value series.Options) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetSeriesOptions mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptions) SetSourceLoggerBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *MockOptions) SetSourceLoggerBuilder(value limits.SourceLoggerBuilder) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetSourceLoggerBuilder mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptions) SetTileAggregator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *MockOptions) SetTileAggregator(aggregator TileAggregator) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetTileAggregator mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptions) SetTruncateType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *MockOptions) SetTruncateType(value series.TruncateType) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetTruncateType mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptions) SetWideBatchSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *MockOptions) SetWideBatchSize(value int) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetWideBatchSize mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptions) SetWriteBatchPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *MockOptions) SetWriteBatchPool(value *writes.WriteBatchPool) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetWriteBatchPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptions) SetWriteTransformOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *MockOptions) SetWriteTransformOptions(value series.WriteTransformOptions) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetWriteTransformOptions mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptions) SourceLoggerBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *MockOptions) SourceLoggerBuilder() limits.SourceLoggerBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SourceLoggerBuilder mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptions) TileAggregator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *MockOptions) TileAggregator() TileAggregator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TileAggregator mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptions) TruncateType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *MockOptions) TruncateType() series.TruncateType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TruncateType mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptions) Validate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *MockOptions) Validate() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Validate mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptions) WideBatchSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *MockOptions) WideBatchSize() int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                WideBatchSize mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptions) WriteBatchPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *MockOptions) WriteBatchPool() *writes.WriteBatchPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  WriteBatchPool mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptions) WriteTransformOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *MockOptions) WriteTransformOptions() series.WriteTransformOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WriteTransformOptions mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type MockOptionsMockRecorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type MockOptionsMockRecorder struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MockOptionsMockRecorder is the mock recorder for MockOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptionsMockRecorder) AdminClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (mr *MockOptionsMockRecorder) AdminClient() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        AdminClient indicates an expected call of AdminClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptionsMockRecorder) BackgroundProcessFns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockOptionsMockRecorder) BackgroundProcessFns() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          BackgroundProcessFns indicates an expected call of BackgroundProcessFns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptionsMockRecorder) BlockLeaseManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (mr *MockOptionsMockRecorder) BlockLeaseManager() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            BlockLeaseManager indicates an expected call of BlockLeaseManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptionsMockRecorder) BootstrapProcessProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (mr *MockOptionsMockRecorder) BootstrapProcessProvider() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              BootstrapProcessProvider indicates an expected call of BootstrapProcessProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptionsMockRecorder) BufferBucketPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (mr *MockOptionsMockRecorder) BufferBucketPool() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                BufferBucketPool indicates an expected call of BufferBucketPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptionsMockRecorder) BufferBucketVersionsPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (mr *MockOptionsMockRecorder) BufferBucketVersionsPool() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  BufferBucketVersionsPool indicates an expected call of BufferBucketVersionsPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptionsMockRecorder) BytesPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (mr *MockOptionsMockRecorder) BytesPool() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    BytesPool indicates an expected call of BytesPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptionsMockRecorder) CheckedBytesWrapperPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (mr *MockOptionsMockRecorder) CheckedBytesWrapperPool() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CheckedBytesWrapperPool indicates an expected call of CheckedBytesWrapperPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptionsMockRecorder) ClockOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (mr *MockOptionsMockRecorder) ClockOptions() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ClockOptions indicates an expected call of ClockOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptionsMockRecorder) CommitLogOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockOptionsMockRecorder) CommitLogOptions() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          CommitLogOptions indicates an expected call of CommitLogOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptionsMockRecorder) ContextPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (mr *MockOptionsMockRecorder) ContextPool() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ContextPool indicates an expected call of ContextPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptionsMockRecorder) DatabaseBlockOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (mr *MockOptionsMockRecorder) DatabaseBlockOptions() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              DatabaseBlockOptions indicates an expected call of DatabaseBlockOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptionsMockRecorder) DatabaseBlockRetrieverManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (mr *MockOptionsMockRecorder) DatabaseBlockRetrieverManager() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                DatabaseBlockRetrieverManager indicates an expected call of DatabaseBlockRetrieverManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptionsMockRecorder) DatabaseSeriesPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (mr *MockOptionsMockRecorder) DatabaseSeriesPool() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  DatabaseSeriesPool indicates an expected call of DatabaseSeriesPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptionsMockRecorder) DoNotIndexWithFieldsMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (mr *MockOptionsMockRecorder) DoNotIndexWithFieldsMap() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    DoNotIndexWithFieldsMap indicates an expected call of DoNotIndexWithFieldsMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptionsMockRecorder) EncoderPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (mr *MockOptionsMockRecorder) EncoderPool() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      EncoderPool indicates an expected call of EncoderPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptionsMockRecorder) ErrorThresholdForLoad

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (mr *MockOptionsMockRecorder) ErrorThresholdForLoad() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ErrorThresholdForLoad indicates an expected call of ErrorThresholdForLoad

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptionsMockRecorder) ErrorWindowForLoad

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockOptionsMockRecorder) ErrorWindowForLoad() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ErrorWindowForLoad indicates an expected call of ErrorWindowForLoad

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptionsMockRecorder) FetchBlockMetadataResultsPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (mr *MockOptionsMockRecorder) FetchBlockMetadataResultsPool() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FetchBlockMetadataResultsPool indicates an expected call of FetchBlockMetadataResultsPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptionsMockRecorder) FetchBlocksMetadataResultsPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (mr *MockOptionsMockRecorder) FetchBlocksMetadataResultsPool() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              FetchBlocksMetadataResultsPool indicates an expected call of FetchBlocksMetadataResultsPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptionsMockRecorder) ForceColdWritesEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (mr *MockOptionsMockRecorder) ForceColdWritesEnabled() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ForceColdWritesEnabled indicates an expected call of ForceColdWritesEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptionsMockRecorder) IdentifierPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (mr *MockOptionsMockRecorder) IdentifierPool() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  IdentifierPool indicates an expected call of IdentifierPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptionsMockRecorder) IndexClaimsManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (mr *MockOptionsMockRecorder) IndexClaimsManager() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    IndexClaimsManager indicates an expected call of IndexClaimsManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptionsMockRecorder) IndexOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (mr *MockOptionsMockRecorder) IndexOptions() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      IndexOptions indicates an expected call of IndexOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptionsMockRecorder) InstrumentOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (mr *MockOptionsMockRecorder) InstrumentOptions() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        InstrumentOptions indicates an expected call of InstrumentOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptionsMockRecorder) IterationOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockOptionsMockRecorder) IterationOptions() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          IterationOptions indicates an expected call of IterationOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptionsMockRecorder) MediatorTickInterval

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (mr *MockOptionsMockRecorder) MediatorTickInterval() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            MediatorTickInterval indicates an expected call of MediatorTickInterval

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptionsMockRecorder) MemoryTracker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (mr *MockOptionsMockRecorder) MemoryTracker() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              MemoryTracker indicates an expected call of MemoryTracker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptionsMockRecorder) MmapReporter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (mr *MockOptionsMockRecorder) MmapReporter() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                MmapReporter indicates an expected call of MmapReporter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptionsMockRecorder) MultiReaderIteratorPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (mr *MockOptionsMockRecorder) MultiReaderIteratorPool() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  MultiReaderIteratorPool indicates an expected call of MultiReaderIteratorPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptionsMockRecorder) NamespaceHooks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (mr *MockOptionsMockRecorder) NamespaceHooks() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NamespaceHooks indicates an expected call of NamespaceHooks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptionsMockRecorder) NamespaceInitializer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (mr *MockOptionsMockRecorder) NamespaceInitializer() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NamespaceInitializer indicates an expected call of NamespaceInitializer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptionsMockRecorder) NamespaceRuntimeOptionsManagerRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (mr *MockOptionsMockRecorder) NamespaceRuntimeOptionsManagerRegistry() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NamespaceRuntimeOptionsManagerRegistry indicates an expected call of NamespaceRuntimeOptionsManagerRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptionsMockRecorder) OnColdFlush

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockOptionsMockRecorder) OnColdFlush() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          OnColdFlush indicates an expected call of OnColdFlush

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptionsMockRecorder) PersistManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (mr *MockOptionsMockRecorder) PersistManager() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            PersistManager indicates an expected call of PersistManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptionsMockRecorder) QueryIDsWorkerPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (mr *MockOptionsMockRecorder) QueryIDsWorkerPool() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              QueryIDsWorkerPool indicates an expected call of QueryIDsWorkerPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptionsMockRecorder) ReaderIteratorPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (mr *MockOptionsMockRecorder) ReaderIteratorPool() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ReaderIteratorPool indicates an expected call of ReaderIteratorPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptionsMockRecorder) RepairEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (mr *MockOptionsMockRecorder) RepairEnabled() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  RepairEnabled indicates an expected call of RepairEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptionsMockRecorder) RepairOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (mr *MockOptionsMockRecorder) RepairOptions() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    RepairOptions indicates an expected call of RepairOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptionsMockRecorder) RetrieveRequestPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (mr *MockOptionsMockRecorder) RetrieveRequestPool() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      RetrieveRequestPool indicates an expected call of RetrieveRequestPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptionsMockRecorder) RuntimeOptionsManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (mr *MockOptionsMockRecorder) RuntimeOptionsManager() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        RuntimeOptionsManager indicates an expected call of RuntimeOptionsManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptionsMockRecorder) SchemaRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockOptionsMockRecorder) SchemaRegistry() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SchemaRegistry indicates an expected call of SchemaRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptionsMockRecorder) SegmentReaderPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (mr *MockOptionsMockRecorder) SegmentReaderPool() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SegmentReaderPool indicates an expected call of SegmentReaderPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptionsMockRecorder) SeriesCachePolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (mr *MockOptionsMockRecorder) SeriesCachePolicy() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SeriesCachePolicy indicates an expected call of SeriesCachePolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptionsMockRecorder) SeriesOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (mr *MockOptionsMockRecorder) SeriesOptions() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SeriesOptions indicates an expected call of SeriesOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptionsMockRecorder) SetAdminClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (mr *MockOptionsMockRecorder) SetAdminClient(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetAdminClient indicates an expected call of SetAdminClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptionsMockRecorder) SetBackgroundProcessFns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (mr *MockOptionsMockRecorder) SetBackgroundProcessFns(arg0 interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetBackgroundProcessFns indicates an expected call of SetBackgroundProcessFns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptionsMockRecorder) SetBlockLeaseManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (mr *MockOptionsMockRecorder) SetBlockLeaseManager(leaseMgr interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetBlockLeaseManager indicates an expected call of SetBlockLeaseManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptionsMockRecorder) SetBootstrapProcessProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (mr *MockOptionsMockRecorder) SetBootstrapProcessProvider(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetBootstrapProcessProvider indicates an expected call of SetBootstrapProcessProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptionsMockRecorder) SetBufferBucketPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockOptionsMockRecorder) SetBufferBucketPool(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetBufferBucketPool indicates an expected call of SetBufferBucketPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptionsMockRecorder) SetBufferBucketVersionsPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (mr *MockOptionsMockRecorder) SetBufferBucketVersionsPool(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetBufferBucketVersionsPool indicates an expected call of SetBufferBucketVersionsPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptionsMockRecorder) SetBytesPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (mr *MockOptionsMockRecorder) SetBytesPool(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetBytesPool indicates an expected call of SetBytesPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptionsMockRecorder) SetCheckedBytesWrapperPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (mr *MockOptionsMockRecorder) SetCheckedBytesWrapperPool(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetCheckedBytesWrapperPool indicates an expected call of SetCheckedBytesWrapperPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptionsMockRecorder) SetClockOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (mr *MockOptionsMockRecorder) SetClockOptions(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetClockOptions indicates an expected call of SetClockOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptionsMockRecorder) SetCommitLogOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (mr *MockOptionsMockRecorder) SetCommitLogOptions(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetCommitLogOptions indicates an expected call of SetCommitLogOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptionsMockRecorder) SetContextPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (mr *MockOptionsMockRecorder) SetContextPool(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetContextPool indicates an expected call of SetContextPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptionsMockRecorder) SetDatabaseBlockOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (mr *MockOptionsMockRecorder) SetDatabaseBlockOptions(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetDatabaseBlockOptions indicates an expected call of SetDatabaseBlockOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptionsMockRecorder) SetDatabaseBlockRetrieverManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockOptionsMockRecorder) SetDatabaseBlockRetrieverManager(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetDatabaseBlockRetrieverManager indicates an expected call of SetDatabaseBlockRetrieverManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptionsMockRecorder) SetDatabaseSeriesPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (mr *MockOptionsMockRecorder) SetDatabaseSeriesPool(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetDatabaseSeriesPool indicates an expected call of SetDatabaseSeriesPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptionsMockRecorder) SetDoNotIndexWithFieldsMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (mr *MockOptionsMockRecorder) SetDoNotIndexWithFieldsMap(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetDoNotIndexWithFieldsMap indicates an expected call of SetDoNotIndexWithFieldsMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptionsMockRecorder) SetEncoderPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (mr *MockOptionsMockRecorder) SetEncoderPool(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetEncoderPool indicates an expected call of SetEncoderPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptionsMockRecorder) SetEncodingM3TSZPooled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (mr *MockOptionsMockRecorder) SetEncodingM3TSZPooled() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetEncodingM3TSZPooled indicates an expected call of SetEncodingM3TSZPooled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptionsMockRecorder) SetErrorThresholdForLoad

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (mr *MockOptionsMockRecorder) SetErrorThresholdForLoad(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetErrorThresholdForLoad indicates an expected call of SetErrorThresholdForLoad

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptionsMockRecorder) SetErrorWindowForLoad

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (mr *MockOptionsMockRecorder) SetErrorWindowForLoad(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetErrorWindowForLoad indicates an expected call of SetErrorWindowForLoad

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptionsMockRecorder) SetFetchBlockMetadataResultsPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (mr *MockOptionsMockRecorder) SetFetchBlockMetadataResultsPool(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetFetchBlockMetadataResultsPool indicates an expected call of SetFetchBlockMetadataResultsPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptionsMockRecorder) SetFetchBlocksMetadataResultsPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockOptionsMockRecorder) SetFetchBlocksMetadataResultsPool(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetFetchBlocksMetadataResultsPool indicates an expected call of SetFetchBlocksMetadataResultsPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptionsMockRecorder) SetForceColdWritesEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (mr *MockOptionsMockRecorder) SetForceColdWritesEnabled(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetForceColdWritesEnabled indicates an expected call of SetForceColdWritesEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptionsMockRecorder) SetIdentifierPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (mr *MockOptionsMockRecorder) SetIdentifierPool(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetIdentifierPool indicates an expected call of SetIdentifierPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptionsMockRecorder) SetIndexClaimsManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (mr *MockOptionsMockRecorder) SetIndexClaimsManager(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetIndexClaimsManager indicates an expected call of SetIndexClaimsManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptionsMockRecorder) SetIndexOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (mr *MockOptionsMockRecorder) SetIndexOptions(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetIndexOptions indicates an expected call of SetIndexOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptionsMockRecorder) SetInstrumentOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (mr *MockOptionsMockRecorder) SetInstrumentOptions(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetInstrumentOptions indicates an expected call of SetInstrumentOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptionsMockRecorder) SetIterationOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (mr *MockOptionsMockRecorder) SetIterationOptions(arg0 interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetIterationOptions indicates an expected call of SetIterationOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptionsMockRecorder) SetMediatorTickInterval

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (mr *MockOptionsMockRecorder) SetMediatorTickInterval(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetMediatorTickInterval indicates an expected call of SetMediatorTickInterval

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptionsMockRecorder) SetMemoryTracker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockOptionsMockRecorder) SetMemoryTracker(memTracker interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetMemoryTracker indicates an expected call of SetMemoryTracker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptionsMockRecorder) SetMmapReporter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (mr *MockOptionsMockRecorder) SetMmapReporter(mmapReporter interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetMmapReporter indicates an expected call of SetMmapReporter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptionsMockRecorder) SetMultiReaderIteratorPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (mr *MockOptionsMockRecorder) SetMultiReaderIteratorPool(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetMultiReaderIteratorPool indicates an expected call of SetMultiReaderIteratorPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptionsMockRecorder) SetNamespaceHooks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (mr *MockOptionsMockRecorder) SetNamespaceHooks(hooks interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetNamespaceHooks indicates an expected call of SetNamespaceHooks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptionsMockRecorder) SetNamespaceInitializer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (mr *MockOptionsMockRecorder) SetNamespaceInitializer(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetNamespaceInitializer indicates an expected call of SetNamespaceInitializer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptionsMockRecorder) SetNamespaceRuntimeOptionsManagerRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (mr *MockOptionsMockRecorder) SetNamespaceRuntimeOptionsManagerRegistry(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetNamespaceRuntimeOptionsManagerRegistry indicates an expected call of SetNamespaceRuntimeOptionsManagerRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptionsMockRecorder) SetOnColdFlush

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (mr *MockOptionsMockRecorder) SetOnColdFlush(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetOnColdFlush indicates an expected call of SetOnColdFlush

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptionsMockRecorder) SetPersistManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (mr *MockOptionsMockRecorder) SetPersistManager(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetPersistManager indicates an expected call of SetPersistManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptionsMockRecorder) SetQueryIDsWorkerPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockOptionsMockRecorder) SetQueryIDsWorkerPool(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetQueryIDsWorkerPool indicates an expected call of SetQueryIDsWorkerPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptionsMockRecorder) SetReaderIteratorPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (mr *MockOptionsMockRecorder) SetReaderIteratorPool(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetReaderIteratorPool indicates an expected call of SetReaderIteratorPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptionsMockRecorder) SetRepairEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (mr *MockOptionsMockRecorder) SetRepairEnabled(b interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetRepairEnabled indicates an expected call of SetRepairEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptionsMockRecorder) SetRepairOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (mr *MockOptionsMockRecorder) SetRepairOptions(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetRepairOptions indicates an expected call of SetRepairOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptionsMockRecorder) SetRetrieveRequestPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (mr *MockOptionsMockRecorder) SetRetrieveRequestPool(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetRetrieveRequestPool indicates an expected call of SetRetrieveRequestPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptionsMockRecorder) SetRuntimeOptionsManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (mr *MockOptionsMockRecorder) SetRuntimeOptionsManager(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetRuntimeOptionsManager indicates an expected call of SetRuntimeOptionsManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptionsMockRecorder) SetSchemaRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (mr *MockOptionsMockRecorder) SetSchemaRegistry(registry interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetSchemaRegistry indicates an expected call of SetSchemaRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptionsMockRecorder) SetSegmentReaderPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (mr *MockOptionsMockRecorder) SetSegmentReaderPool(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetSegmentReaderPool indicates an expected call of SetSegmentReaderPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptionsMockRecorder) SetSeriesCachePolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockOptionsMockRecorder) SetSeriesCachePolicy(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetSeriesCachePolicy indicates an expected call of SetSeriesCachePolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptionsMockRecorder) SetSeriesOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (mr *MockOptionsMockRecorder) SetSeriesOptions(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetSeriesOptions indicates an expected call of SetSeriesOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptionsMockRecorder) SetSourceLoggerBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (mr *MockOptionsMockRecorder) SetSourceLoggerBuilder(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetSourceLoggerBuilder indicates an expected call of SetSourceLoggerBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptionsMockRecorder) SetTileAggregator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (mr *MockOptionsMockRecorder) SetTileAggregator(aggregator interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetTileAggregator indicates an expected call of SetTileAggregator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptionsMockRecorder) SetTruncateType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (mr *MockOptionsMockRecorder) SetTruncateType(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetTruncateType indicates an expected call of SetTruncateType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptionsMockRecorder) SetWideBatchSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (mr *MockOptionsMockRecorder) SetWideBatchSize(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetWideBatchSize indicates an expected call of SetWideBatchSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptionsMockRecorder) SetWriteBatchPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (mr *MockOptionsMockRecorder) SetWriteBatchPool(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetWriteBatchPool indicates an expected call of SetWriteBatchPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptionsMockRecorder) SetWriteTransformOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (mr *MockOptionsMockRecorder) SetWriteTransformOptions(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetWriteTransformOptions indicates an expected call of SetWriteTransformOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptionsMockRecorder) SourceLoggerBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockOptionsMockRecorder) SourceLoggerBuilder() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SourceLoggerBuilder indicates an expected call of SourceLoggerBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptionsMockRecorder) TileAggregator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (mr *MockOptionsMockRecorder) TileAggregator() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TileAggregator indicates an expected call of TileAggregator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptionsMockRecorder) TruncateType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (mr *MockOptionsMockRecorder) TruncateType() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TruncateType indicates an expected call of TruncateType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptionsMockRecorder) Validate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (mr *MockOptionsMockRecorder) Validate() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Validate indicates an expected call of Validate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptionsMockRecorder) WideBatchSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (mr *MockOptionsMockRecorder) WideBatchSize() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  WideBatchSize indicates an expected call of WideBatchSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptionsMockRecorder) WriteBatchPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (mr *MockOptionsMockRecorder) WriteBatchPool() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WriteBatchPool indicates an expected call of WriteBatchPool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptionsMockRecorder) WriteTransformOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (mr *MockOptionsMockRecorder) WriteTransformOptions() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WriteTransformOptions indicates an expected call of WriteTransformOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MockShard

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MockShard struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        MockShard is a mock of Shard interface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewMockShard

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewMockShard(ctrl *gomock.Controller) *MockShard

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NewMockShard creates a new mock instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockShard) BootstrapState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *MockShard) BootstrapState() BootstrapState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            BootstrapState mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockShard) EXPECT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *MockShard) EXPECT() *MockShardMockRecorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              EXPECT returns an object that allows the caller to indicate expected use

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockShard) ID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *MockShard) ID() uint32

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ID mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockShard) IsBootstrapped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *MockShard) IsBootstrapped() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  IsBootstrapped mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockShard) NumSeries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *MockShard) NumSeries() int64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NumSeries mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockShard) ScanData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *MockShard) ScanData(blockStart time.Time, processor fs.DataEntryProcessor) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ScanData mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MockShardColdFlush

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MockShardColdFlush struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        MockShardColdFlush is a mock of ShardColdFlush interface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewMockShardColdFlush

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewMockShardColdFlush(ctrl *gomock.Controller) *MockShardColdFlush

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NewMockShardColdFlush creates a new mock instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockShardColdFlush) Done

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *MockShardColdFlush) Done() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Done mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockShardColdFlush) EXPECT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              EXPECT returns an object that allows the caller to indicate expected use

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MockShardColdFlushMockRecorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MockShardColdFlushMockRecorder struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                MockShardColdFlushMockRecorder is the mock recorder for MockShardColdFlush

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockShardColdFlushMockRecorder) Done

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Done indicates an expected call of Done

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MockShardMockRecorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MockShardMockRecorder struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    MockShardMockRecorder is the mock recorder for MockShard

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockShardMockRecorder) BootstrapState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (mr *MockShardMockRecorder) BootstrapState() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      BootstrapState indicates an expected call of BootstrapState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockShardMockRecorder) ID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (mr *MockShardMockRecorder) ID() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ID indicates an expected call of ID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockShardMockRecorder) IsBootstrapped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockShardMockRecorder) IsBootstrapped() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          IsBootstrapped indicates an expected call of IsBootstrapped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockShardMockRecorder) NumSeries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (mr *MockShardMockRecorder) NumSeries() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NumSeries indicates an expected call of NumSeries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockShardMockRecorder) ScanData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (mr *MockShardMockRecorder) ScanData(blockStart, processor interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ScanData indicates an expected call of ScanData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MockTileAggregator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MockTileAggregator struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                MockTileAggregator is a mock of TileAggregator interface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewMockTileAggregator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewMockTileAggregator(ctrl *gomock.Controller) *MockTileAggregator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NewMockTileAggregator creates a new mock instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockTileAggregator) AggregateTiles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *MockTileAggregator) AggregateTiles(ctx context.Context, sourceNs, targetNs Namespace, shardID uint32, readers []fs.DataFileSetReader, writer fs.StreamingWriter, onFlushSeries persist.OnFlushSeries, opts AggregateTilesOptions) (int64, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    AggregateTiles mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockTileAggregator) EXPECT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      EXPECT returns an object that allows the caller to indicate expected use

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MockTileAggregatorMockRecorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MockTileAggregatorMockRecorder struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        MockTileAggregatorMockRecorder is the mock recorder for MockTileAggregator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockTileAggregatorMockRecorder) AggregateTiles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockTileAggregatorMockRecorder) AggregateTiles(ctx, sourceNs, targetNs, shardID, readers, writer, onFlushSeries, opts interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          AggregateTiles indicates an expected call of AggregateTiles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Mockdatabase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Mockdatabase struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Mockdatabase is a mock of database interface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewMockdatabase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewMockdatabase(ctrl *gomock.Controller) *Mockdatabase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NewMockdatabase creates a new mock instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Mockdatabase) AggregateQuery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *Mockdatabase) AggregateQuery(ctx context.Context, namespace ident.ID, query index.Query, opts index.AggregationOptions) (index.AggregateQueryResult, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                AggregateQuery mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Mockdatabase) AggregateTiles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *Mockdatabase) AggregateTiles(ctx context.Context, sourceNsID, targetNsID ident.ID, opts AggregateTilesOptions) (int64, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  AggregateTiles mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Mockdatabase) AssignShardSet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *Mockdatabase) AssignShardSet(shardSet sharding.ShardSet)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    AssignShardSet mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Mockdatabase) BatchProcessWideQuery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *Mockdatabase) BatchProcessWideQuery(ctx context.Context, n Namespace, query index.Query, batchProcessor IDBatchProcessor, opts index.WideQueryOptions) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      BatchProcessWideQuery mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Mockdatabase) BatchWriter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *Mockdatabase) BatchWriter(namespace ident.ID, batchSize int) (writes.BatchWriter, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        BatchWriter mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Mockdatabase) Bootstrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *Mockdatabase) Bootstrap() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Bootstrap mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Mockdatabase) BootstrapState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *Mockdatabase) BootstrapState() DatabaseBootstrapState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            BootstrapState mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Mockdatabase) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *Mockdatabase) Close() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Close mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Mockdatabase) EXPECT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                EXPECT returns an object that allows the caller to indicate expected use

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Mockdatabase) FetchBlocks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *Mockdatabase) FetchBlocks(ctx context.Context, namespace ident.ID, shard uint32, id ident.ID, starts []time.Time) ([]block.FetchBlockResult, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  FetchBlocks mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Mockdatabase) FetchBlocksMetadataV2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *Mockdatabase) FetchBlocksMetadataV2(ctx context.Context, namespace ident.ID, shard uint32, start, end time.Time, limit int64, pageToken PageToken, opts block.FetchBlocksMetadataOptions) (block.FetchBlocksMetadataResults, PageToken, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    FetchBlocksMetadataV2 mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Mockdatabase) FlushState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *Mockdatabase) FlushState(namespace ident.ID, shardID uint32, blockStart time.Time) (fileOpState, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FlushState mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Mockdatabase) IsBootstrapped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *Mockdatabase) IsBootstrapped() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        IsBootstrapped mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Mockdatabase) IsBootstrappedAndDurable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *Mockdatabase) IsBootstrappedAndDurable() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          IsBootstrappedAndDurable mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Mockdatabase) IsOverloaded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *Mockdatabase) IsOverloaded() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            IsOverloaded mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Mockdatabase) Namespace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *Mockdatabase) Namespace(ns ident.ID) (Namespace, bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Namespace mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Mockdatabase) Namespaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *Mockdatabase) Namespaces() []Namespace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Namespaces mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Mockdatabase) Open

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *Mockdatabase) Open() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Open mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Mockdatabase) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *Mockdatabase) Options() Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Options mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Mockdatabase) OwnedNamespaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *Mockdatabase) OwnedNamespaces() ([]databaseNamespace, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      OwnedNamespaces mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Mockdatabase) QueryIDs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *Mockdatabase) QueryIDs(ctx context.Context, namespace ident.ID, query index.Query, opts index.QueryOptions) (index.QueryResult, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        QueryIDs mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Mockdatabase) ReadEncoded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *Mockdatabase) ReadEncoded(ctx context.Context, namespace, id ident.ID, start, end time.Time) ([][]xio.BlockReader, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ReadEncoded mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Mockdatabase) Repair

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *Mockdatabase) Repair() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Repair mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Mockdatabase) ShardSet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *Mockdatabase) ShardSet() sharding.ShardSet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ShardSet mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Mockdatabase) Terminate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *Mockdatabase) Terminate() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Terminate mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Mockdatabase) Truncate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *Mockdatabase) Truncate(namespace ident.ID) (int64, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Truncate mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Mockdatabase) UpdateOwnedNamespaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *Mockdatabase) UpdateOwnedNamespaces(namespaces namespace.Map) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    UpdateOwnedNamespaces mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Mockdatabase) WideQuery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *Mockdatabase) WideQuery(ctx context.Context, namespace ident.ID, query index.Query, start time.Time, shards []uint32, iterOpts index.IterationOptions) ([]xio.WideEntry, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WideQuery mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Mockdatabase) Write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *Mockdatabase) Write(ctx context.Context, namespace, id ident.ID, timestamp time.Time, value float64, unit time0.Unit, annotation []byte) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Write mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Mockdatabase) WriteBatch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *Mockdatabase) WriteBatch(ctx context.Context, namespace ident.ID, writes writes.BatchWriter, errHandler IndexedErrorHandler) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          WriteBatch mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Mockdatabase) WriteTagged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *Mockdatabase) WriteTagged(ctx context.Context, namespace, id ident.ID, tags ident.TagIterator, timestamp time.Time, value float64, unit time0.Unit, annotation []byte) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WriteTagged mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Mockdatabase) WriteTaggedBatch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *Mockdatabase) WriteTaggedBatch(ctx context.Context, namespace ident.ID, writes writes.BatchWriter, errHandler IndexedErrorHandler) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              WriteTaggedBatch mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MockdatabaseBootstrapManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MockdatabaseBootstrapManager struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                MockdatabaseBootstrapManager is a mock of databaseBootstrapManager interface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewMockdatabaseBootstrapManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewMockdatabaseBootstrapManager(ctrl *gomock.Controller) *MockdatabaseBootstrapManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NewMockdatabaseBootstrapManager creates a new mock instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockdatabaseBootstrapManager) Bootstrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Bootstrap mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockdatabaseBootstrapManager) EXPECT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      EXPECT returns an object that allows the caller to indicate expected use

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockdatabaseBootstrapManager) IsBootstrapped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *MockdatabaseBootstrapManager) IsBootstrapped() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        IsBootstrapped mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockdatabaseBootstrapManager) LastBootstrapCompletionTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *MockdatabaseBootstrapManager) LastBootstrapCompletionTime() (time0.UnixNano, bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          LastBootstrapCompletionTime mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockdatabaseBootstrapManager) Report

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *MockdatabaseBootstrapManager) Report()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Report mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type MockdatabaseBootstrapManagerMockRecorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type MockdatabaseBootstrapManagerMockRecorder struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              MockdatabaseBootstrapManagerMockRecorder is the mock recorder for MockdatabaseBootstrapManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockdatabaseBootstrapManagerMockRecorder) Bootstrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Bootstrap indicates an expected call of Bootstrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockdatabaseBootstrapManagerMockRecorder) IsBootstrapped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  IsBootstrapped indicates an expected call of IsBootstrapped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockdatabaseBootstrapManagerMockRecorder) LastBootstrapCompletionTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (mr *MockdatabaseBootstrapManagerMockRecorder) LastBootstrapCompletionTime() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    LastBootstrapCompletionTime indicates an expected call of LastBootstrapCompletionTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockdatabaseBootstrapManagerMockRecorder) Report

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Report indicates an expected call of Report

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MockdatabaseCleanupManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MockdatabaseCleanupManager struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        MockdatabaseCleanupManager is a mock of databaseCleanupManager interface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewMockdatabaseCleanupManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewMockdatabaseCleanupManager(ctrl *gomock.Controller) *MockdatabaseCleanupManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NewMockdatabaseCleanupManager creates a new mock instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockdatabaseCleanupManager) ColdFlushCleanup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *MockdatabaseCleanupManager) ColdFlushCleanup(t time.Time, isBootstrapped bool) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ColdFlushCleanup mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockdatabaseCleanupManager) EXPECT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              EXPECT returns an object that allows the caller to indicate expected use

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockdatabaseCleanupManager) Report

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *MockdatabaseCleanupManager) Report()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Report mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockdatabaseCleanupManager) WarmFlushCleanup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *MockdatabaseCleanupManager) WarmFlushCleanup(t time.Time, isBootstrapped bool) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  WarmFlushCleanup mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MockdatabaseCleanupManagerMockRecorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MockdatabaseCleanupManagerMockRecorder struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    MockdatabaseCleanupManagerMockRecorder is the mock recorder for MockdatabaseCleanupManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockdatabaseCleanupManagerMockRecorder) ColdFlushCleanup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (mr *MockdatabaseCleanupManagerMockRecorder) ColdFlushCleanup(t, isBootstrapped interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ColdFlushCleanup indicates an expected call of ColdFlushCleanup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockdatabaseCleanupManagerMockRecorder) Report

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Report indicates an expected call of Report

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockdatabaseCleanupManagerMockRecorder) WarmFlushCleanup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockdatabaseCleanupManagerMockRecorder) WarmFlushCleanup(t, isBootstrapped interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          WarmFlushCleanup indicates an expected call of WarmFlushCleanup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type MockdatabaseColdFlushManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type MockdatabaseColdFlushManager struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            MockdatabaseColdFlushManager is a mock of databaseColdFlushManager interface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewMockdatabaseColdFlushManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewMockdatabaseColdFlushManager(ctrl *gomock.Controller) *MockdatabaseColdFlushManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NewMockdatabaseColdFlushManager creates a new mock instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockdatabaseColdFlushManager) ColdFlushCleanup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *MockdatabaseColdFlushManager) ColdFlushCleanup(t time.Time, isBootstrapped bool) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ColdFlushCleanup mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockdatabaseColdFlushManager) Disable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *MockdatabaseColdFlushManager) Disable() fileOpStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Disable mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockdatabaseColdFlushManager) EXPECT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    EXPECT returns an object that allows the caller to indicate expected use

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockdatabaseColdFlushManager) Enable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *MockdatabaseColdFlushManager) Enable() fileOpStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enable mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockdatabaseColdFlushManager) Report

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *MockdatabaseColdFlushManager) Report()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Report mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockdatabaseColdFlushManager) Run

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Run mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockdatabaseColdFlushManager) Status

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *MockdatabaseColdFlushManager) Status() fileOpStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Status mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockdatabaseColdFlushManager) WarmFlushCleanup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *MockdatabaseColdFlushManager) WarmFlushCleanup(t time.Time, isBootstrapped bool) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              WarmFlushCleanup mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MockdatabaseColdFlushManagerMockRecorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MockdatabaseColdFlushManagerMockRecorder struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                MockdatabaseColdFlushManagerMockRecorder is the mock recorder for MockdatabaseColdFlushManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockdatabaseColdFlushManagerMockRecorder) ColdFlushCleanup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (mr *MockdatabaseColdFlushManagerMockRecorder) ColdFlushCleanup(t, isBootstrapped interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ColdFlushCleanup indicates an expected call of ColdFlushCleanup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockdatabaseColdFlushManagerMockRecorder) Disable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Disable indicates an expected call of Disable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockdatabaseColdFlushManagerMockRecorder) Enable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enable indicates an expected call of Enable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockdatabaseColdFlushManagerMockRecorder) Report

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Report indicates an expected call of Report

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockdatabaseColdFlushManagerMockRecorder) Run

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockdatabaseColdFlushManagerMockRecorder) Run(t interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Run indicates an expected call of Run

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockdatabaseColdFlushManagerMockRecorder) Status

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Status indicates an expected call of Status

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockdatabaseColdFlushManagerMockRecorder) WarmFlushCleanup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (mr *MockdatabaseColdFlushManagerMockRecorder) WarmFlushCleanup(t, isBootstrapped interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              WarmFlushCleanup indicates an expected call of WarmFlushCleanup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MockdatabaseFileSystemManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MockdatabaseFileSystemManager struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                MockdatabaseFileSystemManager is a mock of databaseFileSystemManager interface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewMockdatabaseFileSystemManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewMockdatabaseFileSystemManager(ctrl *gomock.Controller) *MockdatabaseFileSystemManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NewMockdatabaseFileSystemManager creates a new mock instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockdatabaseFileSystemManager) Disable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *MockdatabaseFileSystemManager) Disable() fileOpStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Disable mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockdatabaseFileSystemManager) EXPECT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      EXPECT returns an object that allows the caller to indicate expected use

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockdatabaseFileSystemManager) Enable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *MockdatabaseFileSystemManager) Enable() fileOpStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enable mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockdatabaseFileSystemManager) Flush

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Flush mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockdatabaseFileSystemManager) LastSuccessfulSnapshotStartTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *MockdatabaseFileSystemManager) LastSuccessfulSnapshotStartTime() (time0.UnixNano, bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            LastSuccessfulSnapshotStartTime mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockdatabaseFileSystemManager) Report

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *MockdatabaseFileSystemManager) Report()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Report mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockdatabaseFileSystemManager) Run

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *MockdatabaseFileSystemManager) Run(t time.Time, runType runType, forceType forceType) bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Run mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockdatabaseFileSystemManager) Status

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *MockdatabaseFileSystemManager) Status() fileOpStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Status mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MockdatabaseFileSystemManagerMockRecorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MockdatabaseFileSystemManagerMockRecorder struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    MockdatabaseFileSystemManagerMockRecorder is the mock recorder for MockdatabaseFileSystemManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockdatabaseFileSystemManagerMockRecorder) Disable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Disable indicates an expected call of Disable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockdatabaseFileSystemManagerMockRecorder) Enable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enable indicates an expected call of Enable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockdatabaseFileSystemManagerMockRecorder) Flush

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockdatabaseFileSystemManagerMockRecorder) Flush(t interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Flush indicates an expected call of Flush

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockdatabaseFileSystemManagerMockRecorder) LastSuccessfulSnapshotStartTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (mr *MockdatabaseFileSystemManagerMockRecorder) LastSuccessfulSnapshotStartTime() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            LastSuccessfulSnapshotStartTime indicates an expected call of LastSuccessfulSnapshotStartTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockdatabaseFileSystemManagerMockRecorder) Report

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Report indicates an expected call of Report

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockdatabaseFileSystemManagerMockRecorder) Run

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (mr *MockdatabaseFileSystemManagerMockRecorder) Run(t, runType, forceType interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Run indicates an expected call of Run

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockdatabaseFileSystemManagerMockRecorder) Status

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Status indicates an expected call of Status

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MockdatabaseFlushManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MockdatabaseFlushManager struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    MockdatabaseFlushManager is a mock of databaseFlushManager interface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewMockdatabaseFlushManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewMockdatabaseFlushManager(ctrl *gomock.Controller) *MockdatabaseFlushManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NewMockdatabaseFlushManager creates a new mock instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockdatabaseFlushManager) EXPECT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        EXPECT returns an object that allows the caller to indicate expected use

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockdatabaseFlushManager) Flush

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *MockdatabaseFlushManager) Flush(startTime time.Time) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Flush mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockdatabaseFlushManager) LastSuccessfulSnapshotStartTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *MockdatabaseFlushManager) LastSuccessfulSnapshotStartTime() (time0.UnixNano, bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            LastSuccessfulSnapshotStartTime mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockdatabaseFlushManager) Report

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *MockdatabaseFlushManager) Report()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Report mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MockdatabaseFlushManagerMockRecorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MockdatabaseFlushManagerMockRecorder struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                MockdatabaseFlushManagerMockRecorder is the mock recorder for MockdatabaseFlushManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockdatabaseFlushManagerMockRecorder) Flush

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (mr *MockdatabaseFlushManagerMockRecorder) Flush(startTime interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Flush indicates an expected call of Flush

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockdatabaseFlushManagerMockRecorder) LastSuccessfulSnapshotStartTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (mr *MockdatabaseFlushManagerMockRecorder) LastSuccessfulSnapshotStartTime() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    LastSuccessfulSnapshotStartTime indicates an expected call of LastSuccessfulSnapshotStartTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockdatabaseFlushManagerMockRecorder) Report

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Report indicates an expected call of Report

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MockdatabaseMediator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MockdatabaseMediator struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        MockdatabaseMediator is a mock of databaseMediator interface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewMockdatabaseMediator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewMockdatabaseMediator(ctrl *gomock.Controller) *MockdatabaseMediator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NewMockdatabaseMediator creates a new mock instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockdatabaseMediator) Bootstrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *MockdatabaseMediator) Bootstrap() (BootstrapResult, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Bootstrap mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockdatabaseMediator) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *MockdatabaseMediator) Close() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Close mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockdatabaseMediator) DisableFileOpsAndWait

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *MockdatabaseMediator) DisableFileOpsAndWait()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                DisableFileOpsAndWait mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockdatabaseMediator) EXPECT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  EXPECT returns an object that allows the caller to indicate expected use

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockdatabaseMediator) EnableFileOps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *MockdatabaseMediator) EnableFileOps()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    EnableFileOps mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockdatabaseMediator) IsBootstrapped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *MockdatabaseMediator) IsBootstrapped() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      IsBootstrapped mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockdatabaseMediator) LastBootstrapCompletionTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *MockdatabaseMediator) LastBootstrapCompletionTime() (time0.UnixNano, bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        LastBootstrapCompletionTime mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockdatabaseMediator) LastSuccessfulSnapshotStartTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *MockdatabaseMediator) LastSuccessfulSnapshotStartTime() (time0.UnixNano, bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          LastSuccessfulSnapshotStartTime mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockdatabaseMediator) Open

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *MockdatabaseMediator) Open() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Open mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockdatabaseMediator) RegisterBackgroundProcess

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *MockdatabaseMediator) RegisterBackgroundProcess(process BackgroundProcess) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RegisterBackgroundProcess mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockdatabaseMediator) Report

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *MockdatabaseMediator) Report()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Report mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockdatabaseMediator) Tick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *MockdatabaseMediator) Tick(forceType forceType, startTime time.Time) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Tick mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MockdatabaseMediatorMockRecorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MockdatabaseMediatorMockRecorder struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    MockdatabaseMediatorMockRecorder is the mock recorder for MockdatabaseMediator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockdatabaseMediatorMockRecorder) Bootstrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (mr *MockdatabaseMediatorMockRecorder) Bootstrap() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Bootstrap indicates an expected call of Bootstrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockdatabaseMediatorMockRecorder) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Close indicates an expected call of Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockdatabaseMediatorMockRecorder) DisableFileOpsAndWait

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockdatabaseMediatorMockRecorder) DisableFileOpsAndWait() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          DisableFileOpsAndWait indicates an expected call of DisableFileOpsAndWait

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockdatabaseMediatorMockRecorder) EnableFileOps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (mr *MockdatabaseMediatorMockRecorder) EnableFileOps() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            EnableFileOps indicates an expected call of EnableFileOps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockdatabaseMediatorMockRecorder) IsBootstrapped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (mr *MockdatabaseMediatorMockRecorder) IsBootstrapped() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              IsBootstrapped indicates an expected call of IsBootstrapped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockdatabaseMediatorMockRecorder) LastBootstrapCompletionTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (mr *MockdatabaseMediatorMockRecorder) LastBootstrapCompletionTime() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                LastBootstrapCompletionTime indicates an expected call of LastBootstrapCompletionTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockdatabaseMediatorMockRecorder) LastSuccessfulSnapshotStartTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (mr *MockdatabaseMediatorMockRecorder) LastSuccessfulSnapshotStartTime() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  LastSuccessfulSnapshotStartTime indicates an expected call of LastSuccessfulSnapshotStartTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockdatabaseMediatorMockRecorder) Open

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Open indicates an expected call of Open

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockdatabaseMediatorMockRecorder) RegisterBackgroundProcess

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (mr *MockdatabaseMediatorMockRecorder) RegisterBackgroundProcess(process interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      RegisterBackgroundProcess indicates an expected call of RegisterBackgroundProcess

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockdatabaseMediatorMockRecorder) Report

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Report indicates an expected call of Report

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockdatabaseMediatorMockRecorder) Tick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockdatabaseMediatorMockRecorder) Tick(forceType, startTime interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Tick indicates an expected call of Tick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type MockdatabaseMockRecorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type MockdatabaseMockRecorder struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            MockdatabaseMockRecorder is the mock recorder for Mockdatabase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockdatabaseMockRecorder) AggregateQuery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (mr *MockdatabaseMockRecorder) AggregateQuery(ctx, namespace, query, opts interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              AggregateQuery indicates an expected call of AggregateQuery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockdatabaseMockRecorder) AggregateTiles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (mr *MockdatabaseMockRecorder) AggregateTiles(ctx, sourceNsID, targetNsID, opts interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                AggregateTiles indicates an expected call of AggregateTiles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockdatabaseMockRecorder) AssignShardSet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (mr *MockdatabaseMockRecorder) AssignShardSet(shardSet interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  AssignShardSet indicates an expected call of AssignShardSet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockdatabaseMockRecorder) BatchProcessWideQuery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (mr *MockdatabaseMockRecorder) BatchProcessWideQuery(ctx, n, query, batchProcessor, opts interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    BatchProcessWideQuery indicates an expected call of BatchProcessWideQuery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockdatabaseMockRecorder) BatchWriter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (mr *MockdatabaseMockRecorder) BatchWriter(namespace, batchSize interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      BatchWriter indicates an expected call of BatchWriter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockdatabaseMockRecorder) Bootstrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (mr *MockdatabaseMockRecorder) Bootstrap() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Bootstrap indicates an expected call of Bootstrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockdatabaseMockRecorder) BootstrapState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockdatabaseMockRecorder) BootstrapState() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          BootstrapState indicates an expected call of BootstrapState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockdatabaseMockRecorder) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (mr *MockdatabaseMockRecorder) Close() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Close indicates an expected call of Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockdatabaseMockRecorder) FetchBlocks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (mr *MockdatabaseMockRecorder) FetchBlocks(ctx, namespace, shard, id, starts interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              FetchBlocks indicates an expected call of FetchBlocks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockdatabaseMockRecorder) FetchBlocksMetadataV2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (mr *MockdatabaseMockRecorder) FetchBlocksMetadataV2(ctx, namespace, shard, start, end, limit, pageToken, opts interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                FetchBlocksMetadataV2 indicates an expected call of FetchBlocksMetadataV2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockdatabaseMockRecorder) FlushState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (mr *MockdatabaseMockRecorder) FlushState(namespace, shardID, blockStart interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  FlushState indicates an expected call of FlushState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockdatabaseMockRecorder) IsBootstrapped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (mr *MockdatabaseMockRecorder) IsBootstrapped() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    IsBootstrapped indicates an expected call of IsBootstrapped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockdatabaseMockRecorder) IsBootstrappedAndDurable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (mr *MockdatabaseMockRecorder) IsBootstrappedAndDurable() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      IsBootstrappedAndDurable indicates an expected call of IsBootstrappedAndDurable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockdatabaseMockRecorder) IsOverloaded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (mr *MockdatabaseMockRecorder) IsOverloaded() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        IsOverloaded indicates an expected call of IsOverloaded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockdatabaseMockRecorder) Namespace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockdatabaseMockRecorder) Namespace(ns interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Namespace indicates an expected call of Namespace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockdatabaseMockRecorder) Namespaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (mr *MockdatabaseMockRecorder) Namespaces() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Namespaces indicates an expected call of Namespaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockdatabaseMockRecorder) Open

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (mr *MockdatabaseMockRecorder) Open() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Open indicates an expected call of Open

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockdatabaseMockRecorder) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (mr *MockdatabaseMockRecorder) Options() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Options indicates an expected call of Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockdatabaseMockRecorder) OwnedNamespaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (mr *MockdatabaseMockRecorder) OwnedNamespaces() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  OwnedNamespaces indicates an expected call of OwnedNamespaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockdatabaseMockRecorder) QueryIDs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (mr *MockdatabaseMockRecorder) QueryIDs(ctx, namespace, query, opts interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    QueryIDs indicates an expected call of QueryIDs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockdatabaseMockRecorder) ReadEncoded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (mr *MockdatabaseMockRecorder) ReadEncoded(ctx, namespace, id, start, end interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ReadEncoded indicates an expected call of ReadEncoded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockdatabaseMockRecorder) Repair

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (mr *MockdatabaseMockRecorder) Repair() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Repair indicates an expected call of Repair

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockdatabaseMockRecorder) ShardSet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockdatabaseMockRecorder) ShardSet() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ShardSet indicates an expected call of ShardSet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockdatabaseMockRecorder) Terminate