Struct SyncConnection 

pub struct SyncConnection { /* private fields */ }

A blocking Connection backed by an async driver and a private current-thread runtime.

Blocking model. Every method calls self.rt.block_on(...) on the owned runtime, so it blocks the calling thread until the driver future resolves. Memory model. query buffers the result but is bounded by size_guards — an oversized cell/row or a result past the total cap fails fast; query_cursor streams at bounded memory. Reentrancy. The runtime is current-thread; do not call from inside another block_on on the same thread (hop to a blocking thread first).

Trait Implementations

impl Connection for SyncConnection

fn query(&mut self, sql: &str) -> Result<QueryResult, SqlError>

Eager read, routed through the native cursor and collected into a fully-materialized QueryResult. Building the eager result on top of the streaming producer keeps a single decode path shared with query_cursor; for the network backends it also means the rows are pulled from the server’s cursor rather than pre-buffered by the driver.

fn execute(&mut self, sql: &str) -> Result<ExecutionSummary, SqlError>

Execute a statement that may not return rows (INSERT, UPDATE, CREATE, etc.). Blocks until the statement completes.

fn query_cursor(&mut self, sql: &str) -> Result<RowCursor<'_>, SqlError>

Open a streaming read cursor for sql, returning a RowCursor that pulls rows from a native database cursor at bounded memory.

fn size_guards(&self) -> SizeGuards

The size guards currently applied to this connection’s reads (per-cell, per-row, per-result byte caps). The default implementation reports SizeGuards::default; the concrete SyncConnection tracks the real configured value.

fn set_size_guards(&mut self, guards: SizeGuards)

Install new size guards for subsequent reads. Lets a host raise or lower the per-cell / per-row / per-result caps (e.g. the CLI wiring its [limits] config). The default implementation is a no-op for wrappers that hold no guard state; the concrete SyncConnection stores it.

fn execute_multi(&mut self, sql: &str) -> Result<Vec<StatementResult>, SqlError>

Execute one or more statements, one result per statement. Backends that natively support multi-resultsets (Postgres, MSSQL) split the batch; others fall back to single-statement behavior. Blocks until the batch completes.

fn ping(&mut self) -> Result<(), SqlError>

Test connectivity (ping / SELECT 1). Blocks on a round-trip.

fn list_tables(&mut self, schema: Option<&str>) -> Result<Vec<String>, SqlError>

List tables in the given schema (or default schema if None).

fn list_schemas(&mut self) -> Result<Vec<SchemaInfo>, SqlError>

List the schemas / databases / owners visible on this connection, ordered by name. The entry whose is_default is set is the schema unqualified objects resolve against (PG current_schema(), MySQL DATABASE(), MSSQL SCHEMA_NAME(), Oracle USER, SQLite main). Blocks on a round-trip.

fn describe_table( &mut self, schema: Option<&str>, table: &str, ) -> Result<QueryResult, SqlError>

Describe the columns of a single table.

fn primary_key( &mut self, schema: Option<&str>, table: &str, ) -> Result<Vec<String>, SqlError>

Return the column names of table’s primary key, in key position order. Returns an empty Vec when the table has no declared PK. Must not infer a PK from unique indexes — only declared primary-key constraints.

fn list_foreign_keys( &mut self, schema: Option<&str>, ) -> Result<Vec<ForeignKey>, SqlError>

Return every foreign-key edge in schema (or the default schema if None). Used by schema-level copy to order tables — parents before children.

fn bulk_insert_rows( &mut self, target: BulkInsert<'_>, ) -> Result<usize, SqlError>

Insert target.rows into target.table using the backend’s native bulk loader. Returns the number of rows accepted, or SqlError::BulkUnavailable when the backend has no native loader so the caller can fall back to the generic INSERT path. Blocks until the whole batch has streamed to the server.