TablePublisher

The table_publisher method creates a TablePublisher. A TablePublisher produces a blink table from tables that are added to it via the add method.

Syntax

table_publisher(
    name: str,
    col_defs: dict[str, DType],
    on_flush_callback: Callable[[TablePublisher], None] = None
    on_shutdown_callback: Callable[[], None] = None,
    update_graph: UpdateGraph = None,
    chunk_size: int = 2048
) -> TablePublisher

Parameters

Parameter	Type	Description
name	str	The name of the blink table.
col_defs	dict	The blink table's column definitions.
on_flush_callback optional	Callable	The on-flush callback, if present, is called once at the beginning of each update graph cycle. It allows publishers to add any data they may have been batching. This blocks the update cycle from proceeding, so implements should take care not to do extraneous work. The default is `None`.
on_shutdown_callback optional	Callable	An on-shutdown callback method. It will be called once when the caller should stop adding new data and release any related resources. The default is `None`.
update_graph optional	UpdateGraph	The update graph that the resulting table will belong to. The default is `None`, which uses the update graph of the current execution context.
chunk_size optional	int	The size at which chunks of data will be filled from the source table during an add. The default is 2048 bytes.

Returns

A TablePublisher.

Methods

TablePublisher supports the following methods:

add(table) - Adds a snapshot of the data from table into the blink table. The table must contain a superset of the columns from the blink table's definition. The columns can be in any order. Columns from table that are not in the blink table's definition are ignored.
is_alive() - Checks if the table is alive. Returns True if the table is alive, and False otherwise.
publish_failure(failure) - Indicates that data publication has failed.

Examples

The following example creates a TablePublisher with three columns. It adds a table with three rows using add and new_table. add_to_table calls my_publisher.add, which adds three new rows to my_blink_table. Because my_blink_table is a blink table, each subsequent call to add_to_table will reset the state of the table.

from deephaven.stream.table_publisher import table_publisher
from deephaven import dtypes as dht
from deephaven import new_table
from deephaven.column import string_col, int_col, float_col

my_blink_table, my_publisher = table_publisher(
    "My table",
    {"Name": dht.string, "Age": dht.int32, "Height": dht.float32},
)


def add_to_table():
    my_publisher.add(
        new_table(
            [
                string_col("Name", ["Foo", "Bar", "Baz"]),
                int_col("Age", [42, 22, 32]),
                float_col("Height", [5.5, 6.0, 6.5]),
            ]
        )
    )


add_to_table()
add_to_table()

The table my_blink_table created by the above query

Subsequent calls to add_to_table in later update cycles will show only the rows created in that update cycle.

add_to_table()

The blink table updates to only show new rows created in the current update cycle