Package com.illumon.iris.db.tables.dataimport.importstate.lastby

Class LastByTableImportState<KEY_TYPE>

java.lang.Object
com.illumon.iris.db.tables.dataimport.importstate.lastby.LastByTableImportState<KEY_TYPE>
All Implemented Interfaces:
ImportState, LiveTable, Externalizable, Serializable
public class LastByTableImportState<KEY_TYPE>
extends Object
implements ImportState, LiveTable, Externalizable

ImportState that publishes a last-by view of the data being imported, producing a table intended for concurrent usage by clients with access to the importing process.

See Also:
Serialized Form

  • Constructor Details

  • Method Details

    • getTableMap

      public static LastByTableImportState.ResultTableMap getTableMap​(@NotNull TableKey tableKey)
      Get a LocalTableMap keyed by TableLocationKey of DynamicTables that contain only an Index and no user-facing ColumnSources. The contents of the result are produced by LastByImportState instances for the supplied TableKey and null name
      Parameters:
      tableKey - The key
      Returns:
      The table map, possibly empty

    • getTableMap

      public static LastByTableImportState.ResultTableMap getTableMap​(@NotNull TableKey tableKey, String name)
      Get a LocalTableMap keyed by TableLocationKey of DynamicTables that contain only an Index and no user-facing ColumnSources. The contents of the result are produced by LastByTableImportState instances for the supplied TableKey and name. Distinct names should be used for distinct last-by import state views of the same table. TODO: Consider whether we should implement a LocalTableMap equivalent that stores weakly-reachable values.
      Parameters:
      tableKey - The key
      name - The name
      Returns:
      The table map, possibly empty

    • writeExternal

      public void writeExternal​(@NotNull ObjectOutput out) throws IOException
      Specified by:
      writeExternal in interface Externalizable
      Throws:
      IOException

    • readExternal

      public void readExternal​(@NotNull ObjectInput in) throws IOException, ClassNotFoundException
      Specified by:
      readExternal in interface Externalizable
      Throws:
      IOException
      ClassNotFoundException

    • newRowForKey

      public final void newRowForKey​(KEY_TYPE key)

      Observe a new row for the specified key, which may be compound.

      It is required that users of this method render their key immutable.

      The recommended way to do so is to invoke prepareElement(Object) on single element keys, or construct a CanonicalizableTuple directly from primitive elements and the result of prepareElement(Object) on all Object elements of a compound key. Alternatively, prepareKey(Object) tries to do the correct thing, but may not be as performant. Users must not use SmartKey or Pair directly as keys or indirectly as elements.

      Parameters:
      key - The key

    • skipRow

      public final void skipRow()
      Observe the passing of a row that will not be a part of the last-by view.

    • newRow

      public final void newRow​(Object keyElement)

      Observe a new row for the specified uni-element key.

      Note that key elements must be either functionally immutable or instances of StringCompatible.

      It is recommended that users of compound keys use newRowForKey(Object) coupled with appropriate key and/or key element preparation.

      Parameters:
      keyElement - The key element

    • newRow

      public final void newRow​(Object keyElement1, Object keyElement2)

      Observe a new row for the specified bi-element key.

      Note that key elements must be either functionally immutable or instances of StringCompatible.

      It is recommended that users of compound keys use newRowForKey(Object) coupled with appropriate key and/or key element preparation.

      Parameters:
      keyElement1 - The first element that makes up the bi-element key
      keyElement2 - The second element that makes up the bi-element key

    • newRow

      public final void newRow​(Object keyElement1, Object keyElement2, Object keyElement3)

      Observe a new row for the specified tri-element key.

      Note that key elements must be either functionally immutable or instances of StringCompatible.

      It is recommended that users of compound keys use newRowForKey(Object) coupled with appropriate key and/or key element preparation.

      Parameters:
      keyElement1 - The first element that makes up the tri-element key
      keyElement2 - The second element that makes up the tri-element key
      keyElement3 - The second element that makes up the tri-element key

    • newRow

      public final void newRow​(Object... keyElements)

      Observe a new row for the specified multi-element key.

      Note that key elements must be either functionally immutable or instances of StringCompatible.

      It is recommended that users of compound keys use newRowForKey(Object) coupled with appropriate key and/or key element preparation.

      Parameters:
      keyElements - The elements that makes up the multi-element key

    • prepareElement

      public final Object prepareElement​(@Nullable Object element)
      Prepare a key element (that is, a component of a compound key) before using it to build a key that will be passed to newRow(Object). This entails canonicalization, and converting StringCompatible instances to Strings.
      Parameters:
      element - The element to prepare
      Returns:
      The preparation result

    • prepareKey

      public final KEY_TYPE prepareKey​(@Nullable KEY_TYPE key)
      Prepare a key for inclusion in the import state.
      Parameters:
      key - The key
      Returns:
      The prepared result

    • getImportDetails

      @NotNull public Properties getImportDetails()
      Specified by:
      getImportDetails in interface ImportState

    • ensureInitialized

      public void ensureInitialized​(@NotNull FullTableLocationKey locationKey)
      Description copied from interface: ImportState
      Called when non-import code needs to ensure that an ImportState's internals have been initialized because of their side effects. Must not interfere with concurrent data ingestion in the same process. Generally should be treated as a query operation, and the caller should hold the LiveTableMonitor lock.
      Specified by:
      ensureInitialized in interface ImportState
      Parameters:
      locationKey - The full table location key of the location whose ImportState is being initialized

    • onResume

      public void onResume​(@NotNull FullTableLocationKey locationKey)
      Description copied from interface: ImportState
      Called when data ingestion is resumed for the location observed by this ImportState.
      Specified by:
      onResume in interface ImportState
      Parameters:
      locationKey - The full table location key of the location that has been resumed

    • onTruncate

      public void onTruncate​(@NotNull FullTableLocationKey locationKey)
      Description copied from interface: ImportState
      Called when the underlying table location has been truncated. Useful for resetting any in-memory state that may otherwise linger inappropriately.
      Specified by:
      onTruncate in interface ImportState
      Parameters:
      locationKey - The full table location key of the location that has been truncated

    • onFlush

      public void onFlush()
      Description copied from interface: ImportState
      Called when the data ingestion process for the location observed by this ImportState is flushed (properly, after it has been flushed and when the resulting size has been made visible if applicable).
      Specified by:
      onFlush in interface ImportState

    • onRelease

      public void onRelease()
      Description copied from interface: ImportState
      Call when the data ingestion process for the location observed by this ImportState is finished, temporarily or permanently, in an inconsistent state.
      Specified by:
      onRelease in interface ImportState

    • onClose

      public void onClose()
      Description copied from interface: ImportState
      Called when the data ingestion process for the location observed by this ImportState is finished, temporarily or permanently, in a consistent state.
      Specified by:
      onClose in interface ImportState

    • refresh

      public void refresh()
      Description copied from interface: LiveTable
      Refresh this LiveTable.
      Specified by:
      refresh in interface LiveTable