Struct basex::connection::connection::Connection

pub struct Connection<T, State = Unauthenticated> where
    T: DatabaseStream,  {
    state: PhantomData<State>,
    stream: T,
}

Responsible for low-level communication with the stream. It handles authentication, sends commands and reads responses.

As opposed to the Client or Query can do, connection does not understand what commands do or how to parse responses. It can only send them, send arguments and be read like a stream.

Fields

state: PhantomData<State>

stream: T

Implementations

impl<T> Connection<T, Unauthenticated> where
    T: DatabaseStream, 

pub fn new(stream: T) -> Self

Creates a connection that communicates with the database via the provided stream.

pub fn authenticate(
    self,
    user: &str,
    password: &str
) -> Result<Connection<T, Authenticated>>

Authenticates the connection using the server protocol. Being authenticated is the pre-requisite for every other method to work.

Arguments

• user: Username.
• password: Password.

impl<T> Connection<T, Authenticated> where
    T: DatabaseStream, 

pub(crate) fn send_cmd(&mut self, code: u8) -> Result<&mut Self>

pub(crate) fn send_arg(&mut self, argument: &mut impl Read) -> Result<&mut Self>

pub(crate) fn skip_arg(&mut self) -> Result<&mut Self>

pub(crate) fn get_response(&mut self) -> Result<String>

Gets response string, and returns string if command was successful. Returns CommandFailed error with a message otherwise.

pub(crate) fn is_ok(&mut self) -> Result<bool>

Reads return code and decodes it to TRUE on success or FALSE on error.

impl<T, State> Connection<T, State> where
    T: DatabaseStream, 

pub(crate) fn try_clone(&self) -> Result<Self>

Creates a new connection with a new independently owned handle to the underlying socket.

pub(crate) fn read_string(&mut self) -> Result<String>

Trait Implementations

impl<T: DatabaseStream> Borrow<Connection<T, Authenticated>> for Client<T>

fn borrow(&self) -> &Connection<T, Authenticated>

Immutably borrows from an owned value.

impl<T: DatabaseStream> BorrowMut<Connection<T, Authenticated>> for Client<T>

fn borrow_mut(&mut self) -> &mut Connection<T, Authenticated>

Mutably borrows from an owned value.

impl<T, State> Clone for Connection<T, State> where
    T: DatabaseStream, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, State: Debug> Debug for Connection<T, State> where
    T: DatabaseStream, 

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

Formats the value using the given formatter.

impl<T, State> Read for Connection<T, State> where
    T: DatabaseStream, 

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬 This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8, Global>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Read the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: &mut ReadBuf<'_>) -> Result<(), Error>

🔬 This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, buf: &mut ReadBuf<'_>) -> Result<(), Error>

🔬 This is a nightly-only experimental API. (read_buf)

Read the exact number of bytes required to fill buf.

fn by_ref(&mut self) -> &mut Self

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R> where
    R: Read, 

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

Creates an adapter which will read at most limit bytes from it.