Struct PgExecutor 

pub struct PgExecutor { /* private fields */ }

PostgreSQL executor using sqlx.

Manages a connection pool and executes queries against PostgreSQL databases.

Example

use nautilus_connector::PgExecutor;

#[tokio::main]
async fn main() -> nautilus_core::Result<()> {
    let executor = PgExecutor::new("postgres://user:pass@localhost/mydb").await?;
    // Use executor to run queries...
    Ok(())
}

Implementations

impl PgExecutor

pub async fn new(url: &str) -> Result<Self>

Create a new PostgreSQL executor with a connection pool.

Parameters

• url: PostgreSQL connection URL (e.g., postgres://user:pass@localhost/dbname)

Errors

Returns ConnectorError::Connection if the pool cannot be created or if an initial connection test fails.

pub async fn new_with_options( url: &str, pool_options: ConnectorPoolOptions, ) -> Result<Self>

Create a new PostgreSQL executor with explicit pool overrides.

Any override not provided keeps the same default used by Self::new.

pub fn pool(&self) -> &PgPool

Get a reference to the underlying connection pool.

pub async fn execute_raw(&self, sql: &str) -> Result<()>

Execute a raw SQL statement with no result rows (e.g., DDL).

pub async fn execute_collect_unprepared(&self, sql: &Sql) -> Result<Vec<Row>>

Execute a SQL query with sqlx statement persistence disabled.

This is reserved for raw/direct query paths that must stay compatible with poolers such as PgBouncer transaction pooling.

pub async fn execute_affected(&self, sql: &Sql) -> Result<usize>

Execute a mutation SQL and return the number of affected rows.

Used when return_data = false — no RETURNING clause is emitted so the affected-row count must come from the database result.

Trait Implementations

impl Executor for PgExecutor

Executor implementation backed by a PostgreSQL connection pool.

type Row<'conn> = Row where Self: 'conn

The row type returned by this executor.

type RowStream<'conn> = RowStream<'conn> where Self: 'conn

The stream type yielding rows from query execution.

fn execute<'conn>(&'conn self, sql: &'conn Sql) -> Self::RowStream<'conn>

Execute a SQL query and return a stream of rows.

fn execute_owned(&self, sql: Sql) -> RowStream<'static>

Execute a SQL query and return a row stream that owns its work.

fn execute_and_fetch<'conn>( &'conn self, mutation: &'conn Sql, fetch: &'conn Sql, ) -> Self::RowStream<'conn>

Execute a mutation SQL, drain its results, then execute a fetch SQL on the same database connection and return the fetch rows.

fn execute_collect<'conn>( &'conn self, sql: &'conn Sql, ) -> BoxFuture<'conn, Result<Vec<Self::Row<'conn>>>>

where Self: 'conn,

Execute a SQL query and materialize all rows into a vector.

fn execute_one<'conn>( &'conn self, sql: &'conn Sql, ) -> BoxFuture<'conn, Result<Self::Row<'conn>>>

where Self: 'conn,

Execute a SQL query and require exactly one row.

fn execute_optional<'conn>( &'conn self, sql: &'conn Sql, ) -> BoxFuture<'conn, Result<Option<Self::Row<'conn>>>>

where Self: 'conn,

Execute a SQL query and accept zero or one row.