Package com.illumon.iris.db.v2.remote

Class WrappedDelegatingTable

java.lang.Object
com.illumon.util.referencecounting.ReferenceCounted
com.illumon.iris.db.util.liveness.LivenessArtifact
com.illumon.iris.db.v2.BaseTable
com.illumon.iris.db.v2.remote.WrappedDelegatingTable
All Implemented Interfaces:
com.fishlib.base.log.LogOutputAppendable, NotificationQueue.Dependency, Deflatable<Table>, Table, LivenessManager, LivenessNode, LivenessReferent, LongSizedDataStructure, DynamicNode, DynamicTable, NotificationStepReceiver, NotificationStepSource, SystemicObject, Serializable
Direct Known Subclasses:
PreemptiveUpdatesTable
public abstract class WrappedDelegatingTable
extends BaseTable
See Also:
Serialized Form

  • Field Details

  • Constructor Details

  • Method Details

    • apply

      public <R> R apply​(com.fishlib.base.Function.Unary<R,​Table> function)
      Description copied from interface: Table
      Applies a function to this table.

      This is useful if you have a reference to a table, or a proxy; but not the database and want to run a series of operations against the table without each individual operation resulting in an RMI.

      Type Parameters:
      R - the return type of function
      Parameters:
      function - the function to run, its single argument will be this table
      Returns:
      the return value of function

    • getColumnSource

      public ColumnSource getColumnSource​(String sourceName)

    • getColumnSourceMap

      public Map<String,​? extends ColumnSource> getColumnSourceMap()

    • getColumnSources

      public Collection<? extends ColumnSource> getColumnSources()

    • getColumn

      public DataColumn getColumn​(String columnName)

    • getRecord

      public Object[] getRecord​(long rowNo, String... columnNames)

    • where

      public Table where​(SelectFilter... filters)

    • wouldMatch

      public Table wouldMatch​(WouldMatchPair... matchers)
      Description copied from interface: Table
      A table operation that applies the supplied predicate to each row in the table and produces columns containing the pass/fail result of the predicate application. This is similar to Table.where(String...) except that instead of selecting only rows that meet the criteria, new columns are added with the result of the comparison.
      Returns:
      a table with new columns containing the filter result for each row.

    • whereIn

      public Table whereIn​(Table rightTable, boolean inclusion, MatchPair... columnsToMatch)
      Description copied from interface: Table
      Filters this table based on the set of values in the rightTable. Note that when the right table ticks, all of the rows in the left table are going to be re-evaluated, thus the intention is that the right table is fairly slow moving compared with the left table.
      Parameters:
      rightTable - the filtering table.
      inclusion - whether things included in rightTable should be passed through (they are exluded if false)
      columnsToMatch - the columns to match between the two tables
      Returns:
      a new table filtered on right table

    • getSubTable

      public Table getSubTable​(Index index)

    • select

      public Table select​(SelectColumn... columns)

    • selectDistinct

      public Table selectDistinct​(SelectColumn... columns)

    • update

      public Table update​(SelectColumn... newColumns)

    • lazyUpdate

      public Table lazyUpdate​(SelectColumn... newColumns)
      Description copied from interface: Table
      Compute column formulas on demand.

      Lazy update defers computation until required for a set of values, and caches the results for a set of input values. This uses less RAM than an update statement when you have a smaller set of unique values. Less computation than an updateView is needed, because the results are saved in a cache.

      If you have many unique values, you should instead use an update statement, which will have more memory efficient structures. Values are never removed from the lazyUpdate cache, so it should be used judiciously on a ticking table.

      Parameters:
      newColumns - the columns to add
      Returns:
      a new Table with the columns added; to be computed on demand

    • view

      public Table view​(SelectColumn... columns)

    • updateView

      public Table updateView​(SelectColumn... newColumns)

    • dropColumns

      public Table dropColumns​(String... columnNames)

    • renameColumns

      public Table renameColumns​(MatchPair... pairs)

    • head

      public Table head​(long size)

    • tail

      public Table tail​(long size)

    • slice

      public Table slice​(long firstPositionInclusive, long lastPositionExclusive)
      Description copied from interface: Table
      Extracts a subset of a table by row position. If both firstPosition and lastPosition are positive, then the rows are counted from the beginning of the table. The firstPosition is inclusive, and the lastPosition is exclusive. The Table.head(long)(N) call is equivalent to slice(0, N). The firstPosition must be less than or equal to the lastPosition. If firstPosition is positive and lastPosition is negative, then the firstRow is counted from the beginning of the table, inclusively. The lastPosition is counted from the end of the table. For example, slice(1, -1) includes all rows but the first and last. If the lastPosition would be before the firstRow, the result is an emptyTable. If firstPosition is negative, and lastPosition is zero, then the firstRow is counted from the end of the table, and the end of the slice is the size of the table. slice(-N, 0) is equivalent to Table.tail(long)(N). If the firstPosition is nega tive and the lastPosition is negative, they are both counted from the end of the table. For example, slice(-2, -1) returns the second to last row of the table.
      Parameters:
      firstPositionInclusive - the first position to include in the result
      lastPositionExclusive - the last position to include in the result
      Returns:
      a new Table, which is the request subset of rows from the original table

    • headPct

      public Table headPct​(double percent)
      Description copied from interface: Table
      Provides a head that selects a dynamic number of rows based on a percent.
      Parameters:
      percent - the fraction of the table to return (0..1), the number of rows will be rounded up. For example if there are 3 rows, headPct(50) returns the first two rows.

    • tailPct

      public Table tailPct​(double percent)

    • leftJoin

      public Table leftJoin​(Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd)
      Description copied from interface: Table
      Augments this table with array columns of right-hand side matches.

      The leftJoin() method returns the exact rows of the leftTable. The data joined in from the rightTable are grouped into arrays of data. When no right-hand side data is found, the right hand columns are null.

      Parameters:
      rightTable - The right side table on the join.
      columnsToMatch - An array of match pair conditions ("leftColumn=rightColumn" or "columnFoundInBoth")
      columnsToAdd - An array of the columns from the right side be added to the left side as a result of the match. If empty, then all columns from the right table are added to the result.
      Returns:
      a new table joined according to the specification in columnsToMatch and columnsToAdd

    • exactJoin

      public Table exactJoin​(Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd)
      Description copied from interface: Table
      Identical to naturalJoin, but fail if the right side does not produce a match.

    • aj

      public Table aj​(Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd, Table.AsOfMatchRule asOfMatchRule)
      Description copied from interface: Table
      Looks up the columns in the rightTable that meet the match conditions in the columnsToMatch list. Matching is done exactly for the first n-1 columns and via a binary search for the last match pair. The columns of the original table are returned intact, together with the columns from rightTable defined in a comma separated list "columnsToAdd"
      Parameters:
      rightTable - The right side table on the join.
      columnsToMatch - A comma separated list of match conditions ("leftColumn=rightColumn" or "columnFoundInBoth")
      columnsToAdd - A comma separated list with the columns from the left side that need to be added to the right side as a result of the match.
      Returns:
      a new table joined according to the specification in columnsToMatch and columnsToAdd

    • raj

      public Table raj​(Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd, Table.AsOfMatchRule asOfMatchRule)
      Description copied from interface: Table
      Just like .aj(), but the matching on the last column is in reverse order, so that you find the row after the given timestamp instead of the row before.

      Looks up the columns in the rightTable that meet the match conditions in the columnsToMatch list. Matching is done exactly for the first n-1 columns and via a binary search for the last match pair. The columns of the original table are returned intact, together with the columns from rightTable defined in a comma separated list "columnsToAdd"

      Parameters:
      rightTable - The right side table on the join.
      columnsToMatch - A comma separated list of match conditions ("leftColumn=rightColumn" or "columnFoundInBoth")
      columnsToAdd - A comma separated list with the columns from the left side that need to be added to the right side as a result of the match.
      Returns:
      a new table joined according to the specification in columnsToMatch and columnsToAdd

    • naturalJoin

      public Table naturalJoin​(Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd)
      Description copied from interface: Table
      Augment this table with zero or one row from the right table.

      The result is somewhat like an Excel vlookup or SQL leftJoin.

      • The leftTable always retains the same number of rows and the same columns with which it started.
      • If there are no matching values for a row, the appended cell(s) from the rightTable will contain NULL values.
      • The right side table can only have one row for each key of the join. If duplicate rows exist on the right side, then the operation's initialization or update results in an error.

      When columnsToMatch is empty, then no join keys are used. If there is a row in the right table, it is joined to all rows of the left table. If there are no rows in the right table, then the right columns are null. If there are multiple rows in the right table then there is an error.

      Parameters:
      rightTable - The right side table on the join.
      columnsToMatch - An array of match pair conditions ("leftColumn=rightColumn" or "columnFoundInBoth")
      columnsToAdd - An array of the columns from the right side be added to the left side as a result of the match. If empty, then all columns from the right table are added to the result.
      Returns:
      a new table joined according to the specification in columnsToMatch and columnsToAdd

    • join

      public Table join​(Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd, int numRightBitsToReserve)
      Description copied from interface: Table
      Perform a cross join with the right table.

      Returns a table that is the cartesian product of left rows X right rows, with one column for each of the left table's columns, and one column corresponding to each of the right table's columns that are included in the columnsToAdd argument. The rows are ordered first by the left table then by the right table. If columnsToMatch is non-empty then the product is filtered by the supplied match conditions.

      To efficiently produce updates, the bits that represent a key for a given row are split into two. Unless specified, join reserves 16 bits to represent a right row. When there are too few bits to represent all of the right rows for a given aggregation group the table will shift a bit from the left side to the right side. The default of 16 bits was carefully chosen because it results in an efficient implementation to process live updates.

      An OutOfKeySpaceException is thrown when the total number of bits needed to express the result table exceeds that needed to represent Long.MAX_VALUE. There are a few work arounds: - If the left table is sparse, consider flattening the left table. - If there are no key-columns and the right table is sparse, consider flattening the right table. - If the maximum size of a right table's group is small, you can reserve fewer bits by setting numRightBitsToReserve on initialization.

      Note: If you can prove that a given group has at most one right-row then you should prefer using Table.naturalJoin(com.illumon.iris.db.tables.Table, com.illumon.iris.db.tables.select.MatchPair[], com.illumon.iris.db.tables.select.MatchPair[]).

      Parameters:
      rightTable - The right side table on the join.
      columnsToMatch - An array of match pair conditions ("leftColumn=rightColumn" or "columnFoundInBoth")
      columnsToAdd - An array of the columns from the right side that need to be added to the left side as a result of the match.
      numRightBitsToReserve - The number of bits to reserve for rightTable groups.
      Returns:
      a new table joined according to the specification in columnsToMatch and columnsToAdd

    • by

      public Table by​(AggregationStateFactory aggregationStateFactory, SelectColumn... groupByColumns)

    • headBy

      public Table headBy​(long nRows, String... groupByColumns)

    • tailBy

      public Table tailBy​(long nRows, String... groupByColumns)

    • applyToAllBy

      public Table applyToAllBy​(String formulaColumn, String columnParamName, SelectColumn... groupByColumns)
      Description copied from interface: Table
      Groups data according to groupByColumns and applies formulaColumn to each of columns not altered by the grouping operation. columnParamName is used as place-holder for the name of each column inside formulaColumn.
      Parameters:
      formulaColumn - Formula applied to each column
      columnParamName - The parameter name used as a placeholder for each column
      groupByColumns - The grouping columns Table.by(SelectColumn[])

    • sumBy

      public Table sumBy​(SelectColumn... groupByColumns)
      Description copied from interface: Table
      Groups the data column according to groupByColumns and computes the sum for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns Table.by(String...)

    • absSumBy

      public Table absSumBy​(SelectColumn... groupByColumns)
      Description copied from interface: Table
      Groups the data column according to groupByColumns and computes the sum of the absolute values for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns Table.by(String...)

    • avgBy

      public Table avgBy​(SelectColumn... groupByColumns)
      Description copied from interface: Table
      Groups the data column according to groupByColumns and computes the average for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns Table.by(String...)

    • wavgBy

      public Table wavgBy​(String weightColumn, SelectColumn... groupByColumns)
      Description copied from interface: Table
      Groups the data column according to groupByColumns and computes the weighted average using weightColumn for the rest of the fields
      Parameters:
      weightColumn - the column to use for the weight
      groupByColumns - The grouping columns Table.by(String...)

    • wsumBy

      public Table wsumBy​(String weightColumn, SelectColumn... groupByColumns)
      Description copied from interface: Table
      Groups the data column according to groupByColumns and computes the weighted sum using weightColumn for the rest of the fields If the weight column is a floating point type, all result columns will be doubles. If the weight column is an integral type, all integral input columns will have long results and all floating point input columns will have double results.
      Parameters:
      weightColumn - the column to use for the weight
      groupByColumns - The grouping columns Table.by(String...)

    • stdBy

      public Table stdBy​(SelectColumn... groupByColumns)

    • varBy

      public Table varBy​(SelectColumn... groupByColumns)
      Description copied from interface: Table
      Groups the data column according to groupByColumns and computes the variance for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns Table.by(String...)

    • lastBy

      public Table lastBy​(SelectColumn... groupByColumns)
      Description copied from interface: Table
      Groups the data column according to groupByColumns and retrieves the last for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns Table.by(String...)

    • firstBy

      public Table firstBy​(SelectColumn... groupByColumns)
      Description copied from interface: Table
      Groups the data column according to groupByColumns and retrieves the first for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns Table.by(String...)

    • minBy

      public Table minBy​(SelectColumn... groupByColumns)
      Description copied from interface: Table
      Groups the data column according to groupByColumns and computes the min for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns Table.by(String...)

    • maxBy

      public Table maxBy​(SelectColumn... groupByColumns)
      Description copied from interface: Table
      Groups the data column according to groupByColumns and computes the max for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns Table.by(String...) }

    • medianBy

      public Table medianBy​(SelectColumn... groupByColumns)
      Description copied from interface: Table
      Groups the data column according to groupByColumns and computes the median for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns Table.by(String...) }

    • countBy

      public Table countBy​(String countColumnName, SelectColumn... groupByColumns)

    • ungroup

      public Table ungroup​(boolean nullFill, String... columnsToUngroup)
      Description copied from interface: Table
      Ungroups a table by converting arrays into columns.
      Parameters:
      nullFill - indicates if the ungrouped table should allow disparate sized arrays filling shorter columns with null values. If set to false, then all arrays should be the same length.
      columnsToUngroup - the columns to ungroup
      Returns:
      the ungrouped table

    • byExternal

      public TableMap byExternal​(boolean dropKeys, String... keyColumnNames)
      Description copied from interface: Table
      Create a TableMap from this table, keyed by the specified columns.

      The returned TableMap contains each row in this table in exactly one of the tables within the map. If you have exactly one key column the TableMap is keyed by the value in that column. If you have zero key columns, then the TableMap is keyed by com.fishlib.datastructures.util.SmartKey.EMPTY (and will contain this table as the value). If you have multiple key columns, then the TableMap is keyed by a com.fishlib.datastructures.util.SmartKey. The SmartKey will have one value for each of your column values, in the order specified by keyColumnNames.

      For example if you have a Table keyed by a String column named USym, and a DBDateTime column named Expiry; a value could be retrieved from the TableMap with tableMap.get(new SmartKey("SPY";, DBTimeUtils.convertDateTime("2020-06-19T16:15:00 NY"))). For a table with an Integer column named Bucket, you simply use the desired value as in tableMap.get(1).

      Parameters:
      dropKeys - if true, drop key columns in the output Tables
      keyColumnNames - the name of the key columns to use.
      Returns:
      a TableMap keyed by keyColumnNames

    • rollup

      public HierarchicalTable rollup​(ComboAggregateFactory comboAggregateFactory, boolean includeConstituents, SelectColumn... columns)

    • treeTable

      public HierarchicalTable treeTable​(String idColumn, String parentColumn)
      Description copied from interface: Table
      Create a hierarchical tree table. The structure of the table is encoded by an "id" and a "parent" column. The id column should represent a unique identifier for a given row, and the parent column indicates which row is the parent for a given row. Rows that have a null parent, are shown in the main table. It is possible for rows to be "orphaned", if their parent reference is non-null and does not exist in the table.
      Parameters:
      idColumn - the name of a column containing a unique identifier for a particular row in the table
      parentColumn - the name of a column containing the parent's identifier, null for elements that are part of the root table
      Returns:
      a hierarchical table grouped according to the parentColumn

    • sort

      public Table sort​(SortPair... sortPairs)

    • reverse

      public Table reverse()

    • snapshot

      public Table snapshot​(Table rightTable, boolean doInitialSnapshot, String... stampColumns)
      Description copied from interface: Table
      Snapshot "rightTable", triggered by "this" Table, and return a new Table as a result. "this" Table is the triggering table, i.e. the table whose change events cause a new snapshot to be taken. The result table includes a "snapshot key" which is a subset (possibly all) of this Table's columns. The remaining columns in the result table come from "rightTable", the table being snapshotted.
      Parameters:
      rightTable - The table to be snapshotted
      doInitialSnapshot - Take the first snapshot now (otherwise wait for a change event)
      stampColumns - The columns forming the "snapshot key", i.e. some subset of this Table's columns to be included in the result at snapshot time. As a special case, an empty stampColumns is taken to mean "include all columns".
      Returns:
      The result table

    • snapshotIncremental

      public Table snapshotIncremental​(Table rightTable, boolean doInitialSnapshot, String... stampColumns)

    • snapshotHistory

      public Table snapshotHistory​(Table rightTable)

    • flatten

      public Table flatten()
      Description copied from interface: Table
      Creates a version of this table with a flat index (V2 only).

    • updateBy

      public Table updateBy​(@NotNull UpdateByControl control, @NotNull Collection<UpdateByClause> operations, MatchPair... byColumns)
      Description copied from interface: Table

      Create a table with the same index as it's parent that will perform the specified set of row based operations to it. As opposed to Table.update(String...) these operations are more restricted but are capable of processing state between rows. This operation will group the table by the specified set of keys if provided before applying the operation.

      operations - the operations to apply to the table.
      byColumns - the columns to group by before applying.
      Returns:
      a table with the same index, with the specified operations applied to each group defined by the byColumns

    • silent

      public Table silent()
      Description copied from interface: DynamicTable

      Return an identical table that suppresses all downstream notifications

      WARNING: Use this feature responsibly. Even though updates are suppressed, that does not imply that the underlying column sources are necessarily static, and so reading data from the table may not be consistent. A safer approach is to use Table.snapshot(Table, String...) or Table.snapshotIncremental(Table, String...)

      Returns:
      a new Table that does not propagate updates downstream.

    • validateSelect

      public SelectValidationResult validateSelect​(SelectColumn... columns)
      Description copied from interface: Table
      DO NOT USE -- this API is in flux and may change or disappear in the future.

    • preemptiveUpdatesTable

      public Table preemptiveUpdatesTable​(long updateInterval)

    • preemptiveSnapshotTable

      public Table preemptiveSnapshotTable​(long updateInterval)

    • initializeTransientFieldsForLiveness

      @VisibleForTesting public final void initializeTransientFieldsForLiveness()
      Package-private for Serializable sub-classes to use in readObject only. Public to allow unit tests in another package to work around mock issues where the constructor is never invoked.

    • tryRetainReference

      public final boolean tryRetainReference()
      Description copied from interface: LivenessReferent
      If this referent is "live", behave as LivenessReferent.retainReference() and return true. Otherwise, returns false rather than throwing an exception.
      Specified by:
      tryRetainReference in interface LivenessReferent
      Returns:
      True if this referent was retained, false otherwise

    • dropReference

      public final void dropReference()
      Description copied from interface: LivenessReferent
      Drop a previously-retained reference to this referent.
      Specified by:
      dropReference in interface LivenessReferent

    • getWeakReference

      public WeakReference<? extends LivenessReferent> getWeakReference()
      Description copied from interface: LivenessReferent
      Get a WeakReference to this referent. This may be cached, or newly created.
      Specified by:
      getWeakReference in interface LivenessReferent
      Returns:
      A new or cached reference to this referent

    • tryManage

      public final boolean tryManage​(@NotNull LivenessReferent referent)
      Description copied from interface: LivenessManager
      Attempt to add the specified referent to this manager.
      Specified by:
      tryManage in interface LivenessManager
      Parameters:
      referent - The referent to add
      Returns:
      Whether the referent was in fact added

    • onReferenceCountAtZero

      protected final void onReferenceCountAtZero()
      Description copied from class: ReferenceCounted
      Callback method that will be invoked when the reference count returns to zero.
      Specified by:
      onReferenceCountAtZero in class ReferenceCounted