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 

                                              func (m *MockBackgroundProcess) EXPECT() *MockBackgroundProcessMockRecorder

                                                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 

                                                        func (mr *MockBackgroundProcessMockRecorder) Report() *gomock.Call

                                                          Report indicates an expected call of Report

                                                          func (*MockBackgroundProcessMockRecorder) Start 

                                                          func (mr *MockBackgroundProcessMockRecorder) Start() *gomock.Call

                                                            Start indicates an expected call of Start

                                                            func (*MockBackgroundProcessMockRecorder) Stop 

                                                            func (mr *MockBackgroundProcessMockRecorder) Stop() *gomock.Call

                                                              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 

                                                                                  func (m *MockDatabase) EXPECT() *MockDatabaseMockRecorder

                                                                                    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 

                                                                                                                                                                                              func (m *MockIndexedErrorHandler) EXPECT() *MockIndexedErrorHandlerMockRecorder

                                                                                                                                                                                                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 

                                                                                                                                                                                                            func (m *MockMemoryTracker) EXPECT() *MockMemoryTrackerMockRecorder

                                                                                                                                                                                                              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 

                                                                                                                                                                                                                                        func (m *MockNamespace) EXPECT() *MockNamespaceMockRecorder

                                                                                                                                                                                                                                          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 

                                                                                                                                                                                                                                                                        func (m *MockNamespaceHooks) EXPECT() *MockNamespaceHooksMockRecorder

                                                                                                                                                                                                                                                                          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 

                                                                                                                                                                                                                                                                                    func (m *MockNamespaceIndex) AggregateQuery(ctx context.Context, query index.Query, opts index.AggregationOptions) (index.AggregateQueryResult, error)

                                                                                                                                                                                                                                                                                      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 

                                                                                                                                                                                                                                                                                                          func (m *MockNamespaceIndex) EXPECT() *MockNamespaceIndexMockRecorder

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

                                                                                                                                                                                                                                                                                                            func (*MockNamespaceIndex) Query 

                                                                                                                                                                                                                                                                                                            func (m *MockNamespaceIndex) Query(ctx context.Context, query index.Query, opts index.QueryOptions) (index.QueryResult, error)

                                                                                                                                                                                                                                                                                                              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 

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

                                                                                                                                                                                                                                                                                                                                              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 

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

                                                                                                                                                                                                                                                                                                                                                                        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 

                                                                                                                                                                                                                                                                                                                                                                                                    func (m *MockOnColdFlush) EXPECT() *MockOnColdFlushMockRecorder

                                                                                                                                                                                                                                                                                                                                                                                                      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 

                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *MockOnColdFlushNamespace) EXPECT() *MockOnColdFlushNamespaceMockRecorder

                                                                                                                                                                                                                                                                                                                                                                                                                    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 

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

                                                                                                                                                                                                                                                                                                                                                                                                                            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 

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *MockShardColdFlush) EXPECT() *MockShardColdFlushMockRecorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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 

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (mr *MockShardColdFlushMockRecorder) Done() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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 

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *MockTileAggregator) EXPECT() *MockTileAggregatorMockRecorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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 

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *Mockdatabase) EXPECT() *MockdatabaseMockRecorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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 

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Bootstrap mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockdatabaseBootstrapManager) EXPECT 

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *MockdatabaseBootstrapManager) EXPECT() *MockdatabaseBootstrapManagerMockRecorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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 

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Bootstrap indicates an expected call of Bootstrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockdatabaseBootstrapManagerMockRecorder) IsBootstrapped 

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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 

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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 

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *MockdatabaseCleanupManager) EXPECT() *MockdatabaseCleanupManagerMockRecorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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 

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (mr *MockdatabaseCleanupManagerMockRecorder) Report() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *MockdatabaseColdFlushManager) EXPECT() *MockdatabaseColdFlushManagerMockRecorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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 

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *MockdatabaseColdFlushManager) Run(t time.Time) bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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 

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (mr *MockdatabaseColdFlushManagerMockRecorder) Disable() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Disable indicates an expected call of Disable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockdatabaseColdFlushManagerMockRecorder) Enable 

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (mr *MockdatabaseColdFlushManagerMockRecorder) Enable() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enable indicates an expected call of Enable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockdatabaseColdFlushManagerMockRecorder) Report 

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (mr *MockdatabaseColdFlushManagerMockRecorder) Report() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (mr *MockdatabaseColdFlushManagerMockRecorder) Status() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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 

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *MockdatabaseFileSystemManager) EXPECT() *MockdatabaseFileSystemManagerMockRecorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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 

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *MockdatabaseFileSystemManager) Flush(t time.Time) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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 

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Disable indicates an expected call of Disable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockdatabaseFileSystemManagerMockRecorder) Enable 

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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 

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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 

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *MockdatabaseFlushManager) EXPECT() *MockdatabaseFlushManagerMockRecorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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 

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *MockdatabaseMediator) EXPECT() *MockdatabaseMediatorMockRecorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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 

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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 

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (mr *MockdatabaseMockReco