Retrieves the names of all tables that this client has access to.

name is a string identifier unique to the [Table] (per [Client]), which can be used in conjunction with [Client::open_table] to get a [Table] instance without the use of [Client::table] constructor directly (e.g., one created by another [Client]).

JavaScript Examples

const tables = await client.get_hosted_table_names();
Copy

Register a callback which is invoked whenever [Client::table] (on this [Client]) or [Table::delete] (on a [Table] belinging to this [Client]) are called.

Opens a [Table] that is hosted on the perspective_server::Server that is connected to this [Client].

The name property of [TableInitOptions] is used to identify each [Table]. [Table] names can be looked up for each [Client] via [Client::get_hosted_table_names].

JavaScript Examples

Get a virtual [Table] named "table_one" from this [Client]

const tables = await client.open_table("table_one");
Copy

Remove a callback previously registered via Client::on_hosted_tables_update.

Provides the [SystemInfo] struct, implementation-specific metadata about the [perspective_server::Server] runtime such as Memory and CPU usage.

For WebAssembly servers, this method includes the WebAssembly heap size.

JavaScript Examples

const info = await client.system_info();
Copy

Creates a new [Table] from either a schema or data.

The [Client::table] factory function can be initialized with either a schema (see [Table::schema]), or data in one of these formats:

• Apache Arrow
• CSV
• JSON row-oriented
• JSON column-oriented
• NDJSON

When instantiated with data, the schema is inferred from this data. While this is convenient, inferrence is sometimes imperfect e.g. when the input is empty, null or ambiguous. For these cases, [Client::table] can first be instantiated with a explicit schema.

When instantiated with a schema, the resulting [Table] is empty but with known column names and column types. When subsqeuently populated with [Table::update], these columns will be coerced to the schema's type. This behavior can be useful when [Client::table]'s column type inferences doesn't work.

The resulting [Table] is virtual, and invoking its methods dispatches events to the perspective_server::Server this [Client] connects to, where the data is stored and all calculation occurs.

Arguments

• arg - Either schema or initialization data.
• options - Optional configuration which provides one of:
  • limit - The max number of rows the resulting [Table] can store.
  • index - The column name to use as an index column. If this Table is being instantiated by data, this column name must be present in the data.
  • name - The name of the table. This will be generated if it is not provided.
  • format - The explicit format of the input data, can be one of "json", "columns", "csv" or "arrow". This overrides language-specific type dispatch behavior, which allows stringified and byte array alternative inputs.

JavaScript Examples

Load a CSV from a string:

const table = await client.table("x,y\n1,2\n3,4");
Copy

Load an Arrow from an ArrayBuffer:

import * as fs from "node:fs/promises";
const table2 = await client.table(await fs.readFile("superstore.arrow"));
Copy

Load a CSV from a UInt8Array (the default for this type is Arrow) using a format override:

const enc = new TextEncoder();
const table = await client.table(enc.encode("x,y\n1,2\n3,4"), {
    format: "csv",
});
Copy

Create a table with an index:

const table = await client.table(data, { index: "Row ID" });
Copy

Terminates this [Client], cleaning up any [crate::View] handles the [Client] has open as well as its callbacks.