Struct pgwire::codec::FramedConn

pub struct FramedConn<A> {
    conn_id: u32,
    inner: Buffer<Framed<Conn<A>, Codec>, BackendMessage>,
}

A connection that manages the encoding and decoding of pgwire frames.

Fields

conn_id: u32

inner: Buffer<Framed<Conn<A>, Codec>, BackendMessage>

Implementations

impl<A> FramedConn<A> where
    A: AsyncRead + AsyncWrite + Unpin, 

pub fn new(conn_id: u32, inner: Conn<A>) -> FramedConn<A>

Constructs a new framed connection.

The underlying connection, inner, is expected to be something like a TCP stream. Anything that implements AsyncRead and AsyncWrite will do.

The supplied conn_id is used to identify the connection in logging messages.

pub fn id(&self) -> u32

Returns the ID of this connection.

pub async fn recv(&mut self) -> Result<Option<FrontendMessage>, Error>

Reads and decodes one frontend message from the client.

Blocks until the client sends a complete message. If the client terminates the stream, returns None. Returns an error if the client sends a malformatted message or if the connection underlying is broken.

pub async fn send<M>(&mut self, message: M) -> Result<(), Error> where
    M: Into<BackendMessage>, 

Encodes and sends one backend message to the client.

Note that the connection is not flushed after calling this method. You must call FramedConn::flush explicitly. Returns an error if the underlying connection is broken.

pub async fn send_all(
    &mut self,
    messages: impl IntoIterator<Item = BackendMessage>
) -> Result<(), Error>

Encodes and sends the backend messages in the messages iterator to the client.

As with FramedConn::send, the connection is not flushed after calling this method. You must call FramedConn::flush explicitly. Returns an error if the underlying connection is broken.

pub async fn flush(&mut self) -> Result<(), Error>

Flushes all outstanding messages.

pub fn set_encode_state(&mut self, encode_state: Vec<(Type, Format)>)

Injects state that affects how certain backend messages are encoded.

Specifically, the encoding of BackendMessage::DataRow depends upon the types of the datums in the row. To avoid including the same type information in each message, we use this side channel to install the type information in the codec before sending any data row messages. This violates the abstraction boundary a bit but results in much better performance.

impl<A> FramedConn<A> where
    A: AsyncRead + AsyncWrite + Unpin, 

pub fn inner(&self) -> &Conn<A>

Trait Implementations

impl<A> AsyncReady for FramedConn<A> where
    A: AsyncRead + AsyncWrite + AsyncReady + Send + Sync + Unpin, 

fn ready<'life0, 'async_trait>(
    &'life0 self,
    interest: Interest
) -> Pin<Box<dyn Future<Output = Result<Ready>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Checks for IO readiness.