postro 0.1.1

Asynchronous Postgres Driver and Utility
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

//! Postgres Driver
//!
//! # Examples
//!
//! Single connection:
//!
//! ```no_run
//! use postro::Connection;
//!
//! # async fn app() -> postro::Result<()> {
//! let mut conn = Connection::connect_env().await?;
//!
//! let res = postro::query::<_, _, (i32,String)>("SELECT 420,$1", &mut conn)
//!     .bind("Foo")
//!     .fetch_one()
//!     .await?;
//!
//! assert_eq!(res.0,420);
//! assert_eq!(res.1.as_str(),"Foo");
//! # Ok(())
//! # }
//! ```
//!
//! Database connection pooling:
//!
//! ```no_run
//! use postro::Pool;
//!
//! # async fn app() -> postro::Result<()> {
//! let mut pool = Pool::connect_env().await?;
//!
//! let mut handles = vec![];
//!
//! for i in 0..14 {
//!     let mut pool = pool.clone();
//!     let t = tokio::spawn(async move {
//!         postro::execute("INSERT INTO foo(id) VALUES($1)", &mut pool)
//!             .bind(i)
//!             .execute()
//!             .await
//!     });
//!     handles.push(t);
//! }
//!
//! for h in handles {
//!     h.await.unwrap();
//! }
//!
//! let foos = postro::query::<_, _, (i32,)>("SELECT * FROM foo", &mut pool)
//!     .fetch_all()
//!     .await?;
//!
//! assert_eq!(foos.len(), 14);
//! # Ok(())
//! # }
//! # mod tokio { pub fn spawn<F>(_: F) -> F { todo!() } }
//! ```
//!
//! Begin a transaction:
//!
//! ```no_run
//! use postro::Connection;
//!
//! # async fn app() -> postro::Result<()> {
//! let mut conn = Connection::connect_env().await?;
//!
//! let mut tx = postro::begin(&mut conn).await?;
//!
//! let _res = postro::query::<_, _, (i32,String)>("INSERT INTO foo(id) VALUES($1)", &mut tx)
//!     .bind(14)
//!     .execute()
//!     .await?;
//!
//! // if this failed, `tx` will be droped and transaction is rolledback
//! fallible_operation()?;
//!
//! tx.commit().await?;
//! # Ok(())
//! # }
//! #
//! # fn fallible_operation() -> postro::Result<()> { todo!() }
//! ```

pub mod common;
mod io;
mod net;
mod ext;

// Protocol
pub mod postgres;

// Encoding
mod value;
pub mod encode;

// Component
mod statement;
pub mod sql;
pub mod row;

// Operation
pub mod transport;
pub mod executor;
pub mod query;
pub mod transaction;
mod phase;
mod fetch;

// Connection
pub mod connection;
pub mod pool;

// Integration
pub mod types;

pub mod error;


#[doc(inline)]
pub use encode::Encode;
#[doc(inline)]
pub use row::{Row, FromRow, Decode, DecodeError};
pub use sql::SqlExt;

#[doc(inline)]
pub use executor::Executor;
#[doc(inline)]
pub use connection::{Connection, Config};
#[doc(inline)]
pub use pool::{Pool, PoolConfig};
#[doc(inline)]
pub use query::{query, query_row, execute};
#[doc(inline)]
pub use phase::{startup, begin};
#[doc(inline)]
pub use error::{Error, Result};

#[cfg(feature = "macros")]
pub use postro_macros::FromRow;