Package com.illumon.iris.db.v2

Class LocalTableMap

java.lang.Object
com.illumon.util.referencecounting.ReferenceCounted
com.illumon.iris.db.util.liveness.ReferenceCountedLivenessNode
com.illumon.iris.db.util.liveness.LivenessArtifact
com.illumon.iris.db.v2.TableMapImpl
com.illumon.iris.db.v2.LocalTableMap
All Implemented Interfaces:
com.fishlib.base.log.LogOutputAppendable, NotificationQueue.Dependency, Deflatable<TableMap>, LivenessManager, LivenessNode, LivenessReferent, DynamicNode, SystemicObject, TableMap, TransformableTableMap, Serializable
Direct Known Subclasses:
FilteredTableMap, LastByTableImportState.ResultTableMap
public class LocalTableMap extends TableMapImpl implements NotificationQueue.Dependency, SystemicObject
A TableMap implementation backed by a Map.
See Also:

  • Constructor Details

    • LocalTableMap

      public LocalTableMap(LocalTableMap.PopulateCallback populateCallback)
      Constructor to create an instance with an empty default map.
      Parameters:
      populateCallback - the callback that is invoked when populateKeys(Object...) is called

    • LocalTableMap

      public LocalTableMap(LocalTableMap.PopulateCallback populateCallback, TableDefinition constituentDefinition)
      Constructor to create an instance with an empty default map.
      Parameters:
      populateCallback - the callback that is invoked when populateKeys(Object...) is called
      constituentDefinition - the definition of the constituent tables (optional, but by providing it, a TableMap with no constituents can be merged)

  • Method Details

    • getCallback

      public LocalTableMap.PopulateCallback getCallback()

    • isSystemicObject

      public boolean isSystemicObject()
      Description copied from interface: SystemicObject
      Returns true if this is a systemically important object (see SystemicObjectTracker).
      Specified by:
      isSystemicObject in interface SystemicObject
      Returns:
      true if this is a systemically important object, false otherwise.

    • markSystemic

      public void markSystemic()
      Description copied from interface: SystemicObject
      Mark this object as systemically important.
      Specified by:
      markSystemic in interface SystemicObject

    • put

      public Table put(Object key, Table table)
      Add a table to the map with the given key. Return the previous value, if any.
      Parameters:
      key - the key to add
      table - the value to add
      Returns:
      the previous table for the given key

    • computeIfAbsent

      public Table computeIfAbsent(Object key, Function<Object,Table> tableFactory)

    • get

      public Table get(Object key)
      Description copied from interface: TableMap
      Gets a table with a given key. Note that this causes the current LivenessManager (see LivenessScopeStack) to manage the result if non-null.
      Specified by:
      get in interface TableMap
      Parameters:
      key - key
      Returns:
      table associated with the key, or null if the key is not present.

    • getWithTransform

      public Table getWithTransform(Object key, Function<Table,Table> transform)
      Description copied from interface: TableMap
      Gets a table with a given key, applying the specified transform before returning.
      Specified by:
      getWithTransform in interface TableMap
      Parameters:
      key - key
      Returns:
      table associated with the key, or null if the key is not present.

    • getKeySet

      public Object[] getKeySet()
      Description copied from interface: TableMap
      Gets the keys.
      Specified by:
      getKeySet in interface TableMap
      Returns:
      keys

    • values

      public Collection<Table> values()
      Description copied from interface: TableMap
      Gets the values.
      Specified by:
      values in interface TableMap
      Returns:
      values

    • size

      public int size()
      Description copied from interface: TableMap
      Number of tables in the map.
      Specified by:
      size in interface TableMap
      Returns:
      number of tables in the map.

    • populateKeys

      public TableMap populateKeys(Object... keys)
      Description copied from interface: TableMap
      When creating the table map, some of the keys that we would like to be there eventually may not exist. This call lets you pre-populate keys, so that at initialization time you can perform the appropriate joins, etc., on empty tables that you expect to be populated in the future.
      Specified by:
      populateKeys in interface TableMap
      Parameters:
      keys - the keys to add to the map
      Returns:
      this TableMap

    • removeKeys

      public void removeKeys(Object... keys)

    • containsKey

      public boolean containsKey(Object key)

    • entrySet

      public Collection<Map.Entry<Object,Table>> entrySet()
      Description copied from interface: TableMap
      Gets the entries.
      Specified by:
      entrySet in interface TableMap
      Returns:
      the entries

    • flatten

      public TableMap flatten()
      Description copied from interface: TableMap
      Flattens all of the result tables within the tablemap.
      Specified by:
      flatten in interface TableMap

    • preemptiveUpdatesTable

      public TableMap preemptiveUpdatesTable(int intervalMillis)
      Description copied from interface: TableMap
      Creates preemptive tables out of all of the result tables within the tablemap.
      Specified by:
      preemptiveUpdatesTable in interface TableMap
      Parameters:
      intervalMillis - update interval for the preemptive tables

    • apply

      public <R> R apply(com.fishlib.base.Function.Unary<R,TableMap> function)
      Description copied from interface: TableMap
      Applies a function to this tableMap. This is useful if you have a reference to a tableMap; but not the database and want to run a series of operations against the table map without each individual operation resulting in a remote method invocation.
      Specified by:
      apply in interface TableMap
      Type Parameters:
      R - the return type of function
      Parameters:
      function - the function to run, its single argument will be this table map.
      Returns:
      the return value of function

    • transformTables

      public TableMap transformTables(NotificationQueue.Dependency dependency, BiFunction<Object,Table,Table> function)

    • transformTablesWithKey

      public TableMap transformTablesWithKey(BiFunction<Object,Table,Table> function)
      Description copied from interface: TableMap
      Applies a transformation function on all tables in the TableMap, producing a new TableMap which will update as new keys are added.

      The function may be passed a sentinel key, which can be checked with TableMap.isSentinel(Object). On the sentinel key, the function will be passed in an empty table, and is expected to return an empty table of the proper definition. To avoid this sentinel invocation, callers can be explicit and use TableMap.transformTablesWithKey(TableDefinition, BiFunction).

      Specified by:
      transformTablesWithKey in interface TableMap
      Parameters:
      function - the bifunction to apply to each table in this TableMap
      Returns:
      a new TableMap where each table has had function applied

    • transformTablesWithKey

      public TableMap transformTablesWithKey(TableDefinition returnDefinition, BiFunction<Object,Table,Table> function)
      Description copied from interface: TableMap
      Applies a transformation function on all tables in the TableMap, producing a new TableMap which will update as new keys are added.
      Specified by:
      transformTablesWithKey in interface TableMap
      Parameters:
      returnDefinition - the table definition for the tables the function will return
      function - the bifunction to apply to each table in this TableMap
      Returns:
      a new TableMap where each table has had function applied

    • transformTablesWithKey

      public TableMap transformTablesWithKey(NotificationQueue.Dependency dependency, TableDefinition returnDefinition, BiFunction<Object,Table,Table> function)

    • transformTablesWithMap

      public TableMap transformTablesWithMap(TableMap other, BiFunction<Table,Table,Table> function)
      Description copied from interface: TableMap
      Applies a BiFunction function on all tables in this TableMap and otherMap that have matching keys, producing a new TableMap which will update as new keys are added. Only applies the function to tables which exist in both maps.
      Specified by:
      transformTablesWithMap in interface TableMap
      Parameters:
      other - the other TableMap
      function - the function to apply to each table in this TableMap, the tables in this map are the first argument the tables in the other map are the second argument.
      Returns:
      a new TableMap where each table has had function applied

    • asTable

      public Table asTable(boolean strictKeys, boolean allowCoalesce, boolean sanityCheckJoins)
      Description copied from interface: TransformableTableMap
      Create a Table out of this TableMap's values.

      Creates a proxy object that in many respects acts like a Table, you can perform many of the table operations on it, which are then applied using TableMap.transformTables(java.util.function.Function) or TableMap.transformTablesWithMap(TableMap, BiFunction) if the right hand side of an operation is another TableMap.

      The returned table acts as if it were an uncoalesced table; when two of our Proxy objects are operated on together, e.g., by a Table.join(com.illumon.iris.db.tables.Table)) operation, then tables with identical keys are used. If strictKeys is set, an error occurs if the two TableMaps do not have identical keySets.

      Supported operations include those which return a Table, LongSizedDataStructure.size(), Table.getDefinition() and operations to retrieve attributes. Operations which retrieve data (such as Table.getIndex()} or Table.getColumn(int) require a coalesce operation. If allowCoalesce is not set to true, then the coalescing operations will fail with an IllegalArgumentException.

      Specified by:
      asTable in interface TransformableTableMap
      Parameters:
      strictKeys - if we should fail when our RHS TableMap does not have the same keySet
      allowCoalesce - if we should allow this TableMap to be automatically coalesced into a table
      sanityCheckJoins - if we should sanity check join keys, meaning that we should refuse to perform any joins if the join keys would span two segments of the TableMap. This option is safer, but requires additional work on the query engine to perform the safety checks.
      Returns:
      a Table object that performs operations by segment

    • isMergeable

      public boolean isMergeable()

    • getConstituentDefinition

      public Optional<TableDefinition> getConstituentDefinition()

    • getConstituentDefinitionOrErr

      public TableDefinition getConstituentDefinitionOrErr()

    • merge

      public Table merge()
      Description copied from interface: TransformableTableMap
      Merges all of the component tables into a single Table.
      Specified by:
      merge in interface TransformableTableMap
      Returns:
      all of our component tables merged into a single Table.

    • setDependency

      public void setDependency(NotificationQueue.Dependency dependency)

    • satisfied

      public boolean satisfied(long step)
      Description copied from interface: NotificationQueue.Dependency
      Is this ancestor satisfied? Note that this method must be safe to call on any thread.
      Specified by:
      satisfied in interface NotificationQueue.Dependency
      Parameters:
      step - The step for which we are testing satisfaction
      Returns:
      Whether the dependency is satisfied on step (and will not fire subsequent notifications)

    • toString

      public String toString()
      Overrides:
      toString in class ReferenceCounted

    • destroy

      protected void destroy()
      Description copied from class: ReferenceCountedLivenessNode

      Attempt to release (destructively when necessary) resources held by this object. This may render the object unusable for subsequent operations. Implementations should be sure to call super.destroy().

      This is intended to only ever be used as a side effect of decreasing the reference count to 0.

      Overrides:
      destroy in class TableMapImpl

    • useGlobalTransformationThreadPool

      public boolean useGlobalTransformationThreadPool()
      Returns whether this LocalTableMap is configured to use the global transformation thread pool. Derived TableMaps will inherit this setting (but use their own thread pool).
      Returns:
      true if transformTables and transformTablesWithMap will use the global thread pool; false if they will use a private thread pool

    • setUseGlobalTransformationThreadPool

      public void setUseGlobalTransformationThreadPool(boolean useGlobalTransformationThreadPool)
      Sets whether this LocalTableMap is configured to use the global transformation thread pool. When set to true, the global thread pool configured in TableMapTransformThreadPool is used. When set to false, a thread pool for this particular TableMap is used (or no thread pool if transformation threads is set to 1).

    • getTransformationThreads

      public int getTransformationThreads()
      Returns the number of transformation threads that will be used (if this TableMap is not configured to use the global thread pool). If this TableMap is configured to use the global thread pool, then this value is ignored.
      Returns:
      the number of threads that will be used for transformations

    • setTransformationThreads

      public void setTransformationThreads(int transformationThreads)
      Set the number of transformation threads that should be used. Additionally, the global transformation thread pool is disabled for this TableMap. Derived TableMaps will inherit this setting (but use their own thread pool).
      Parameters:
      transformationThreads - the number of threads that should be used for transformations