Struct SyncConnection

Source

pub struct SyncConnection { /* private fields */ }

Expand description

A synchronous PostgreSQL connection over a Unix domain socket.

This is the blocking counterpart to Connection. All I/O is synchronous using std::os::unix::net::UnixStream. No tokio runtime is required.

§Thread safety

SyncConnection is Send but not Sync — it must be used by one thread at a time. This matches the PostgreSQL wire protocol which is inherently sequential.

§Example

use bsql_driver_postgres::{SyncConnection, Config, Arena};

let config = Config::from_url("postgres://user@localhost/db?host=/tmp").unwrap();
let mut conn = SyncConnection::connect(&config).unwrap();
let mut arena = Arena::new();

let hash = bsql_driver_postgres::hash_sql("SELECT 1 AS n");
let result = conn.query("SELECT 1 AS n", hash, &[], &mut arena).unwrap();
assert_eq!(result.len(), 1);

Implementations§

Source §

impl SyncConnection

Source

pub fn connect(config: &Config) -> Result<Self, DriverError>

Connect to PostgreSQL via Unix domain socket and complete the startup/auth handshake. Fully synchronous — no tokio runtime needed.

config.host must start with / (UDS directory path).

§Errors

Returns an error if the host is not a UDS path, connection fails, or authentication fails.

Source

pub fn prepare_only( &mut self, sql: &str, sql_hash: u64, ) -> Result<(), DriverError>

Prepare a statement without executing it (Parse+Describe+Sync only).

If the statement is already cached, this is a no-op.

Source

pub fn query( &mut self, sql: &str, sql_hash: u64, params: &[&(dyn Encode + Sync)], arena: &mut Arena, ) -> Result<QueryResult, DriverError>

Execute a prepared query and return rows in arena-allocated storage.

Optimized path: after send_pipeline flushes, we parse BindComplete + DataRow* + CommandComplete + ReadyForQuery directly from stream_buf, avoiding per-message read_message_buffered overhead. DataRow payloads are parsed in-place from stream_buf into arena storage.

Source

pub fn execute_monolithic( &mut self, sql: &str, sql_hash: u64, params: &[&(dyn Encode + Sync)], ) -> Result<u64, DriverError>

Monolithic execute — everything in one function, no intermediate calls.

Inlines the entire send_pipeline + response parsing path for INSERT/UPDATE/DELETE. On cache hit: template copy + param patch + write_all + inline message parsing. No send_pipeline(), no flush_write(), no refill_stream_buf(). The compiler sees the entire path and can optimize globally.

On cache miss (first execution of a statement), falls through to the cold execute_with_prepare path.

Source

pub fn execute( &mut self, sql: &str, sql_hash: u64, params: &[&(dyn Encode + Sync)], ) -> Result<u64, DriverError>

Execute a query without result rows (INSERT/UPDATE/DELETE).

Delegates to execute_monolithic which inlines the entire send + receive path. Kept for API compatibility.

Source

pub fn execute_pipeline( &mut self, sql: &str, sql_hash: u64, param_sets: &[&[&(dyn Encode + Sync)]], ) -> Result<Vec<u64>, DriverError>

Execute the same prepared statement N times with different parameters in a single pipeline round-trip.

Sends all N Bind+Execute messages followed by one Sync. PostgreSQL processes them in order and returns N BindComplete+CommandComplete responses followed by one ReadyForQuery.

This is a real optimization for bulk operations: N inserts in a transaction become 1 round-trip instead of N round-trips.

Returns the number of affected rows for each parameter set.

Source

pub fn for_each<F>( &mut self, sql: &str, sql_hash: u64, params: &[&(dyn Encode + Sync)], f: F, ) -> Result<(), DriverError>
where F: FnMut(PgDataRow<'_>) -> Result<(), DriverError>,

Process each row via a closure with zero-copy PgDataRow.

Source

pub fn for_each_raw_monolithic<F>( &mut self, sql: &str, sql_hash: u64, params: &[&(dyn Encode + Sync)], f: F, ) -> Result<(), DriverError>
where F: FnMut(&[u8]) -> Result<(), DriverError>,

Monolithic for_each_raw — everything in one function, no intermediate calls.

Inlines the entire send_pipeline + response parsing path for SELECT queries processed via a raw byte closure. On cache hit: template copy + param patch + write_all + inline DataRow streaming + inline ReadyForQuery. No send_pipeline(), no flush_write(), no refill_stream_buf().

On cache miss (first execution of a statement), falls through to the cold for_each_raw_with_prepare path.

Source