Struct clickhouse_srv::connection::Connection

pub struct Connection {
    pub buffer: BytesMut,
    pub session: Arc<dyn ClickHouseSession>,
    // some fields omitted
}

Send and receive Packet values from a remote peer.

When implementing networking protocols, a message on that protocol is often composed of several smaller messages known as frames. The purpose of Connection is to read and write frames on the underlying TcpStream.

To read frames, the Connection uses an internal buffer, which is filled up until there are enough bytes to create a full frame. Once this happens, the Connection creates the frame and returns it to the caller.

When sending frames, the frame is first encoded into the write buffer. The contents of the write buffer are then written to the socket.

Fields

buffer: BytesMut

session: Arc<dyn ClickHouseSession>

Implementations

impl Connection

pub fn new(
    stream: TcpStream,
    session: Arc<dyn ClickHouseSession>,
    timezone: String
) -> Result<Connection>

Create a new Connection, backed by socket. Read and write buffers are initialized.

pub async fn read_packet(
    &mut self,
    ctx: &mut CHContext
) -> Result<Option<Packet>>

Read a single Packet value from the underlying stream.

The function waits until it has retrieved enough data to parse a frame. Any data remaining in the read buffer after the frame has been parsed is kept there for the next call to read_packet.

Returns

On success, the received frame is returned. If the TcpStream is closed in a way that doesn’t break a frame in half, it returns None. Otherwise, an error is returned.

pub async fn write_block(&mut self, block: &Block) -> Result<()>

pub async fn write_progress(
    &mut self,
    progress: Progress,
    client_revision: u64
) -> Result<()>

pub async fn write_end_of_stream(&mut self) -> Result<()>

pub async fn write_error(&mut self, err: &Error) -> Result<()>

pub async fn write_bytes(&mut self, bytes: Vec<u8>) -> Result<()>