Line data    Source code

       1              : //! An asynchronous, pipelined, PostgreSQL client.
       2              : #![warn(clippy::all)]
       3              : 
       4              : pub use crate::cancel_token::CancelToken;
       5              : pub use crate::client::{Client, SocketConfig};
       6              : pub use crate::config::Config;
       7              : pub use crate::connect_raw::RawConnection;
       8              : pub use crate::connection::Connection;
       9              : use crate::error::DbError;
      10              : pub use crate::error::Error;
      11              : pub use crate::generic_client::GenericClient;
      12              : pub use crate::query::RowStream;
      13              : pub use crate::row::{Row, SimpleQueryRow};
      14              : pub use crate::simple_query::SimpleQueryStream;
      15              : pub use crate::statement::{Column, Statement};
      16              : pub use crate::tls::NoTls;
      17              : pub use crate::to_statement::ToStatement;
      18              : pub use crate::transaction::Transaction;
      19              : pub use crate::transaction_builder::{IsolationLevel, TransactionBuilder};
      20              : use crate::types::ToSql;
      21              : use postgres_protocol2::message::backend::ReadyForQueryBody;
      22              : 
      23              : /// After executing a query, the connection will be in one of these states
      24              : #[derive(Clone, Copy, Debug, PartialEq)]
      25              : #[repr(u8)]
      26              : pub enum ReadyForQueryStatus {
      27              :     /// Connection state is unknown
      28              :     Unknown,
      29              :     /// Connection is idle (no transactions)
      30              :     Idle = b'I',
      31              :     /// Connection is in a transaction block
      32              :     Transaction = b'T',
      33              :     /// Connection is in a failed transaction block
      34              :     FailedTransaction = b'E',
      35              : }
      36              : 
      37              : impl From<ReadyForQueryBody> for ReadyForQueryStatus {
      38            0 :     fn from(value: ReadyForQueryBody) -> Self {
      39            0 :         match value.status() {
      40            0 :             b'I' => Self::Idle,
      41            0 :             b'T' => Self::Transaction,
      42            0 :             b'E' => Self::FailedTransaction,
      43            0 :             _ => Self::Unknown,
      44              :         }
      45            0 :     }
      46              : }
      47              : 
      48              : mod cancel_query;
      49              : mod cancel_query_raw;
      50              : mod cancel_token;
      51              : mod client;
      52              : mod codec;
      53              : pub mod config;
      54              : mod connect;
      55              : mod connect_raw;
      56              : mod connect_socket;
      57              : mod connect_tls;
      58              : mod connection;
      59              : pub mod error;
      60              : mod generic_client;
      61              : pub mod maybe_tls_stream;
      62              : mod prepare;
      63              : mod query;
      64              : pub mod row;
      65              : mod simple_query;
      66              : mod statement;
      67              : pub mod tls;
      68              : mod to_statement;
      69              : mod transaction;
      70              : mod transaction_builder;
      71              : pub mod types;
      72              : 
      73              : /// An asynchronous notification.
      74              : #[derive(Clone, Debug)]
      75              : pub struct Notification {
      76              :     process_id: i32,
      77              :     channel: String,
      78              :     payload: String,
      79              : }
      80              : 
      81              : impl Notification {
      82              :     /// The process ID of the notifying backend process.
      83            0 :     pub fn process_id(&self) -> i32 {
      84            0 :         self.process_id
      85            0 :     }
      86              : 
      87              :     /// The name of the channel that the notify has been raised on.
      88            0 :     pub fn channel(&self) -> &str {
      89            0 :         &self.channel
      90            0 :     }
      91              : 
      92              :     /// The "payload" string passed from the notifying process.
      93            0 :     pub fn payload(&self) -> &str {
      94            0 :         &self.payload
      95            0 :     }
      96              : }
      97              : 
      98              : /// An asynchronous message from the server.
      99              : #[allow(clippy::large_enum_variant)]
     100              : #[derive(Debug, Clone)]
     101              : #[non_exhaustive]
     102              : pub enum AsyncMessage {
     103              :     /// A notice.
     104              :     ///
     105              :     /// Notices use the same format as errors, but aren't "errors" per-se.
     106              :     Notice(DbError),
     107              :     /// A notification.
     108              :     ///
     109              :     /// Connections can subscribe to notifications with the `LISTEN` command.
     110              :     Notification(Notification),
     111              : }
     112              : 
     113              : /// Message returned by the `SimpleQuery` stream.
     114              : #[derive(Debug)]
     115              : #[non_exhaustive]
     116              : pub enum SimpleQueryMessage {
     117              :     /// A row of data.
     118              :     Row(SimpleQueryRow),
     119              :     /// A statement in the query has completed.
     120              :     ///
     121              :     /// The number of rows modified or selected is returned.
     122              :     CommandComplete(u64),
     123              : }
     124              : 
     125            0 : fn slice_iter<'a>(
     126            0 :     s: &'a [&'a (dyn ToSql + Sync)],
     127            0 : ) -> impl ExactSizeIterator<Item = &'a (dyn ToSql + Sync)> + 'a {
     128            0 :     s.iter().map(|s| *s as _)
     129            0 : }