Struct perspective_client::Client

pub struct Client { /* private fields */ }

An instance of a Client is a unique connection to a single Server, whether locally in-memory or remote over some transport like a WebSocket. To create, use the appropriate constructor function:

• websocket - Create a connection to a WebSocket Server instance.
• worker [JavaScript] - Unlike the other Client constructors, the worker version also owns its Server, which runs in a dedicated Web Worker.
• local [Rust, Python] - Create an Client connected to an in-memory, in-process Server.

Examples

JavaScript

const client = perspective.worker();

Implementations

impl Client

pub fn new_with_callback<T>(send_request: T) -> Self

where T: for<'a> Fn(&'a [u8]) -> BoxFuture<'a, Result<(), Box<dyn Error + Send + Sync>>> + 'static + Sync + Send,

Create a new client instance with a closure that handles message dispatch. See Client::new for details.

pub fn new<T>(client_handler: T) -> Self

where T: ClientHandler + 'static + Sync + Send,

Create a new Client instance with ClientHandler.

pub async fn handle_response<'a>(&'a self, msg: &'a [u8]) -> ClientResult<bool>

Handle a message from the external message queue. Client::handle_response is part of the low-level message-handling API necessary to implement new transports for a Client connection to a local-or-remote [perspective_server::Server], and doesn’t generally need to be called directly by “users” of a Client once connected.

pub async fn init(&self) -> ClientResult<()>

pub async fn table( &self, input: TableData, options: TableInitOptions, ) -> ClientResult<Table>

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

• Apache Arrow, as [pyo3::bytes] (python) or [js_sys::ArrayBuffer] (js)
• CSV as a String
• Row-oriented [pyo3::list] (python) or [js_sys::Array] (js)
• Column-oriented [pyo3::dict] (python) or [js_sys::Object] (js)

When instantiated with data, the schema is inferred from this data. Future calls to Table::update will coerce to the inferred type this schema. While this is convenient, inferrence is sometimes imperfect e.g. when the input is empty, null or ambiguous. For these cases, Client::table can 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 Server from which it was instantiated (e.g. a Web Worker or WebSocket client), 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.

Examples

JavaScript

// Load a CSV
const table = await client.table("x,y\n1,2\n3,4");

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

Python

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

Rust

let table = client.table(TableData::FromCsv("x,y\n1,2\n3,4")).await?;

pub async fn open_table(&self, entity_id: String) -> ClientResult<Table>

Opens a Table that is hosted on the [perspective_server::Server] that is connected to this Client. The name property of TableInitOptions

Examples

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

tables = client.open_table("table_one");

let tables = client.open_table("table_one").await;

pub async fn get_hosted_table_names(&self) -> ClientResult<Vec<String>>

Retrieves the names of all tables that this client has access to. This can be used in conjunction with Client::open_table.

Arguments

None.

Examples

const tables = await client.get_hosted_table_names();

tables = await async_client.get_hosted_table_names();

let tables = client.get_hosted_table_names().await;

pub async fn system_info(&self) -> ClientResult<SystemInfo>

Provides the [SystemInfo] struct.

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Client

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.