Struct Client

Source

pub struct Client {
    pub grpc: PancakeDbClient<Channel>,
}

Expand description

The best way to communicate with a PancakeDB server from Rust.

Supports the entire PancakeDB API. Additionally, since PancakeDB reads return raw byte data in a compressed format, Client supports some higher-level functionality for reading whole segments into a meaningful representation.

use pancake_db_client::Client;

let client = Client::connect("http://localhost:3842").await?;

Fields§

§grpc: PancakeDbClient<Channel>

The generated Tonic GRPC client.

All client calls ultimately go through this. You can manually make low-level calls like read_segment_columns through this GRPC client.

Implementations§

Source §

impl Client

Source

pub async fn connect<D>(dst: D) -> ClientResult<Self>
where D: TryInto<Endpoint>, D::Error: Into<StdError>,

Creates a new client connected to the given endpoint.

See tonic::transport::Endpoint for what qualifies as an endpoint. One option is a string of format "http://$HOST:$PORT"

Source

pub async fn alter_table( &mut self, req: AlterTableRequest, ) -> ClientResult<AlterTableResponse>

Alters a table, e.g. by adding columns.

Source

pub async fn create_table( &mut self, req: CreateTableRequest, ) -> ClientResult<CreateTableResponse>

Creates or asserts or declaratively updates a table.

Source

pub async fn drop_table( &mut self, req: DropTableRequest, ) -> ClientResult<DropTableResponse>

Drops a table, deleting all its data.

Source

pub async fn get_schema( &mut self, req: GetSchemaRequest, ) -> ClientResult<GetSchemaResponse>

Returns the table’s schema.

Source

pub async fn delete_from_segment( &mut self, req: DeleteFromSegmentRequest, ) -> ClientResult<DeleteFromSegmentResponse>

Deletes specific rows from the segment.

Source

pub async fn list_tables( &mut self, req: ListTablesRequest, ) -> ClientResult<ListTablesResponse>

Lists of all tables.

Source

pub async fn list_segments( &mut self, req: ListSegmentsRequest, ) -> ClientResult<ListSegmentsResponse>

Lists all segments in the table, optionally subject to a partition filter.

Source

pub async fn read_segment_deletions( &mut self, req: ReadSegmentDeletionsRequest, ) -> ClientResult<ReadSegmentDeletionsResponse>

Reads the binary data for the rows deleted.

Uncommonly used; you should typically use [Client::decode_segment] instead.

Source

pub async fn write_to_partition( &mut self, req: WriteToPartitionRequest, ) -> ClientResult<WriteToPartitionResponse>

Writes rows to a partition of a table.

The request can be easily constructed with macros:

use std::time::SystemTime;
use pancake_db_idl::dml::WriteToPartitionRequest;
use pancake_db_client::{make_row, make_partition};

let req = WriteToPartitionRequest {
  table_name: "my_table".to_string(),
  partition: make_partition! {
    "string_partition_col" => "my_partition_value".to_string(),
    "int_partition_col" => 77,
  },
  rows: vec![
    make_row! {
      "timestamp_col" => SystemTime::now(),
      "bool_col" => false,
    }
  ],
};