org.hibernate.search

## Interface MassIndexer

- All Known Subinterfaces:
    MassIndexerWithTenant
  All Known Implementing Classes:
    MassIndexerImpl

      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 Summary

    All Methods Instance Methods Abstract Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `MassIndexer` | `batchSizeToLoadObjects(int batchSize)` Sets the batch size used to load the root entities.
    `MassIndexer` | `cacheMode(CacheMode cacheMode)` Sets the cache interaction mode for the data loading tasks.
    `MassIndexer` | `idFetchSize(int idFetchSize)` Specifies the fetch size to be used when loading primary keys if objects to be indexed.
    `MassIndexer` | `limitIndexedObjectsTo(long maximum)` EXPERIMENTAL method: will probably change Will stop indexing after having indexed a set amount of objects.
    `MassIndexer` | `optimizeAfterPurge(boolean optimize)` If index optimization should be run before starting, after the purgeAll.
    `MassIndexer` | `optimizeOnFinish(boolean optimize)` If index optimization has to be started at the end of the indexing process.
    `MassIndexer` | `progressMonitor(MassIndexerProgressMonitor monitor)` Override the default `MassIndexerProgressMonitor`.
    `MassIndexer` | `purgeAllOnStart(boolean purgeAll)` If all entities should be removed from the index before starting using purgeAll.
    `Future<?>` | `start()` Starts the indexing process in background (asynchronous).
    `void` | `startAndWait()` Starts the indexing process, and then block until it's finished.
    `MassIndexer` | `threadsForSubsequentFetching(int numberOfThreads)` Deprecated. Being ignored: this method will be removed.
    `MassIndexer` | `threadsToLoadObjects(int numberOfThreads)` Set the number of threads to be used to load the root entities.
    `MassIndexer` | `transactionTimeout(int timeoutInSeconds)` Timeout of transactions for loading ids and entities to be re-indexed.
    `MassIndexer` | `typesToIndexInParallel(int threadsToIndexObjects)` Sets the number of entity types to be indexed in parallel.

- - ### Method Detail

    - #### 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)

      Set 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

    - #### threadsForSubsequentFetching

          @Deprecated
          MassIndexer threadsForSubsequentFetching(int numberOfThreads)

      Deprecated. Being ignored: this method will be removed.
      Deprecated: value is ignored.
      Parameters:
        `numberOfThreads` - the number of threads
      Returns:
        `this` for method chaining

    - #### progressMonitor

          MassIndexer progressMonitor(MassIndexerProgressMonitor monitor)

      Override the default `MassIndexerProgressMonitor`.
      Parameters:
        `monitor` - this instance will receive updates about the massindexing progress.
      Returns:
        `this` for method chaining

    - #### cacheMode

          MassIndexer cacheMode(CacheMode cacheMode)

      Sets the cache interaction mode for the data loading tasks. Defaults to `CacheMode.IGNORE`.
      Parameters:
        `cacheMode` - the cache interaction mode
      Returns:
        `this` for method chaining

    - #### optimizeOnFinish

          MassIndexer optimizeOnFinish(boolean optimize)

      If index optimization has to be started at the end of the indexing process. Defaults to `true`.
      Parameters:
        `optimize` - `true` to enable the index optimization at the end of the indexing process
      Returns:
        `this` for method chaining

    - #### optimizeAfterPurge

          MassIndexer optimizeAfterPurge(boolean optimize)

      If index optimization should be run before starting, after the purgeAll. Has no effect if `purgeAll` is set to false. Defaults to `true`.
      Parameters:
        `optimize` - `true` to enable the index optimization after purge
      Returns:
        `this` for method chaining

    - #### purgeAllOnStart

          MassIndexer purgeAllOnStart(boolean purgeAll)

      If all entities should be removed from the index before starting using purgeAll. Set it to false only if you know there are no entities in the index: otherwise search results may be duplicated. Defaults to true.
      Parameters:
        `purgeAll` - if `true` all entities will be removed from the index before starting the indexing
      Returns:
        `this` for method chaining

    - #### limitIndexedObjectsTo

          MassIndexer limitIndexedObjectsTo(long maximum)

      EXPERIMENTAL method: will probably change Will stop indexing after having indexed a set amount of objects. As a results the index will not be consistent with the database: use only for testing on an (undefined) subset of database data.
      Parameters:
        `maximum` - the maximum number of objects to index
      Returns:
        `this` for method chaining

    - #### start

          Future<?> start()

      Starts the indexing process in background (asynchronous). Can be called only once.
      Returns:
        a Future to control the indexing task.

    - #### startAndWait

          void startAndWait()
                     throws InterruptedException

      Starts the indexing process, and then block until it's finished. Can be called only once.
      Throws:
        `InterruptedException` - if the current thread is interrupted while waiting.

    - #### idFetchSize

          MassIndexer idFetchSize(int idFetchSize)

      Specifies the fetch size to be used when loading primary keys if objects to be indexed. Some databases accept special values, for example MySQL might benefit from using `Integer.MIN_VALUE` otherwise it will attempt to preload everything in memory.
      Parameters:
        `idFetchSize` - the fetch size to be used when loading primary keys
      Returns:
        `this` for method chaining

    - #### transactionTimeout

          MassIndexer transactionTimeout(int timeoutInSeconds)

      Timeout of transactions for loading ids and entities to be re-indexed. Specify a timeout which is long enough to load and index all entities of the type with the most instances, taking into account the configured batch size and number of threads to load objects.

      Only supported in JTA-compatible environments.

      Parameters:
        `timeoutInSeconds` - the transaction timeout in seconds; If no value is given, the global default timeout of the JTA environment applies.
      Returns:
        `this` for method chaining

Copyright © 2006-2017 Red Hat, Inc. All Rights Reserved