[−][src]Struct postgres::Client
A synchronous PostgreSQL client.
This is a lightweight wrapper over the asynchronous tokio_postgres Client
.
Methods
impl Client
[src]
pub fn connect<T>(params: &str, tls_mode: T) -> Result<Client, Error> where
T: MakeTlsConnect<Socket> + 'static + Send,
T::TlsConnect: Send,
T::Stream: Send,
<T::TlsConnect as TlsConnect<Socket>>::Future: Send,
[src]
T: MakeTlsConnect<Socket> + 'static + Send,
T::TlsConnect: Send,
T::Stream: Send,
<T::TlsConnect as TlsConnect<Socket>>::Future: Send,
A convenience function which parses a configuration string into a Config
and then connects to the database.
See the documentation for Config
for information about the connection syntax.
Requires the runtime
Cargo feature (enabled by default).
pub fn configure() -> Config
[src]
Returns a new Config
object which can be used to configure and connect to a database.
Requires the runtime
Cargo feature (enabled by default).
pub fn execute<T: ?Sized>(
&mut self,
query: &T,
params: &[&(dyn ToSql + Sync)]
) -> Result<u64, Error> where
T: ToStatement,
[src]
&mut self,
query: &T,
params: &[&(dyn ToSql + Sync)]
) -> Result<u64, Error> where
T: ToStatement,
Executes a statement, returning the number of rows modified.
A statement may contain parameters, specified by $n
, where n
is the index of the parameter of the list
provided, 1-indexed.
If the statement does not modify any rows (e.g. SELECT
), 0 is returned.
The query
argument can either be a Statement
, or a raw query string. If the same statement will be
repeatedly executed (perhaps with different query parameters), consider preparing the statement up front
with the prepare
method.
Panics
Panics if the number of parameters provided does not match the number expected.
Example
use postgres::{Client, NoTls}; let mut client = Client::connect("host=localhost user=postgres", NoTls)?; let bar = 1i32; let baz = true; let rows_updated = client.execute( "UPDATE foo SET bar = $1 WHERE baz = $2", &[&bar, &baz], )?; println!("{} rows updated", rows_updated);
pub fn query<T: ?Sized>(
&mut self,
query: &T,
params: &[&(dyn ToSql + Sync)]
) -> Result<Vec<Row>, Error> where
T: ToStatement,
[src]
&mut self,
query: &T,
params: &[&(dyn ToSql + Sync)]
) -> Result<Vec<Row>, Error> where
T: ToStatement,
Executes a statement, returning the resulting rows.
A statement may contain parameters, specified by $n
, where n
is the index of the parameter of the list
provided, 1-indexed.
The query
argument can either be a Statement
, or a raw query string. If the same statement will be
repeatedly executed (perhaps with different query parameters), consider preparing the statement up front
with the prepare
method.
Panics
Panics if the number of parameters provided does not match the number expected.
Examples
use postgres::{Client, NoTls}; let mut client = Client::connect("host=localhost user=postgres", NoTls)?; let baz = true; for row in client.query("SELECT foo FROM bar WHERE baz = $1", &[&baz])? { let foo: i32 = row.get("foo"); println!("foo: {}", foo); }
pub fn query_one<T: ?Sized>(
&mut self,
query: &T,
params: &[&(dyn ToSql + Sync)]
) -> Result<Row, Error> where
T: ToStatement,
[src]
&mut self,
query: &T,
params: &[&(dyn ToSql + Sync)]
) -> Result<Row, Error> where
T: ToStatement,
Executes a statement which returns a single row, returning it.
A statement may contain parameters, specified by $n
, where n
is the index of the parameter of the list
provided, 1-indexed.
The query
argument can either be a Statement
, or a raw query string. If the same statement will be
repeatedly executed (perhaps with different query parameters), consider preparing the statement up front
with the prepare
method.
Panics
Panics if the number of parameters provided does not match the number expected.
Examples
use postgres::{Client, NoTls}; let mut client = Client::connect("host=localhost user=postgres", NoTls)?; let baz = true; let row = client.query_one("SELECT foo FROM bar WHERE baz = $1", &[&baz])?; let foo: i32 = row.get("foo"); println!("foo: {}", foo);
pub fn query_raw<'a, T: ?Sized, I>(
&mut self,
query: &T,
params: I
) -> Result<impl FallibleIterator<Item = Row, Error = Error>, Error> where
T: ToStatement,
I: IntoIterator<Item = &'a dyn ToSql>,
I::IntoIter: ExactSizeIterator,
[src]
&mut self,
query: &T,
params: I
) -> Result<impl FallibleIterator<Item = Row, Error = Error>, Error> where
T: ToStatement,
I: IntoIterator<Item = &'a dyn ToSql>,
I::IntoIter: ExactSizeIterator,
A maximally-flexible version of query
.
It takes an iterator of parameters rather than a slice, and returns an iterator of rows rather than collecting them into an array.
Panics
Panics if the number of parameters provided does not match the number expected.
Examples
use postgres::{Client, NoTls}; use fallible_iterator::FallibleIterator; use std::iter; let mut client = Client::connect("host=localhost user=postgres", NoTls)?; let baz = true; let mut it = client.query_raw("SELECT foo FROM bar WHERE baz = $1", iter::once(&baz as _))?; while let Some(row) = it.next()? { let foo: i32 = row.get("foo"); println!("foo: {}", foo); }
pub fn prepare(&mut self, query: &str) -> Result<Statement, Error>
[src]
Creates a new prepared statement.
Prepared statements can be executed repeatedly, and may contain query parameters (indicated by $1
, $2
, etc),
which are set when executed. Prepared statements can only be used with the connection that created them.
Examples
use postgres::{Client, NoTls}; let mut client = Client::connect("host=localhost user=postgres", NoTls)?; let statement = client.prepare("SELECT name FROM people WHERE id = $1")?; for id in 0..10 { let rows = client.query(&statement, &[&id])?; let name: &str = rows[0].get(0); println!("name: {}", name); }
pub fn prepare_typed(
&mut self,
query: &str,
types: &[Type]
) -> Result<Statement, Error>
[src]
&mut self,
query: &str,
types: &[Type]
) -> Result<Statement, Error>
Like prepare
, but allows the types of query parameters to be explicitly specified.
The list of types may be smaller than the number of parameters - the types of the remaining parameters will be
inferred. For example, client.prepare_typed(query, &[])
is equivalent to client.prepare(query)
.
Examples
use postgres::{Client, NoTls}; use postgres::types::Type; let mut client = Client::connect("host=localhost user=postgres", NoTls)?; let statement = client.prepare_typed( "SELECT name FROM people WHERE id = $1", &[Type::INT8], )?; for id in 0..10 { let rows = client.query(&statement, &[&id])?; let name: &str = rows[0].get(0); println!("name: {}", name); }
pub fn copy_in<T: ?Sized, R>(
&mut self,
query: &T,
params: &[&(dyn ToSql + Sync)],
reader: R
) -> Result<u64, Error> where
T: ToStatement,
R: Read + Unpin,
[src]
&mut self,
query: &T,
params: &[&(dyn ToSql + Sync)],
reader: R
) -> Result<u64, Error> where
T: ToStatement,
R: Read + Unpin,
Executes a COPY FROM STDIN
statement, returning the number of rows created.
The query
argument can either be a Statement
, or a raw query string. The data in the provided reader is
passed along to the server verbatim; it is the caller's responsibility to ensure it uses the proper format.
Examples
use postgres::{Client, NoTls}; let mut client = Client::connect("host=localhost user=postgres", NoTls)?; client.copy_in("COPY people FROM stdin", &[], &mut "1\tjohn\n2\tjane\n".as_bytes())?;
pub fn copy_out<T: ?Sized>(
&mut self,
query: &T,
params: &[&(dyn ToSql + Sync)]
) -> Result<impl BufRead, Error> where
T: ToStatement,
[src]
&mut self,
query: &T,
params: &[&(dyn ToSql + Sync)]
) -> Result<impl BufRead, Error> where
T: ToStatement,
Executes a COPY TO STDOUT
statement, returning a reader of the resulting data.
The query
argument can either be a Statement
, or a raw query string.
Examples
use postgres::{Client, NoTls}; use std::io::Read; let mut client = Client::connect("host=localhost user=postgres", NoTls)?; let mut reader = client.copy_out("COPY people TO stdout", &[])?; let mut buf = vec![]; reader.read_to_end(&mut buf)?;
pub fn simple_query(
&mut self,
query: &str
) -> Result<Vec<SimpleQueryMessage>, Error>
[src]
&mut self,
query: &str
) -> Result<Vec<SimpleQueryMessage>, Error>
Executes a sequence of SQL statements using the simple query protocol.
Statements should be separated by semicolons. If an error occurs, execution of the sequence will stop at that
point. The simple query protocol returns the values in rows as strings rather than in their binary encodings,
so the associated row type doesn't work with the FromSql
trait. Rather than simply returning the rows, this
method returns a sequence of an enum which indicates either the completion of one of the commands, or a row of
data. This preserves the framing between the separate statements in the request.
This is a simple convenience method over simple_query_iter
.
Warning
Prepared statements should be use for any query which contains user-specified data, as they provided the functionality to safely imbed that data in the request. Do not form statements via string concatenation and pass them to this method!
pub fn batch_execute(&mut self, query: &str) -> Result<(), Error>
[src]
Executes a sequence of SQL statements using the simple query protocol.
Statements should be separated by semicolons. If an error occurs, execution of the sequence will stop at that point. This is intended for use when, for example, initializing a database schema.
Warning
Prepared statements should be use for any query which contains user-specified data, as they provided the functionality to safely embed that data in the request. Do not form statements via string concatenation and pass them to this method!
pub fn transaction(&mut self) -> Result<Transaction, Error>
[src]
Begins a new database transaction.
The transaction will roll back by default - use the commit
method to commit it.
Examples
use postgres::{Client, NoTls}; let mut client = Client::connect("host=localhost user=postgres", NoTls)?; let mut transaction = client.transaction()?; transaction.execute("UPDATE foo SET bar = 10", &[])?; // ... transaction.commit()?;
pub fn is_closed(&self) -> bool
[src]
Determines if the client's connection has already closed.
If this returns true
, the client is no longer usable.
pub fn get_ref(&self) -> &Client
[src]
Returns a shared reference to the inner nonblocking client.
pub fn get_mut(&mut self) -> &mut Client
[src]
Returns a mutable reference to the inner nonblocking client.
pub fn into_inner(self) -> Client
[src]
Consumes the client, returning the inner nonblocking client.
Trait Implementations
Auto Trait Implementations
impl Send for Client
impl Sync for Client
impl Unpin for Client
impl !UnwindSafe for Client
impl !RefUnwindSafe for Client
Blanket Implementations
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> From<T> for T
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = !
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,