mirror of
https://github.com/neondatabase/neon.git
synced 2026-01-15 17:32:56 +00:00
8daebb6ed4
Another go at #12341. LKB-2497 We now only need 1 connect mechanism (and 1 more for testing) which saves us some code and complexity. We should be able to remove the final connect mechanism when we create a separate worker task for pglb->compute connections - either via QUIC streams or via in-memory channels. This also now ensures that connect_once always returns a ConnectionError type - something simple enough we can probably define a serialisation for in pglb. * I've abstracted connect_to_compute to always use TcpMechanism and the ProxyConfig. * I've abstracted connect_to_compute_and_auth to perform authentication, managing any retries for stale computes * I had to introduce a separate `managed` function for taking ownership of the compute connection into the Client/Connection pair
105 lines
2.6 KiB
Rust
105 lines
2.6 KiB
Rust
//! An asynchronous, pipelined, PostgreSQL client.
|
|
#![warn(clippy::all)]
|
|
|
|
use postgres_protocol2::message::backend::ReadyForQueryBody;
|
|
|
|
pub use crate::cancel_token::{CancelToken, RawCancelToken};
|
|
pub use crate::client::{Client, SocketConfig};
|
|
pub use crate::config::Config;
|
|
pub use crate::connection::Connection;
|
|
pub use crate::error::Error;
|
|
pub use crate::generic_client::GenericClient;
|
|
pub use crate::query::RowStream;
|
|
pub use crate::row::{Row, SimpleQueryRow};
|
|
pub use crate::simple_query::SimpleQueryStream;
|
|
pub use crate::statement::{Column, Statement};
|
|
pub use crate::tls::NoTls;
|
|
pub use crate::transaction::Transaction;
|
|
pub use crate::transaction_builder::{IsolationLevel, TransactionBuilder};
|
|
|
|
/// After executing a query, the connection will be in one of these states
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
#[repr(u8)]
|
|
pub enum ReadyForQueryStatus {
|
|
/// Connection state is unknown
|
|
Unknown,
|
|
/// Connection is idle (no transactions)
|
|
Idle = b'I',
|
|
/// Connection is in a transaction block
|
|
Transaction = b'T',
|
|
/// Connection is in a failed transaction block
|
|
FailedTransaction = b'E',
|
|
}
|
|
|
|
impl From<ReadyForQueryBody> for ReadyForQueryStatus {
|
|
fn from(value: ReadyForQueryBody) -> Self {
|
|
match value.status() {
|
|
b'I' => Self::Idle,
|
|
b'T' => Self::Transaction,
|
|
b'E' => Self::FailedTransaction,
|
|
_ => Self::Unknown,
|
|
}
|
|
}
|
|
}
|
|
|
|
mod cancel_query;
|
|
mod cancel_query_raw;
|
|
mod cancel_token;
|
|
mod client;
|
|
mod codec;
|
|
pub mod config;
|
|
pub mod connect;
|
|
pub mod connect_raw;
|
|
mod connect_socket;
|
|
mod connect_tls;
|
|
mod connection;
|
|
pub mod error;
|
|
mod generic_client;
|
|
pub mod maybe_tls_stream;
|
|
mod prepare;
|
|
mod query;
|
|
pub mod row;
|
|
mod simple_query;
|
|
mod statement;
|
|
pub mod tls;
|
|
mod transaction;
|
|
mod transaction_builder;
|
|
pub mod types;
|
|
|
|
/// An asynchronous notification.
|
|
#[derive(Clone, Debug)]
|
|
pub struct Notification {
|
|
process_id: i32,
|
|
channel: String,
|
|
payload: String,
|
|
}
|
|
|
|
impl Notification {
|
|
/// The process ID of the notifying backend process.
|
|
pub fn process_id(&self) -> i32 {
|
|
self.process_id
|
|
}
|
|
|
|
/// The name of the channel that the notify has been raised on.
|
|
pub fn channel(&self) -> &str {
|
|
&self.channel
|
|
}
|
|
|
|
/// The "payload" string passed from the notifying process.
|
|
pub fn payload(&self) -> &str {
|
|
&self.payload
|
|
}
|
|
}
|
|
|
|
/// Message returned by the `SimpleQuery` stream.
|
|
#[derive(Debug)]
|
|
#[non_exhaustive]
|
|
pub enum SimpleQueryMessage {
|
|
/// A row of data.
|
|
Row(SimpleQueryRow),
|
|
/// A statement in the query has completed.
|
|
///
|
|
/// The number of rows modified or selected is returned.
|
|
CommandComplete(u64),
|
|
}
|