Package org.hibernate.search.mapper.pojo.standalone.massindexing

Interface MassIndexer

@Incubating public interface MassIndexer
A MassIndexer is useful to rebuild the indexes from the data contained in the database. This process is expensive: all indexed entities and their indexedEmbedded properties are scrolled from database.
Author:
Sanne Grinovero

  • Method Details

    • typesToIndexInParallel

      MassIndexer typesToIndexInParallel(int threadsToIndexObjects)
      Sets the number of entity types to be indexed in parallel.

      Defaults to 1.

      Parameters:
      threadsToIndexObjects - number of entity types to be indexed in parallel
      Returns:
      this for method chaining

    • threadsToLoadObjects

      MassIndexer threadsToLoadObjects(int numberOfThreads)
      Sets the number of threads to be used to load the root entities.
      Parameters:
      numberOfThreads - the number of threads
      Returns:
      this for method chaining

    • batchSizeToLoadObjects

      MassIndexer batchSizeToLoadObjects(int batchSize)
      Sets the batch size used to load the root entities.
      Parameters:
      batchSize - the batch size
      Returns:
      this for method chaining

    • mergeSegmentsOnFinish

      MassIndexer mergeSegmentsOnFinish(boolean enable)
      Merges each index into a single segment after indexing.

      Defaults to false.

      Parameters:
      enable - true to enable this operation, false to disable it.
      Returns:
      this for method chaining

    • mergeSegmentsAfterPurge

      MassIndexer mergeSegmentsAfterPurge(boolean enable)
      Merges each index into a single segment after the initial index purge, just before indexing.

      Defaults to true for indexes that support it, false for other indexes.

      This setting has no effect if purgeAllOnStart is set to false.

      Parameters:
      enable - true to enable this operation, false to disable it.
      Returns:
      this for method chaining

    • dropAndCreateSchemaOnStart

      MassIndexer dropAndCreateSchemaOnStart(boolean dropAndCreateSchema)
      Drops the indexes and their schema (if they exist) and re-creates them before indexing.

      Indexes will be unavailable for a short time during the dropping and re-creation, so this should only be used when failures of concurrent operations on the indexes (indexing caused by entity changes, ...) are acceptable.

      This should be used when the existing schema is known to be obsolete, for example when the Hibernate Search mapping changed and some fields now have a different type, a different analyzer, new capabilities (projectable, ...), etc.

      This may also be used when the schema is up-to-date, since it can be faster than a purge on large indexes.

      Defaults to false.

      Parameters:
      dropAndCreateSchema - if true the indexes and their schema will be dropped then re-created before starting the indexing
      Returns:
      this for method chaining

    • purgeAllOnStart

      MassIndexer purgeAllOnStart(boolean purgeAll)
      Removes all entities from the indexes before indexing.

      Set this to false only if you know there are no entities in the indexes: otherwise search results may be duplicated.

      Default value depends on dropAndCreateSchemaOnStart(boolean). Defaults to false if the mass indexer is configured to drop and create the schema on start, to true otherwise.

      Parameters:
      purgeAll - if true all entities will be removed from the indexes before starting the indexing
      Returns:
      this for method chaining

    • start

      CompletionStage<?> start()
      Starts the indexing process in background (asynchronous).

      May only be called once.

      Returns:
      a CompletionStage to react to the completion of the indexing task. Call CompletionStage.toCompletableFuture() on the returned object to convert it to a CompletableFuture (which implements Future).

    • startAndWait

      void startAndWait() throws InterruptedException
      Starts the indexing process, and then block until it's finished.

      May only be called once.

      Throws:
      InterruptedException - if the current thread is interrupted while waiting.

    • monitor

      MassIndexer monitor(MassIndexingMonitor monitor)
      Sets the MassIndexingMonitor.

      The default monitor just logs the progress.

      Parameters:
      monitor - The monitor that will track mass indexing progress.
      Returns:
      this for method chaining

    • failureHandler

      MassIndexer failureHandler(MassIndexingFailureHandler failureHandler)
      Sets the MassIndexingFailureHandler.

      The default handler just forwards failures to the background failure handler.

      Parameters:
      failureHandler - The handler for failures occurring during mass indexing.
      Returns:
      this for method chaining

    • failureFloodingThreshold

      @Incubating MassIndexer failureFloodingThreshold(long threshold)
      Sets the threshold for failures that will be reported and sent to MassIndexingFailureHandler per indexed type. Any failures exceeding this number will be ignored. A count of such ignored failures together with the operation they belong to will be reported to the failure handler upon the completion of indexing process.
      Parameters:
      threshold - The number of failures during one mass indexing beyond which the failure handler will no longer be notified. This threshold is reached separately for each indexed type. Overrides the threshold defined by the failure handler itself.

      Defaults to 100 with the default failure handler.

      Returns:
      this for method chaining

    • context

      <T> MassIndexer context(Class<T> contextType, T context)
      Sets context for use by the loading strategies.

      The context can be retrieved through MassLoadingOptions.context(Class).

      Type Parameters:
      T - The type of context.
      Parameters:
      contextType - The type of context, used as a key to retrieve it from MassLoadingOptions.context(Class).
      context - The context instance.
      Returns:
      this for method chaining

    • environment

      @Incubating MassIndexer environment(MassIndexingEnvironment environment)
      Sets the MassIndexingEnvironment, which can set up an environment (thread locals, ...) in mass indexing threads.
      Parameters:
      environment - a component that gets a chance to set up e.g. ThreadLocals in mass indexing threads before mass indexing starts, and to remove them after mass indexing stops.
      See Also:

    • failFast

      @Incubating MassIndexer failFast(boolean failFast)
      Enables the fail-fast option for this mass indexer.

      With fail-fast option enabled, the mass indexer will request cancelling all internal mass-indexing processes right after the first error is reported to the MassIndexingFailureHandler.

      Parameters:
      failFast - Whether to enabled fail fast option for this mass indexer.
      Returns:
      this for method chaining