Struct klickhouse::Client

pub struct Client { /* private fields */ }

Client handle for a Clickhouse connection, has internal reference to connection, and can be freely cloned and sent across threads.

Implementations

impl Client

pub async fn connect_stream(
    read: impl AsyncRead + Unpin + Send + Sync + 'static,
    writer: impl AsyncWrite + Unpin + Send + Sync + 'static,
    options: ClientOptions
) -> Result<Self>

Consumes a reader and writer to connect to Klickhouse. To be used for exotic setups or TLS. Generally prefer Client::connect()

pub async fn connect<A: ToSocketAddrs>(
    destination: A,
    options: ClientOptions
) -> Result<Self>

Connects to a specific socket address over plaintext TCP for Clickhouse.

pub async fn query_raw(
    &self,
    query: impl TryInto<ParsedQuery, Error = KlickhouseError>
) -> Result<impl Stream<Item = Result<Block>>>

Sends a query string and read column blocks over a stream. You probably want Client::query()

pub async fn insert_native_raw(
    &self,
    query: impl TryInto<ParsedQuery, Error = KlickhouseError>,
    blocks: impl Stream<Item = Block> + Send + Sync + Unpin + 'static
) -> Result<impl Stream<Item = Result<Block>>>

Sends a query string with streaming associated data (i.e. insert) over native protocol. Once all outgoing blocks are written (EOF of blocks stream), then any response blocks from Clickhouse are read. You probably want Client::insert_native.

pub async fn insert_native<T: Row + Send + Sync + 'static>(
    &self,
    query: impl TryInto<ParsedQuery, Error = KlickhouseError>,
    blocks: impl Stream<Item = Vec<T>> + Send + Sync + Unpin + 'static
) -> Result<()>

Sends a query string with streaming associated data (i.e. insert) over native protocol. Once all outgoing blocks are written (EOF of blocks stream), then any response blocks from Clickhouse are read and DISCARDED. Make sure any query you send native data with has a format native suffix.

pub async fn insert_native_block<T: Row + Send + Sync + 'static>(
    &self,
    query: impl TryInto<ParsedQuery, Error = KlickhouseError>,
    blocks: Vec<T>
) -> Result<()>

Wrapper over Client::insert_native to send a single block. Make sure any query you send native data with has a format native suffix.

pub async fn query<T: Row>(
    &self,
    query: impl TryInto<ParsedQuery, Error = KlickhouseError>
) -> Result<impl Stream<Item = Result<T>>>

Runs a query against Clickhouse, returning a stream of deserialized rows. Note that no rows are returned until Clickhouse sends a full block (but it usually sends more than one block).

pub async fn query_collect<T: Row>(
    &self,
    query: impl TryInto<ParsedQuery, Error = KlickhouseError>
) -> Result<Vec<T>>

Same as query, but collects all rows into a Vec

pub async fn query_one<T: Row>(
    &self,
    query: impl TryInto<ParsedQuery, Error = KlickhouseError>
) -> Result<T>

Same as query, but returns the first row and discards the rest.

pub async fn query_opt<T: Row>(
    &self,
    query: impl TryInto<ParsedQuery, Error = KlickhouseError>
) -> Result<Option<T>>

Same as query, but returns the first row, if any, and discards the rest.

pub async fn execute(
    &self,
    query: impl TryInto<ParsedQuery, Error = KlickhouseError>
) -> Result<()>

Same as query, but discards all returns blocks. Waits until the first block returns from the server to check for errors. Waiting for the first response block or EOS also prevents the server from aborting the query potentially due to client disconnection.

pub async fn execute_now(
    &self,
    query: impl TryInto<ParsedQuery, Error = KlickhouseError>
) -> Result<()>

Same as execute, but doesn’t wait for a server response. The query could get aborted if the connection is closed quickly.

pub fn is_closed(&self) -> bool

true if the Client is closed

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.