Struct DBAdapterManager

Source

pub struct DBAdapterManager<'q, DB, T>where
    DB: Database,
    T: SqlTemplate<'q, DB>,
{ /* private fields */ }

Expand description

Database adapter manager handling SQL rendering and execution

§Generic Parameters

'q: Query lifetime
DB: Database type
T: SQL template type

Implementations§

Source §

impl<'q, DB, T> DBAdapterManager<'q, DB, T>
where DB: Database, T: SqlTemplate<'q, DB>,

Source

pub fn new(template: T) -> Self

Creates new adapter with SQL buffer

§Arguments

template - SQL template instance

Source

pub fn sql(&self) -> &String

Source §

impl<'q, 'c, 'e, DB, T> DBAdapterManager<'q, DB, T>
where DB: Database + Sync, T: SqlTemplate<'q, DB> + Send + 'q, i64: Encode<'q, DB> + Type<DB>, DB::Arguments<'q>: 'q, 'q: 'e, 'c: 'e,

Source

pub fn set_persistent(self, persistent: bool) -> Self

Configures query persistence (default: true)

Examples found in repository ?

examples/example_marco.rs (line 75)

25async fn simple_query() -> Result<(), Error> {
26    let users = vec![
27        User {
28            id: 1,
29            name: "admin".to_string(),
30        },
31        User {
32            id: 99999_i64,
33            name: "super man".to_string(),
34        },
35    ];
36
37    let user_query = UserQuery {
38        user_id: 1,
39        user_name: "admin".to_string(),
40    };
41    //pg
42
43    let pool = sqlx::PgPool::connect("postgres://postgres:postgres@localhost/postgres").await?;
44    let mut sql_buff = String::new();
45    let execute = user_query.render_executable(&mut sql_buff)?;
46
47    let rows = pool.fetch_all(execute).await?;
48    let mut db_users = Vec::new();
49    for row in &rows {
50        db_users.push(User::from_row(row)?);
51    }
52    assert_eq!(db_users, users);
53
54    //sqlite+any
55    install_default_drivers();
56    let pool = AnyPool::connect("sqlite://db.file?mode=memory").await?;
57    let mut sql_buff = String::new();
58    let rows = user_query
59        .render_executable(&mut sql_buff)?
60        .fetch_all(&pool)
61        .await?;
62
63    let mut db_users = Vec::new();
64    for row in &rows {
65        db_users.push(User::from_row(row)?);
66    }
67    assert_eq!(db_users, users);
68
69    //mysql
70
71    let pool = MySqlPool::connect("mysql://root:root@localhost/mysql").await?;
72
73    let db_users: Vec<User> = user_query
74        .adapter_render()
75        .set_persistent(false)
76        .fetch_all_as(&pool)
77        .await?;
78
79    assert_eq!(db_users, users);
80    Ok(())
81}

Source

pub fn count<Adapter>( &'q mut self, db_adapter: Adapter, ) -> BoxFuture<'e, Result<i64, Error>>
where Adapter: BackendDB<'c, DB> + 'c, (i64,): for<'r> FromRow<'r, DB::Row>,

Executes count query for pagination

§Arguments

db_adapter - Database connection adapter

Examples found in repository ?

examples/example_ntex.rs (line 62)

56async fn root(pool: State<AnyPool>) -> impl Responder {
57    //  test count
58    let user_query = UserQuery {
59        user_id: 1,
60        user_name: "ntex",
61    };
62    let count = user_query.adapter_render().count(&*pool).await.unwrap();
63    println!("count: {count}");
64
65    let mut conn = pool.acquire().await.unwrap();
66    let users: Vec<User> = user_query
67        .adapter_render()
68        .fetch_all_as(&mut *conn)
69        .await
70        .unwrap();
71
72    Response::Ok().body(IndexHtml { users }.render().unwrap())
73}

More examples

Hide additional examples

examples/example_actix.rs (line 62)

56async fn root(pool: Data<AnyPool>) -> impl actix_web::Responder {
57    //  test count
58    let user_query = UserQuery {
59        user_id: 1,
60        user_name: "actix",
61    };
62    let count = user_query.adapter_render().count(&**pool).await.unwrap();
63    println!("count: {count}");
64
65    let mut conn = pool.acquire().await.unwrap();
66    let users: Vec<User> = user_query
67        .adapter_render()
68        .fetch_all_as(&mut *conn)
69        .await
70        .unwrap();
71
72    Html::new(IndexHtml { users }.render().unwrap())
73}

examples/example_adapter.rs (line 142)

122async fn test_adapter_query(url: &str) -> Result<(), Error> {
123    let data = vec![
124        User {
125            id: 1,
126            name: "admin".to_string(),
127        },
128        User {
129            id: 99999,
130            name: "super man".to_string(),
131        },
132    ];
133    //  test count
134    let user_query = UserQuery {
135        user_id: 1,
136        user_name: "admin",
137    };
138    let pool = AnyPool::connect(url).await?;
139
140    let mut db_adatper = user_query.adapter_render();
141
142    let count = db_adatper.count(&pool).await?;
143    assert_eq!(2, count);
144
145    // test pagination
146    let user: Option<User> = user_query
147        .adapter_render()
148        .set_page(1, 1)
149        .fetch_optional_as(&pool)
150        .await?;
151    assert_eq!(data.first(), user.as_ref());
152    // println!("{user:?}");
153
154    let mut conn = pool.acquire().await?;
155    let user: Vec<User> = user_query
156        .adapter_render()
157        .set_page(1, 2)
158        .fetch_all_as(&mut *conn)
159        .await?;
160    assert_eq!(data[1..], user);
161    // println!("{user:?}");
162
163    let page_info = user_query.adapter_render().count_page(1, &pool).await?;
164    assert_eq!(PageInfo::new(2, 1), page_info);
165    // println!("{page_info:?}");
166    //fecth
167    let mut tx = pool.begin().await?;
168
169    let rows = UserQuery {
170        user_id: 1,
171        user_name: "admin",
172    }
173    .adapter_render()
174    .fetch_all(&mut *tx)
175    .await?;
176    assert_eq!(2, rows.len());
177    //println!("{:?}", rows.len());
178    let row = UserQuery {
179        user_id: 1,
180        user_name: "admin",
181    }
182    .adapter_render()
183    .fetch_optional(&mut *tx)
184    .await?;
185    assert!(row.is_some());
186    let row = UserQuery {
187        user_id: 1,
188        user_name: "admin",
189    }
190    .adapter_render()
191    .fetch_one(&mut *tx)
192    .await?;
193    assert_eq!(2, row.columns().len());
194    // fetch_as
195    let users: Vec<User> = user_query.adapter_render().fetch_all_as(&pool).await?;
196    assert_eq!(data, users);
197    //println!("{:?}", users);
198
199    let u: Option<User> = UserQuery {
200        user_id: 1,
201        user_name: "admin",
202    }
203    .adapter_render()
204    .fetch_optional_as(&mut *tx)
205    .await?;
206    assert_eq!(data.first(), u.as_ref());
207    let u: User = UserQuery {
208        user_id: 1,
209        user_name: "admin",
210    }
211    .adapter_render()
212    .fetch_one_as(&mut *tx)
213    .await?;
214    assert_eq!(data.first(), Some(&u));
215
216    // stream
217    let mut query = user_query.adapter_render();
218    {
219        let stream = query.fetch(&mut *tx);
220        pin_mut!(stream);
221        while let Some(row) = stream.try_next().await? {
222            assert_eq!(2, row.columns().len());
223        }
224    }
225
226    tx.rollback().await?;
227
228    Ok(())
229}

examples/example_axum.rs (line 78)

58async fn test_adapter_query(url: &str) -> Result<(), Error> {
59    let data = vec![
60        User {
61            id: 1,
62            name: "admin".to_string(),
63        },
64        User {
65            id: 99999,
66            name: "super man".to_string(),
67        },
68    ];
69    //  test count
70    let user_query = UserQuery {
71        user_id: 1,
72        user_name: "admin",
73    };
74    let pool = AnyPool::connect(url).await?;
75
76    let mut db_adatper = user_query.adapter_render();
77
78    let count = db_adatper.count(&pool).await?;
79    assert_eq!(2, count);
80
81    // test pagination
82    let user: Option<User> = user_query
83        .adapter_render()
84        .set_page(1, 1)
85        .fetch_optional_as(&pool)
86        .await?;
87    assert_eq!(data.first(), user.as_ref());
88    // println!("{user:?}");
89
90    let mut conn = pool.acquire().await?;
91    let user: Vec<User> = user_query
92        .adapter_render()
93        .set_page(1, 2)
94        .fetch_all_as(&mut *conn)
95        .await?;
96    assert_eq!(data[1..], user);
97    // println!("{user:?}");
98
99    let page_info = user_query.adapter_render().count_page(1, &pool).await?;
100    assert_eq!(PageInfo::new(2, 1), page_info);
101    // println!("{page_info:?}");
102    //fecth
103    let mut tx = pool.begin().await?;
104
105    let rows = UserQuery {
106        user_id: 1,
107        user_name: "admin",
108    }
109    .adapter_render()
110    .fetch_all(&mut *tx)
111    .await?;
112    assert_eq!(2, rows.len());
113    //println!("{:?}", rows.len());
114    let row = UserQuery {
115        user_id: 1,
116        user_name: "admin",
117    }
118    .adapter_render()
119    .fetch_optional(&mut *tx)
120    .await?;
121    assert!(row.is_some());
122    let row = UserQuery {
123        user_id: 1,
124        user_name: "admin",
125    }
126    .adapter_render()
127    .fetch_one(&mut *tx)
128    .await?;
129    assert_eq!(2, row.columns().len());
130    // fetch_as
131    let users: Vec<User> = user_query.adapter_render().fetch_all_as(&pool).await?;
132    assert_eq!(data, users);
133    //println!("{:?}", users);
134
135    let u: Option<User> = UserQuery {
136        user_id: 1,
137        user_name: "admin",
138    }
139    .adapter_render()
140    .fetch_optional_as(&mut *tx)
141    .await?;
142    assert_eq!(data.first(), u.as_ref());
143    let u: User = UserQuery {
144        user_id: 1,
145        user_name: "admin",
146    }
147    .adapter_render()
148    .fetch_one_as(&mut *tx)
149    .await?;
150    assert_eq!(data.first(), Some(&u));
151
152    // stream
153    let mut query = user_query.adapter_render();
154    {
155        let stream = query.fetch(&mut *tx);
156        pin_mut!(stream);
157        while let Some(row) = stream.try_next().await? {
158            assert_eq!(2, row.columns().len());
159        }
160    }
161
162    tx.rollback().await?;
163
164    Ok(())
165}
166#[axum::debug_handler]
167async fn root(State(pool): State<AnyPool>) -> impl axum::response::IntoResponse {
168    test_adapter_query("sqlite://db.file?mode=memory")
169        .await
170        .unwrap();
171    //  test count
172    let user_query = UserQuery {
173        user_id: 1,
174        user_name: "axum",
175    };
176    let count = user_query.adapter_render().count(&pool).await.unwrap();
177    println!("count: {count}");
178
179    let mut conn = pool.acquire().await.unwrap();
180    let rows = user_query
181        .adapter_render()
182        .fetch_all_as(&mut *conn)
183        .await
184        .unwrap();
185    Html(IndexHtml { users: rows }.render().unwrap())
186}

Source

pub async fn count_page<Adapter>( &'q mut self, page_size: i64, db_adapter: Adapter, ) -> Result<PageInfo, Error>
where Adapter: BackendDB<'c, DB> + 'c, (i64,): for<'r> FromRow<'r, DB::Row>,

Calculates complete pagination metadata

§Arguments

page_size - Records per page
db_adapter - Database connection adapter

Examples found in repository ?

examples/example_adapter.rs (line 163)

122async fn test_adapter_query(url: &str) -> Result<(), Error> {
123    let data = vec![
124        User {
125            id: 1,
126            name: "admin".to_string(),
127        },
128        User {
129            id: 99999,
130            name: "super man".to_string(),
131        },
132    ];
133    //  test count
134    let user_query = UserQuery {
135        user_id: 1,
136        user_name: "admin",
137    };
138    let pool = AnyPool::connect(url).await?;
139
140    let mut db_adatper = user_query.adapter_render();
141
142    let count = db_adatper.count(&pool).await?;
143    assert_eq!(2, count);
144
145    // test pagination
146    let user: Option<User> = user_query
147        .adapter_render()
148        .set_page(1, 1)
149        .fetch_optional_as(&pool)
150        .await?;
151    assert_eq!(data.first(), user.as_ref());
152    // println!("{user:?}");
153
154    let mut conn = pool.acquire().await?;
155    let user: Vec<User> = user_query
156        .adapter_render()
157        .set_page(1, 2)
158        .fetch_all_as(&mut *conn)
159        .await?;
160    assert_eq!(data[1..], user);
161    // println!("{user:?}");
162
163    let page_info = user_query.adapter_render().count_page(1, &pool).await?;
164    assert_eq!(PageInfo::new(2, 1), page_info);
165    // println!("{page_info:?}");
166    //fecth
167    let mut tx = pool.begin().await?;
168
169    let rows = UserQuery {
170        user_id: 1,
171        user_name: "admin",
172    }
173    .adapter_render()
174    .fetch_all(&mut *tx)
175    .await?;
176    assert_eq!(2, rows.len());
177    //println!("{:?}", rows.len());
178    let row = UserQuery {
179        user_id: 1,
180        user_name: "admin",
181    }
182    .adapter_render()
183    .fetch_optional(&mut *tx)
184    .await?;
185    assert!(row.is_some());
186    let row = UserQuery {
187        user_id: 1,
188        user_name: "admin",
189    }
190    .adapter_render()
191    .fetch_one(&mut *tx)
192    .await?;
193    assert_eq!(2, row.columns().len());
194    // fetch_as
195    let users: Vec<User> = user_query.adapter_render().fetch_all_as(&pool).await?;
196    assert_eq!(data, users);
197    //println!("{:?}", users);
198
199    let u: Option<User> = UserQuery {
200        user_id: 1,
201        user_name: "admin",
202    }
203    .adapter_render()
204    .fetch_optional_as(&mut *tx)
205    .await?;
206    assert_eq!(data.first(), u.as_ref());
207    let u: User = UserQuery {
208        user_id: 1,
209        user_name: "admin",
210    }
211    .adapter_render()
212    .fetch_one_as(&mut *tx)
213    .await?;
214    assert_eq!(data.first(), Some(&u));
215
216    // stream
217    let mut query = user_query.adapter_render();
218    {
219        let stream = query.fetch(&mut *tx);
220        pin_mut!(stream);
221        while let Some(row) = stream.try_next().await? {
222            assert_eq!(2, row.columns().len());
223        }
224    }
225
226    tx.rollback().await?;
227
228    Ok(())
229}

More examples

Hide additional examples

examples/example_axum.rs (line 99)

58async fn test_adapter_query(url: &str) -> Result<(), Error> {
59    let data = vec![
60        User {
61            id: 1,
62            name: "admin".to_string(),
63        },
64        User {
65            id: 99999,
66            name: "super man".to_string(),
67        },
68    ];
69    //  test count
70    let user_query = UserQuery {
71        user_id: 1,
72        user_name: "admin",
73    };
74    let pool = AnyPool::connect(url).await?;
75
76    let mut db_adatper = user_query.adapter_render();
77
78    let count = db_adatper.count(&pool).await?;
79    assert_eq!(2, count);
80
81    // test pagination
82    let user: Option<User> = user_query
83        .adapter_render()
84        .set_page(1, 1)
85        .fetch_optional_as(&pool)
86        .await?;
87    assert_eq!(data.first(), user.as_ref());
88    // println!("{user:?}");
89
90    let mut conn = pool.acquire().await?;
91    let user: Vec<User> = user_query
92        .adapter_render()
93        .set_page(1, 2)
94        .fetch_all_as(&mut *conn)
95        .await?;
96    assert_eq!(data[1..], user);
97    // println!("{user:?}");
98
99    let page_info = user_query.adapter_render().count_page(1, &pool).await?;
100    assert_eq!(PageInfo::new(2, 1), page_info);
101    // println!("{page_info:?}");
102    //fecth
103    let mut tx = pool.begin().await?;
104
105    let rows = UserQuery {
106        user_id: 1,
107        user_name: "admin",
108    }
109    .adapter_render()
110    .fetch_all(&mut *tx)
111    .await?;
112    assert_eq!(2, rows.len());
113    //println!("{:?}", rows.len());
114    let row = UserQuery {
115        user_id: 1,
116        user_name: "admin",
117    }
118    .adapter_render()
119    .fetch_optional(&mut *tx)
120    .await?;
121    assert!(row.is_some());
122    let row = UserQuery {
123        user_id: 1,
124        user_name: "admin",
125    }
126    .adapter_render()
127    .fetch_one(&mut *tx)
128    .await?;
129    assert_eq!(2, row.columns().len());
130    // fetch_as
131    let users: Vec<User> = user_query.adapter_render().fetch_all_as(&pool).await?;
132    assert_eq!(data, users);
133    //println!("{:?}", users);
134
135    let u: Option<User> = UserQuery {
136        user_id: 1,
137        user_name: "admin",
138    }
139    .adapter_render()
140    .fetch_optional_as(&mut *tx)
141    .await?;
142    assert_eq!(data.first(), u.as_ref());
143    let u: User = UserQuery {
144        user_id: 1,
145        user_name: "admin",
146    }
147    .adapter_render()
148    .fetch_one_as(&mut *tx)
149    .await?;
150    assert_eq!(data.first(), Some(&u));
151
152    // stream
153    let mut query = user_query.adapter_render();
154    {
155        let stream = query.fetch(&mut *tx);
156        pin_mut!(stream);
157        while let Some(row) = stream.try_next().await? {
158            assert_eq!(2, row.columns().len());
159        }
160    }
161
162    tx.rollback().await?;
163
164    Ok(())
165}

Source

pub fn set_page(self, page_size: i64, page_no: i64) -> Self

Sets pagination parameters

Examples found in repository ?

examples/example_adapter.rs (line 148)

122async fn test_adapter_query(url: &str) -> Result<(), Error> {
123    let data = vec![
124        User {
125            id: 1,
126            name: "admin".to_string(),
127        },
128        User {
129            id: 99999,
130            name: "super man".to_string(),
131        },
132    ];
133    //  test count
134    let user_query = UserQuery {
135        user_id: 1,
136        user_name: "admin",
137    };
138    let pool = AnyPool::connect(url).await?;
139
140    let mut db_adatper = user_query.adapter_render();
141
142    let count = db_adatper.count(&pool).await?;
143    assert_eq!(2, count);
144
145    // test pagination
146    let user: Option<User> = user_query
147        .adapter_render()
148        .set_page(1, 1)
149        .fetch_optional_as(&pool)
150        .await?;
151    assert_eq!(data.first(), user.as_ref());
152    // println!("{user:?}");
153
154    let mut conn = pool.acquire().await?;
155    let user: Vec<User> = user_query
156        .adapter_render()
157        .set_page(1, 2)
158        .fetch_all_as(&mut *conn)
159        .await?;
160    assert_eq!(data[1..], user);
161    // println!("{user:?}");
162
163    let page_info = user_query.adapter_render().count_page(1, &pool).await?;
164    assert_eq!(PageInfo::new(2, 1), page_info);
165    // println!("{page_info:?}");
166    //fecth
167    let mut tx = pool.begin().await?;
168
169    let rows = UserQuery {
170        user_id: 1,
171        user_name: "admin",
172    }
173    .adapter_render()
174    .fetch_all(&mut *tx)
175    .await?;
176    assert_eq!(2, rows.len());
177    //println!("{:?}", rows.len());
178    let row = UserQuery {
179        user_id: 1,
180        user_name: "admin",
181    }
182    .adapter_render()
183    .fetch_optional(&mut *tx)
184    .await?;
185    assert!(row.is_some());
186    let row = UserQuery {
187        user_id: 1,
188        user_name: "admin",
189    }
190    .adapter_render()
191    .fetch_one(&mut *tx)
192    .await?;
193    assert_eq!(2, row.columns().len());
194    // fetch_as
195    let users: Vec<User> = user_query.adapter_render().fetch_all_as(&pool).await?;
196    assert_eq!(data, users);
197    //println!("{:?}", users);
198
199    let u: Option<User> = UserQuery {
200        user_id: 1,
201        user_name: "admin",
202    }
203    .adapter_render()
204    .fetch_optional_as(&mut *tx)
205    .await?;
206    assert_eq!(data.first(), u.as_ref());
207    let u: User = UserQuery {
208        user_id: 1,
209        user_name: "admin",
210    }
211    .adapter_render()
212    .fetch_one_as(&mut *tx)
213    .await?;
214    assert_eq!(data.first(), Some(&u));
215
216    // stream
217    let mut query = user_query.adapter_render();
218    {
219        let stream = query.fetch(&mut *tx);
220        pin_mut!(stream);
221        while let Some(row) = stream.try_next().await? {
222            assert_eq!(2, row.columns().len());
223        }
224    }
225
226    tx.rollback().await?;
227
228    Ok(())
229}

More examples

Hide additional examples

examples/example_axum.rs (line 84)

58async fn test_adapter_query(url: &str) -> Result<(), Error> {
59    let data = vec![
60        User {
61            id: 1,
62            name: "admin".to_string(),
63        },
64        User {
65            id: 99999,
66            name: "super man".to_string(),
67        },
68    ];
69    //  test count
70    let user_query = UserQuery {
71        user_id: 1,
72        user_name: "admin",
73    };
74    let pool = AnyPool::connect(url).await?;
75
76    let mut db_adatper = user_query.adapter_render();
77
78    let count = db_adatper.count(&pool).await?;
79    assert_eq!(2, count);
80
81    // test pagination
82    let user: Option<User> = user_query
83        .adapter_render()
84        .set_page(1, 1)
85        .fetch_optional_as(&pool)
86        .await?;
87    assert_eq!(data.first(), user.as_ref());
88    // println!("{user:?}");
89
90    let mut conn = pool.acquire().await?;
91    let user: Vec<User> = user_query
92        .adapter_render()
93        .set_page(1, 2)
94        .fetch_all_as(&mut *conn)
95        .await?;
96    assert_eq!(data[1..], user);
97    // println!("{user:?}");
98
99    let page_info = user_query.adapter_render().count_page(1, &pool).await?;
100    assert_eq!(PageInfo::new(2, 1), page_info);
101    // println!("{page_info:?}");
102    //fecth
103    let mut tx = pool.begin().await?;
104
105    let rows = UserQuery {
106        user_id: 1,
107        user_name: "admin",
108    }
109    .adapter_render()
110    .fetch_all(&mut *tx)
111    .await?;
112    assert_eq!(2, rows.len());
113    //println!("{:?}", rows.len());
114    let row = UserQuery {
115        user_id: 1,
116        user_name: "admin",
117    }
118    .adapter_render()
119    .fetch_optional(&mut *tx)
120    .await?;
121    assert!(row.is_some());
122    let row = UserQuery {
123        user_id: 1,
124        user_name: "admin",
125    }
126    .adapter_render()
127    .fetch_one(&mut *tx)
128    .await?;
129    assert_eq!(2, row.columns().len());
130    // fetch_as
131    let users: Vec<User> = user_query.adapter_render().fetch_all_as(&pool).await?;
132    assert_eq!(data, users);
133    //println!("{:?}", users);
134
135    let u: Option<User> = UserQuery {
136        user_id: 1,
137        user_name: "admin",
138    }
139    .adapter_render()
140    .fetch_optional_as(&mut *tx)
141    .await?;
142    assert_eq!(data.first(), u.as_ref());
143    let u: User = UserQuery {
144        user_id: 1,
145        user_name: "admin",
146    }
147    .adapter_render()
148    .fetch_one_as(&mut *tx)
149    .await?;
150    assert_eq!(data.first(), Some(&u));
151
152    // stream
153    let mut query = user_query.adapter_render();
154    {
155        let stream = query.fetch(&mut *tx);
156        pin_mut!(stream);
157        while let Some(row) = stream.try_next().await? {
158            assert_eq!(2, row.columns().len());
159        }
160    }
161
162    tx.rollback().await?;
163
164    Ok(())
165}

Source

pub async fn execute<Adapter>( &'q mut self, db_adapter: Adapter, ) -> Result<DB::QueryResult, Error>
where Adapter: BackendDB<'c, DB> + 'c,

like sqlx::Query::execute Execute the query and return the number of rows affected.

Source

pub fn execute_many<Adapter>( &'q mut self, db_adapter: Adapter, ) -> impl Stream<Item = Result<DB::QueryResult, Error>>
where Adapter: BackendDB<'c, DB> + 'c,

like sqlx::Query::execute_many Execute multiple queries and return the rows affected from each query, in a stream.

Source

pub fn fetch<Adapter>( &'q mut self, db_adapter: Adapter, ) -> impl Stream<Item = Result<DB::Row, Error>>
where Adapter: BackendDB<'c, DB> + 'c,

like sqlx::Query::fetch Execute the query and return the generated results as a stream.

Examples found in repository ?

examples/example_adapter.rs (line 219)

122async fn test_adapter_query(url: &str) -> Result<(), Error> {
123    let data = vec![
124        User {
125            id: 1,
126            name: "admin".to_string(),
127        },
128        User {
129            id: 99999,
130            name: "super man".to_string(),
131        },
132    ];
133    //  test count
134    let user_query = UserQuery {
135        user_id: 1,
136        user_name: "admin",
137    };
138    let pool = AnyPool::connect(url).await?;
139
140    let mut db_adatper = user_query.adapter_render();
141
142    let count = db_adatper.count(&pool).await?;
143    assert_eq!(2, count);
144
145    // test pagination
146    let user: Option<User> = user_query
147        .adapter_render()
148        .set_page(1, 1)
149        .fetch_optional_as(&pool)
150        .await?;
151    assert_eq!(data.first(), user.as_ref());
152    // println!("{user:?}");
153
154    let mut conn = pool.acquire().await?;
155    let user: Vec<User> = user_query
156        .adapter_render()
157        .set_page(1, 2)
158        .fetch_all_as(&mut *conn)
159        .await?;
160    assert_eq!(data[1..], user);
161    // println!("{user:?}");
162
163    let page_info = user_query.adapter_render().count_page(1, &pool).await?;
164    assert_eq!(PageInfo::new(2, 1), page_info);
165    // println!("{page_info:?}");
166    //fecth
167    let mut tx = pool.begin().await?;
168
169    let rows = UserQuery {
170        user_id: 1,
171        user_name: "admin",
172    }
173    .adapter_render()
174    .fetch_all(&mut *tx)
175    .await?;
176    assert_eq!(2, rows.len());
177    //println!("{:?}", rows.len());
178    let row = UserQuery {
179        user_id: 1,
180        user_name: "admin",
181    }
182    .adapter_render()
183    .fetch_optional(&mut *tx)
184    .await?;
185    assert!(row.is_some());
186    let row = UserQuery {
187        user_id: 1,
188        user_name: "admin",
189    }
190    .adapter_render()
191    .fetch_one(&mut *tx)
192    .await?;
193    assert_eq!(2, row.columns().len());
194    // fetch_as
195    let users: Vec<User> = user_query.adapter_render().fetch_all_as(&pool).await?;
196    assert_eq!(data, users);
197    //println!("{:?}", users);
198
199    let u: Option<User> = UserQuery {
200        user_id: 1,
201        user_name: "admin",
202    }
203    .adapter_render()
204    .fetch_optional_as(&mut *tx)
205    .await?;
206    assert_eq!(data.first(), u.as_ref());
207    let u: User = UserQuery {
208        user_id: 1,
209        user_name: "admin",
210    }
211    .adapter_render()
212    .fetch_one_as(&mut *tx)
213    .await?;
214    assert_eq!(data.first(), Some(&u));
215
216    // stream
217    let mut query = user_query.adapter_render();
218    {
219        let stream = query.fetch(&mut *tx);
220        pin_mut!(stream);
221        while let Some(row) = stream.try_next().await? {
222            assert_eq!(2, row.columns().len());
223        }
224    }
225
226    tx.rollback().await?;
227
228    Ok(())
229}

More examples

Hide additional examples

examples/example_axum.rs (line 155)

58async fn test_adapter_query(url: &str) -> Result<(), Error> {
59    let data = vec![
60        User {
61            id: 1,
62            name: "admin".to_string(),
63        },
64        User {
65            id: 99999,
66            name: "super man".to_string(),
67        },
68    ];
69    //  test count
70    let user_query = UserQuery {
71        user_id: 1,
72        user_name: "admin",
73    };
74    let pool = AnyPool::connect(url).await?;
75
76    let mut db_adatper = user_query.adapter_render();
77
78    let count = db_adatper.count(&pool).await?;
79    assert_eq!(2, count);
80
81    // test pagination
82    let user: Option<User> = user_query
83        .adapter_render()
84        .set_page(1, 1)
85        .fetch_optional_as(&pool)
86        .await?;
87    assert_eq!(data.first(), user.as_ref());
88    // println!("{user:?}");
89
90    let mut conn = pool.acquire().await?;
91    let user: Vec<User> = user_query
92        .adapter_render()
93        .set_page(1, 2)
94        .fetch_all_as(&mut *conn)
95        .await?;
96    assert_eq!(data[1..], user);
97    // println!("{user:?}");
98
99    let page_info = user_query.adapter_render().count_page(1, &pool).await?;
100    assert_eq!(PageInfo::new(2, 1), page_info);
101    // println!("{page_info:?}");
102    //fecth
103    let mut tx = pool.begin().await?;
104
105    let rows = UserQuery {
106        user_id: 1,
107        user_name: "admin",
108    }
109    .adapter_render()
110    .fetch_all(&mut *tx)
111    .await?;
112    assert_eq!(2, rows.len());
113    //println!("{:?}", rows.len());
114    let row = UserQuery {
115        user_id: 1,
116        user_name: "admin",
117    }
118    .adapter_render()
119    .fetch_optional(&mut *tx)
120    .await?;
121    assert!(row.is_some());
122    let row = UserQuery {
123        user_id: 1,
124        user_name: "admin",
125    }
126    .adapter_render()
127    .fetch_one(&mut *tx)
128    .await?;
129    assert_eq!(2, row.columns().len());
130    // fetch_as
131    let users: Vec<User> = user_query.adapter_render().fetch_all_as(&pool).await?;
132    assert_eq!(data, users);
133    //println!("{:?}", users);
134
135    let u: Option<User> = UserQuery {
136        user_id: 1,
137        user_name: "admin",
138    }
139    .adapter_render()
140    .fetch_optional_as(&mut *tx)
141    .await?;
142    assert_eq!(data.first(), u.as_ref());
143    let u: User = UserQuery {
144        user_id: 1,
145        user_name: "admin",
146    }
147    .adapter_render()
148    .fetch_one_as(&mut *tx)
149    .await?;
150    assert_eq!(data.first(), Some(&u));
151
152    // stream
153    let mut query = user_query.adapter_render();
154    {
155        let stream = query.fetch(&mut *tx);
156        pin_mut!(stream);
157        while let Some(row) = stream.try_next().await? {
158            assert_eq!(2, row.columns().len());
159        }
160    }
161
162    tx.rollback().await?;
163
164    Ok(())
165}

Source

pub fn fetch_many<Adapter>( &'q mut self, db_adapter: Adapter, ) -> BoxStream<'e, Result<Either<DB::QueryResult, DB::Row>, Error>>
where Adapter: BackendDB<'c, DB> + 'c,

like sqlx::Query::fetch_many Execute multiple queries and return the generated results as a stream.

For each query in the stream, any generated rows are returned first, then the QueryResult with the number of rows affected.

Source

pub async fn fetch_all<Adapter>( &'q mut self, db_adapter: Adapter, ) -> Result<Vec<DB::Row>, Error>
where Adapter: BackendDB<'c, DB> + 'c,

like sqlx::Query::fetch_all Execute the query and return all the resulting rows collected into a Vec.

§Note: beware result set size.

This will attempt to collect the full result set of the query into memory.

To avoid exhausting available memory, ensure the result set has a known upper bound, e.g. using LIMIT.

Examples found in repository ?

examples/example_adapter.rs (line 174)

122async fn test_adapter_query(url: &str) -> Result<(), Error> {
123    let data = vec![
124        User {
125            id: 1,
126            name: "admin".to_string(),
127        },
128        User {
129            id: 99999,
130            name: "super man".to_string(),
131        },
132    ];
133    //  test count
134    let user_query = UserQuery {
135        user_id: 1,
136        user_name: "admin",
137    };
138    let pool = AnyPool::connect(url).await?;
139
140    let mut db_adatper = user_query.adapter_render();
141
142    let count = db_adatper.count(&pool).await?;
143    assert_eq!(2, count);
144
145    // test pagination
146    let user: Option<User> = user_query
147        .adapter_render()
148        .set_page(1, 1)
149        .fetch_optional_as(&pool)
150        .await?;
151    assert_eq!(data.first(), user.as_ref());
152    // println!("{user:?}");
153
154    let mut conn = pool.acquire().await?;
155    let user: Vec<User> = user_query
156        .adapter_render()
157        .set_page(1, 2)
158        .fetch_all_as(&mut *conn)
159        .await?;
160    assert_eq!(data[1..], user);
161    // println!("{user:?}");
162
163    let page_info = user_query.adapter_render().count_page(1, &pool).await?;
164    assert_eq!(PageInfo::new(2, 1), page_info);
165    // println!("{page_info:?}");
166    //fecth
167    let mut tx = pool.begin().await?;
168
169    let rows = UserQuery {
170        user_id: 1,
171        user_name: "admin",
172    }
173    .adapter_render()
174    .fetch_all(&mut *tx)
175    .await?;
176    assert_eq!(2, rows.len());
177    //println!("{:?}", rows.len());
178    let row = UserQuery {
179        user_id: 1,
180        user_name: "admin",
181    }
182    .adapter_render()
183    .fetch_optional(&mut *tx)
184    .await?;
185    assert!(row.is_some());
186    let row = UserQuery {
187        user_id: 1,
188        user_name: "admin",
189    }
190    .adapter_render()
191    .fetch_one(&mut *tx)
192    .await?;
193    assert_eq!(2, row.columns().len());
194    // fetch_as
195    let users: Vec<User> = user_query.adapter_render().fetch_all_as(&pool).await?;
196    assert_eq!(data, users);
197    //println!("{:?}", users);
198
199    let u: Option<User> = UserQuery {
200        user_id: 1,
201        user_name: "admin",
202    }
203    .adapter_render()
204    .fetch_optional_as(&mut *tx)
205    .await?;
206    assert_eq!(data.first(), u.as_ref());
207    let u: User = UserQuery {
208        user_id: 1,
209        user_name: "admin",
210    }
211    .adapter_render()
212    .fetch_one_as(&mut *tx)
213    .await?;
214    assert_eq!(data.first(), Some(&u));
215
216    // stream
217    let mut query = user_query.adapter_render();
218    {
219        let stream = query.fetch(&mut *tx);
220        pin_mut!(stream);
221        while let Some(row) = stream.try_next().await? {
222            assert_eq!(2, row.columns().len());
223        }
224    }
225
226    tx.rollback().await?;
227
228    Ok(())
229}

More examples

Hide additional examples

examples/example_axum.rs (line 110)

58async fn test_adapter_query(url: &str) -> Result<(), Error> {
59    let data = vec![
60        User {
61            id: 1,
62            name: "admin".to_string(),
63        },
64        User {
65            id: 99999,
66            name: "super man".to_string(),
67        },
68    ];
69    //  test count
70    let user_query = UserQuery {
71        user_id: 1,
72        user_name: "admin",
73    };
74    let pool = AnyPool::connect(url).await?;
75
76    let mut db_adatper = user_query.adapter_render();
77
78    let count = db_adatper.count(&pool).await?;
79    assert_eq!(2, count);
80
81    // test pagination
82    let user: Option<User> = user_query
83        .adapter_render()
84        .set_page(1, 1)
85        .fetch_optional_as(&pool)
86        .await?;
87    assert_eq!(data.first(), user.as_ref());
88    // println!("{user:?}");
89
90    let mut conn = pool.acquire().await?;
91    let user: Vec<User> = user_query
92        .adapter_render()
93        .set_page(1, 2)
94        .fetch_all_as(&mut *conn)
95        .await?;
96    assert_eq!(data[1..], user);
97    // println!("{user:?}");
98
99    let page_info = user_query.adapter_render().count_page(1, &pool).await?;
100    assert_eq!(PageInfo::new(2, 1), page_info);
101    // println!("{page_info:?}");
102    //fecth
103    let mut tx = pool.begin().await?;
104
105    let rows = UserQuery {
106        user_id: 1,
107        user_name: "admin",
108    }
109    .adapter_render()
110    .fetch_all(&mut *tx)
111    .await?;
112    assert_eq!(2, rows.len());
113    //println!("{:?}", rows.len());
114    let row = UserQuery {
115        user_id: 1,
116        user_name: "admin",
117    }
118    .adapter_render()
119    .fetch_optional(&mut *tx)
120    .await?;
121    assert!(row.is_some());
122    let row = UserQuery {
123        user_id: 1,
124        user_name: "admin",
125    }
126    .adapter_render()
127    .fetch_one(&mut *tx)
128    .await?;
129    assert_eq!(2, row.columns().len());
130    // fetch_as
131    let users: Vec<User> = user_query.adapter_render().fetch_all_as(&pool).await?;
132    assert_eq!(data, users);
133    //println!("{:?}", users);
134
135    let u: Option<User> = UserQuery {
136        user_id: 1,
137        user_name: "admin",
138    }
139    .adapter_render()
140    .fetch_optional_as(&mut *tx)
141    .await?;
142    assert_eq!(data.first(), u.as_ref());
143    let u: User = UserQuery {
144        user_id: 1,
145        user_name: "admin",
146    }
147    .adapter_render()
148    .fetch_one_as(&mut *tx)
149    .await?;
150    assert_eq!(data.first(), Some(&u));
151
152    // stream
153    let mut query = user_query.adapter_render();
154    {
155        let stream = query.fetch(&mut *tx);
156        pin_mut!(stream);
157        while let Some(row) = stream.try_next().await? {
158            assert_eq!(2, row.columns().len());
159        }
160    }
161
162    tx.rollback().await?;
163
164    Ok(())
165}

Source

pub async fn fetch_one<Adapter>( &'q mut self, db_adapter: Adapter, ) -> Result<DB::Row, Error>
where Adapter: BackendDB<'c, DB> + 'c,

like sqlx::Query::fetch_one Execute the query, returning the first row or Error::RowNotFound otherwise.

§Note: for best performance, ensure the query returns at most one row.

Depending on the driver implementation, if your query can return more than one row, it may lead to wasted CPU time and bandwidth on the database server.

Even when the driver implementation takes this into account, ensuring the query returns at most one row can result in a more optimal query plan.

If your query has a WHERE clause filtering a unique column by a single value, you’re good.

Otherwise, you might want to add LIMIT 1 to your query.

Examples found in repository ?

examples/example_adapter.rs (line 191)

122async fn test_adapter_query(url: &str) -> Result<(), Error> {
123    let data = vec![
124        User {
125            id: 1,
126            name: "admin".to_string(),
127        },
128        User {
129            id: 99999,
130            name: "super man".to_string(),
131        },
132    ];
133    //  test count
134    let user_query = UserQuery {
135        user_id: 1,
136        user_name: "admin",
137    };
138    let pool = AnyPool::connect(url).await?;
139
140    let mut db_adatper = user_query.adapter_render();
141
142    let count = db_adatper.count(&pool).await?;
143    assert_eq!(2, count);
144
145    // test pagination
146    let user: Option<User> = user_query
147        .adapter_render()
148        .set_page(1, 1)
149        .fetch_optional_as(&pool)
150        .await?;
151    assert_eq!(data.first(), user.as_ref());
152    // println!("{user:?}");
153
154    let mut conn = pool.acquire().await?;
155    let user: Vec<User> = user_query
156        .adapter_render()
157        .set_page(1, 2)
158        .fetch_all_as(&mut *conn)
159        .await?;
160    assert_eq!(data[1..], user);
161    // println!("{user:?}");
162
163    let page_info = user_query.adapter_render().count_page(1, &pool).await?;
164    assert_eq!(PageInfo::new(2, 1), page_info);
165    // println!("{page_info:?}");
166    //fecth
167    let mut tx = pool.begin().await?;
168
169    let rows = UserQuery {
170        user_id: 1,
171        user_name: "admin",
172    }
173    .adapter_render()
174    .fetch_all(&mut *tx)
175    .await?;
176    assert_eq!(2, rows.len());
177    //println!("{:?}", rows.len());
178    let row = UserQuery {
179        user_id: 1,
180        user_name: "admin",
181    }
182    .adapter_render()
183    .fetch_optional(&mut *tx)
184    .await?;
185    assert!(row.is_some());
186    let row = UserQuery {
187        user_id: 1,
188        user_name: "admin",
189    }
190    .adapter_render()
191    .fetch_one(&mut *tx)
192    .await?;
193    assert_eq!(2, row.columns().len());
194    // fetch_as
195    let users: Vec<User> = user_query.adapter_render().fetch_all_as(&pool).await?;
196    assert_eq!(data, users);
197    //println!("{:?}", users);
198
199    let u: Option<User> = UserQuery {
200        user_id: 1,
201        user_name: "admin",
202    }
203    .adapter_render()
204    .fetch_optional_as(&mut *tx)
205    .await?;
206    assert_eq!(data.first(), u.as_ref());
207    let u: User = UserQuery {
208        user_id: 1,
209        user_name: "admin",
210    }
211    .adapter_render()
212    .fetch_one_as(&mut *tx)
213    .await?;
214    assert_eq!(data.first(), Some(&u));
215
216    // stream
217    let mut query = user_query.adapter_render();
218    {
219        let stream = query.fetch(&mut *tx);
220        pin_mut!(stream);
221        while let Some(row) = stream.try_next().await? {
222            assert_eq!(2, row.columns().len());
223        }
224    }
225
226    tx.rollback().await?;
227
228    Ok(())
229}

More examples

Hide additional examples

examples/example_axum.rs (line 127)

58async fn test_adapter_query(url: &str) -> Result<(), Error> {
59    let data = vec![
60        User {
61            id: 1,
62            name: "admin".to_string(),
63        },
64        User {
65            id: 99999,
66            name: "super man".to_string(),
67        },
68    ];
69    //  test count
70    let user_query = UserQuery {
71        user_id: 1,
72        user_name: "admin",
73    };
74    let pool = AnyPool::connect(url).await?;
75
76    let mut db_adatper = user_query.adapter_render();
77
78    let count = db_adatper.count(&pool).await?;
79    assert_eq!(2, count);
80
81    // test pagination
82    let user: Option<User> = user_query
83        .adapter_render()
84        .set_page(1, 1)
85        .fetch_optional_as(&pool)
86        .await?;
87    assert_eq!(data.first(), user.as_ref());
88    // println!("{user:?}");
89
90    let mut conn = pool.acquire().await?;
91    let user: Vec<User> = user_query
92        .adapter_render()
93        .set_page(1, 2)
94        .fetch_all_as(&mut *conn)
95        .await?;
96    assert_eq!(data[1..], user);
97    // println!("{user:?}");
98
99    let page_info = user_query.adapter_render().count_page(1, &pool).await?;
100    assert_eq!(PageInfo::new(2, 1), page_info);
101    // println!("{page_info:?}");
102    //fecth
103    let mut tx = pool.begin().await?;
104
105    let rows = UserQuery {
106        user_id: 1,
107        user_name: "admin",
108    }
109    .adapter_render()
110    .fetch_all(&mut *tx)
111    .await?;
112    assert_eq!(2, rows.len());
113    //println!("{:?}", rows.len());
114    let row = UserQuery {
115        user_id: 1,
116        user_name: "admin",
117    }
118    .adapter_render()
119    .fetch_optional(&mut *tx)
120    .await?;
121    assert!(row.is_some());
122    let row = UserQuery {
123        user_id: 1,
124        user_name: "admin",
125    }
126    .adapter_render()
127    .fetch_one(&mut *tx)
128    .await?;
129    assert_eq!(2, row.columns().len());
130    // fetch_as
131    let users: Vec<User> = user_query.adapter_render().fetch_all_as(&pool).await?;
132    assert_eq!(data, users);
133    //println!("{:?}", users);
134
135    let u: Option<User> = UserQuery {
136        user_id: 1,
137        user_name: "admin",
138    }
139    .adapter_render()
140    .fetch_optional_as(&mut *tx)
141    .await?;
142    assert_eq!(data.first(), u.as_ref());
143    let u: User = UserQuery {
144        user_id: 1,
145        user_name: "admin",
146    }
147    .adapter_render()
148    .fetch_one_as(&mut *tx)
149    .await?;
150    assert_eq!(data.first(), Some(&u));
151
152    // stream
153    let mut query = user_query.adapter_render();
154    {
155        let stream = query.fetch(&mut *tx);
156        pin_mut!(stream);
157        while let Some(row) = stream.try_next().await? {
158            assert_eq!(2, row.columns().len());
159        }
160    }
161
162    tx.rollback().await?;
163
164    Ok(())
165}

Source

pub async fn fetch_optional<Adapter>( &'q mut self, db_adapter: Adapter, ) -> Result<Option<DB::Row>, Error>
where Adapter: BackendDB<'c, DB> + 'c,

like sqlx::Query::fetch_optional Execute the query, returning the first row or None otherwise.

§Note: for best performance, ensure the query returns at most one row.

Depending on the driver implementation, if your query can return more than one row, it may lead to wasted CPU time and bandwidth on the database server.

Even when the driver implementation takes this into account, ensuring the query returns at most one row can result in a more optimal query plan.

If your query has a WHERE clause filtering a unique column by a single value, you’re good.

Otherwise, you might want to add LIMIT 1 to your query.

Examples found in repository ?

examples/example_adapter.rs (line 183)

122async fn test_adapter_query(url: &str) -> Result<(), Error> {
123    let data = vec![
124        User {
125            id: 1,
126            name: "admin".to_string(),
127        },
128        User {
129            id: 99999,
130            name: "super man".to_string(),
131        },
132    ];
133    //  test count
134    let user_query = UserQuery {
135        user_id: 1,
136        user_name: "admin",
137    };
138    let pool = AnyPool::connect(url).await?;
139
140    let mut db_adatper = user_query.adapter_render();
141
142    let count = db_adatper.count(&pool).await?;
143    assert_eq!(2, count);
144
145    // test pagination
146    let user: Option<User> = user_query
147        .adapter_render()
148        .set_page(1, 1)
149        .fetch_optional_as(&pool)
150        .await?;
151    assert_eq!(data.first(), user.as_ref());
152    // println!("{user:?}");
153
154    let mut conn = pool.acquire().await?;
155    let user: Vec<User> = user_query
156        .adapter_render()
157        .set_page(1, 2)
158        .fetch_all_as(&mut *conn)
159        .await?;
160    assert_eq!(data[1..], user);
161    // println!("{user:?}");
162
163    let page_info = user_query.adapter_render().count_page(1, &pool).await?;
164    assert_eq!(PageInfo::new(2, 1), page_info);
165    // println!("{page_info:?}");
166    //fecth
167    let mut tx = pool.begin().await?;
168
169    let rows = UserQuery {
170        user_id: 1,
171        user_name: "admin",
172    }
173    .adapter_render()
174    .fetch_all(&mut *tx)
175    .await?;
176    assert_eq!(2, rows.len());
177    //println!("{:?}", rows.len());
178    let row = UserQuery {
179        user_id: 1,
180        user_name: "admin",
181    }
182    .adapter_render()
183    .fetch_optional(&mut *tx)
184    .await?;
185    assert!(row.is_some());
186    let row = UserQuery {
187        user_id: 1,
188        user_name: "admin",
189    }
190    .adapter_render()
191    .fetch_one(&mut *tx)
192    .await?;
193    assert_eq!(2, row.columns().len());
194    // fetch_as
195    let users: Vec<User> = user_query.adapter_render().fetch_all_as(&pool).await?;
196    assert_eq!(data, users);
197    //println!("{:?}", users);
198
199    let u: Option<User> = UserQuery {
200        user_id: 1,
201        user_name: "admin",
202    }
203    .adapter_render()
204    .fetch_optional_as(&mut *tx)
205    .await?;
206    assert_eq!(data.first(), u.as_ref());
207    let u: User = UserQuery {
208        user_id: 1,
209        user_name: "admin",
210    }
211    .adapter_render()
212    .fetch_one_as(&mut *tx)
213    .await?;
214    assert_eq!(data.first(), Some(&u));
215
216    // stream
217    let mut query = user_query.adapter_render();
218    {
219        let stream = query.fetch(&mut *tx);
220        pin_mut!(stream);
221        while let Some(row) = stream.try_next().await? {
222            assert_eq!(2, row.columns().len());
223        }
224    }
225
226    tx.rollback().await?;
227
228    Ok(())
229}

More examples

Hide additional examples

examples/example_axum.rs (line 119)

58async fn test_adapter_query(url: &str) -> Result<(), Error> {
59    let data = vec![
60        User {
61            id: 1,
62            name: "admin".to_string(),
63        },
64        User {
65            id: 99999,
66            name: "super man".to_string(),
67        },
68    ];
69    //  test count
70    let user_query = UserQuery {
71        user_id: 1,
72        user_name: "admin",
73    };
74    let pool = AnyPool::connect(url).await?;
75
76    let mut db_adatper = user_query.adapter_render();
77
78    let count = db_adatper.count(&pool).await?;
79    assert_eq!(2, count);
80
81    // test pagination
82    let user: Option<User> = user_query
83        .adapter_render()
84        .set_page(1, 1)
85        .fetch_optional_as(&pool)
86        .await?;
87    assert_eq!(data.first(), user.as_ref());
88    // println!("{user:?}");
89
90    let mut conn = pool.acquire().await?;
91    let user: Vec<User> = user_query
92        .adapter_render()
93        .set_page(1, 2)
94        .fetch_all_as(&mut *conn)
95        .await?;
96    assert_eq!(data[1..], user);
97    // println!("{user:?}");
98
99    let page_info = user_query.adapter_render().count_page(1, &pool).await?;
100    assert_eq!(PageInfo::new(2, 1), page_info);
101    // println!("{page_info:?}");
102    //fecth
103    let mut tx = pool.begin().await?;
104
105    let rows = UserQuery {
106        user_id: 1,
107        user_name: "admin",
108    }
109    .adapter_render()
110    .fetch_all(&mut *tx)
111    .await?;
112    assert_eq!(2, rows.len());
113    //println!("{:?}", rows.len());
114    let row = UserQuery {
115        user_id: 1,
116        user_name: "admin",
117    }
118    .adapter_render()
119    .fetch_optional(&mut *tx)
120    .await?;
121    assert!(row.is_some());
122    let row = UserQuery {
123        user_id: 1,
124        user_name: "admin",
125    }
126    .adapter_render()
127    .fetch_one(&mut *tx)
128    .await?;
129    assert_eq!(2, row.columns().len());
130    // fetch_as
131    let users: Vec<User> = user_query.adapter_render().fetch_all_as(&pool).await?;
132    assert_eq!(data, users);
133    //println!("{:?}", users);
134
135    let u: Option<User> = UserQuery {
136        user_id: 1,
137        user_name: "admin",
138    }
139    .adapter_render()
140    .fetch_optional_as(&mut *tx)
141    .await?;
142    assert_eq!(data.first(), u.as_ref());
143    let u: User = UserQuery {
144        user_id: 1,
145        user_name: "admin",
146    }
147    .adapter_render()
148    .fetch_one_as(&mut *tx)
149    .await?;
150    assert_eq!(data.first(), Some(&u));
151
152    // stream
153    let mut query = user_query.adapter_render();
154    {
155        let stream = query.fetch(&mut *tx);
156        pin_mut!(stream);
157        while let Some(row) = stream.try_next().await? {
158            assert_eq!(2, row.columns().len());
159        }
160    }
161
162    tx.rollback().await?;
163
164    Ok(())
165}

Source

pub async fn fetch_as<Adapter, O>( &'q mut self, db_adapter: Adapter, ) -> impl Stream<Item = Result<O, Error>>
where Adapter: BackendDB<'c, DB> + 'c, O: Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'e,

like sqlx::QueryAs::fetch Execute the query and return the generated results as a stream.

Source

pub fn fetch_many_as<Adapter, O>( &'q mut self, db_adapter: Adapter, ) -> BoxStream<'e, Result<Either<DB::QueryResult, O>, Error>>
where Adapter: BackendDB<'c, DB> + 'c, O: Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'e,

like sqlx::QueryAs::fetch_many Execute multiple queries and return the generated results as a stream from each query, in a stream.

Source

pub async fn fetch_all_as<Adapter, O>( &'q mut self, db_adapter: Adapter, ) -> Result<Vec<O>, Error>
where Adapter: BackendDB<'c, DB> + 'c, O: Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'e,

like sqlx::QueryAs::fetch_all Execute the query and return all the resulting rows collected into a Vec.

§Note: beware result set size.

This will attempt to collect the full result set of the query into memory.

To avoid exhausting available memory, ensure the result set has a known upper bound, e.g. using LIMIT.

Examples found in repository ?

examples/example_ntex.rs (line 68)

56async fn root(pool: State<AnyPool>) -> impl Responder {
57    //  test count
58    let user_query = UserQuery {
59        user_id: 1,
60        user_name: "ntex",
61    };
62    let count = user_query.adapter_render().count(&*pool).await.unwrap();
63    println!("count: {count}");
64
65    let mut conn = pool.acquire().await.unwrap();
66    let users: Vec<User> = user_query
67        .adapter_render()
68        .fetch_all_as(&mut *conn)
69        .await
70        .unwrap();
71
72    Response::Ok().body(IndexHtml { users }.render().unwrap())
73}

More examples

Hide additional examples

examples/example_actix.rs (line 68)

56async fn root(pool: Data<AnyPool>) -> impl actix_web::Responder {
57    //  test count
58    let user_query = UserQuery {
59        user_id: 1,
60        user_name: "actix",
61    };
62    let count = user_query.adapter_render().count(&**pool).await.unwrap();
63    println!("count: {count}");
64
65    let mut conn = pool.acquire().await.unwrap();
66    let users: Vec<User> = user_query
67        .adapter_render()
68        .fetch_all_as(&mut *conn)
69        .await
70        .unwrap();
71
72    Html::new(IndexHtml { users }.render().unwrap())
73}

examples/example_marco.rs (line 76)

25async fn simple_query() -> Result<(), Error> {
26    let users = vec![
27        User {
28            id: 1,
29            name: "admin".to_string(),
30        },
31        User {
32            id: 99999_i64,
33            name: "super man".to_string(),
34        },
35    ];
36
37    let user_query = UserQuery {
38        user_id: 1,
39        user_name: "admin".to_string(),
40    };
41    //pg
42
43    let pool = sqlx::PgPool::connect("postgres://postgres:postgres@localhost/postgres").await?;
44    let mut sql_buff = String::new();
45    let execute = user_query.render_executable(&mut sql_buff)?;
46
47    let rows = pool.fetch_all(execute).await?;
48    let mut db_users = Vec::new();
49    for row in &rows {
50        db_users.push(User::from_row(row)?);
51    }
52    assert_eq!(db_users, users);
53
54    //sqlite+any
55    install_default_drivers();
56    let pool = AnyPool::connect("sqlite://db.file?mode=memory").await?;
57    let mut sql_buff = String::new();
58    let rows = user_query
59        .render_executable(&mut sql_buff)?
60        .fetch_all(&pool)
61        .await?;
62
63    let mut db_users = Vec::new();
64    for row in &rows {
65        db_users.push(User::from_row(row)?);
66    }
67    assert_eq!(db_users, users);
68
69    //mysql
70
71    let pool = MySqlPool::connect("mysql://root:root@localhost/mysql").await?;
72
73    let db_users: Vec<User> = user_query
74        .adapter_render()
75        .set_persistent(false)
76        .fetch_all_as(&pool)
77        .await?;
78
79    assert_eq!(db_users, users);
80    Ok(())
81}

examples/example_adapter.rs (line 158)

122async fn test_adapter_query(url: &str) -> Result<(), Error> {
123    let data = vec![
124        User {
125            id: 1,
126            name: "admin".to_string(),
127        },
128        User {
129            id: 99999,
130            name: "super man".to_string(),
131        },
132    ];
133    //  test count
134    let user_query = UserQuery {
135        user_id: 1,
136        user_name: "admin",
137    };
138    let pool = AnyPool::connect(url).await?;
139
140    let mut db_adatper = user_query.adapter_render();
141
142    let count = db_adatper.count(&pool).await?;
143    assert_eq!(2, count);
144
145    // test pagination
146    let user: Option<User> = user_query
147        .adapter_render()
148        .set_page(1, 1)
149        .fetch_optional_as(&pool)
150        .await?;
151    assert_eq!(data.first(), user.as_ref());
152    // println!("{user:?}");
153
154    let mut conn = pool.acquire().await?;
155    let user: Vec<User> = user_query
156        .adapter_render()
157        .set_page(1, 2)
158        .fetch_all_as(&mut *conn)
159        .await?;
160    assert_eq!(data[1..], user);
161    // println!("{user:?}");
162
163    let page_info = user_query.adapter_render().count_page(1, &pool).await?;
164    assert_eq!(PageInfo::new(2, 1), page_info);
165    // println!("{page_info:?}");
166    //fecth
167    let mut tx = pool.begin().await?;
168
169    let rows = UserQuery {
170        user_id: 1,
171        user_name: "admin",
172    }
173    .adapter_render()
174    .fetch_all(&mut *tx)
175    .await?;
176    assert_eq!(2, rows.len());
177    //println!("{:?}", rows.len());
178    let row = UserQuery {
179        user_id: 1,
180        user_name: "admin",
181    }
182    .adapter_render()
183    .fetch_optional(&mut *tx)
184    .await?;
185    assert!(row.is_some());
186    let row = UserQuery {
187        user_id: 1,
188        user_name: "admin",
189    }
190    .adapter_render()
191    .fetch_one(&mut *tx)
192    .await?;
193    assert_eq!(2, row.columns().len());
194    // fetch_as
195    let users: Vec<User> = user_query.adapter_render().fetch_all_as(&pool).await?;
196    assert_eq!(data, users);
197    //println!("{:?}", users);
198
199    let u: Option<User> = UserQuery {
200        user_id: 1,
201        user_name: "admin",
202    }
203    .adapter_render()
204    .fetch_optional_as(&mut *tx)
205    .await?;
206    assert_eq!(data.first(), u.as_ref());
207    let u: User = UserQuery {
208        user_id: 1,
209        user_name: "admin",
210    }
211    .adapter_render()
212    .fetch_one_as(&mut *tx)
213    .await?;
214    assert_eq!(data.first(), Some(&u));
215
216    // stream
217    let mut query = user_query.adapter_render();
218    {
219        let stream = query.fetch(&mut *tx);
220        pin_mut!(stream);
221        while let Some(row) = stream.try_next().await? {
222            assert_eq!(2, row.columns().len());
223        }
224    }
225
226    tx.rollback().await?;
227
228    Ok(())
229}

examples/example_axum.rs (line 94)

58async fn test_adapter_query(url: &str) -> Result<(), Error> {
59    let data = vec![
60        User {
61            id: 1,
62            name: "admin".to_string(),
63        },
64        User {
65            id: 99999,
66            name: "super man".to_string(),
67        },
68    ];
69    //  test count
70    let user_query = UserQuery {
71        user_id: 1,
72        user_name: "admin",
73    };
74    let pool = AnyPool::connect(url).await?;
75
76    let mut db_adatper = user_query.adapter_render();
77
78    let count = db_adatper.count(&pool).await?;
79    assert_eq!(2, count);
80
81    // test pagination
82    let user: Option<User> = user_query
83        .adapter_render()
84        .set_page(1, 1)
85        .fetch_optional_as(&pool)
86        .await?;
87    assert_eq!(data.first(), user.as_ref());
88    // println!("{user:?}");
89
90    let mut conn = pool.acquire().await?;
91    let user: Vec<User> = user_query
92        .adapter_render()
93        .set_page(1, 2)
94        .fetch_all_as(&mut *conn)
95        .await?;
96    assert_eq!(data[1..], user);
97    // println!("{user:?}");
98
99    let page_info = user_query.adapter_render().count_page(1, &pool).await?;
100    assert_eq!(PageInfo::new(2, 1), page_info);
101    // println!("{page_info:?}");
102    //fecth
103    let mut tx = pool.begin().await?;
104
105    let rows = UserQuery {
106        user_id: 1,
107        user_name: "admin",
108    }
109    .adapter_render()
110    .fetch_all(&mut *tx)
111    .await?;
112    assert_eq!(2, rows.len());
113    //println!("{:?}", rows.len());
114    let row = UserQuery {
115        user_id: 1,
116        user_name: "admin",
117    }
118    .adapter_render()
119    .fetch_optional(&mut *tx)
120    .await?;
121    assert!(row.is_some());
122    let row = UserQuery {
123        user_id: 1,
124        user_name: "admin",
125    }
126    .adapter_render()
127    .fetch_one(&mut *tx)
128    .await?;
129    assert_eq!(2, row.columns().len());
130    // fetch_as
131    let users: Vec<User> = user_query.adapter_render().fetch_all_as(&pool).await?;
132    assert_eq!(data, users);
133    //println!("{:?}", users);
134
135    let u: Option<User> = UserQuery {
136        user_id: 1,
137        user_name: "admin",
138    }
139    .adapter_render()
140    .fetch_optional_as(&mut *tx)
141    .await?;
142    assert_eq!(data.first(), u.as_ref());
143    let u: User = UserQuery {
144        user_id: 1,
145        user_name: "admin",
146    }
147    .adapter_render()
148    .fetch_one_as(&mut *tx)
149    .await?;
150    assert_eq!(data.first(), Some(&u));
151
152    // stream
153    let mut query = user_query.adapter_render();
154    {
155        let stream = query.fetch(&mut *tx);
156        pin_mut!(stream);
157        while let Some(row) = stream.try_next().await? {
158            assert_eq!(2, row.columns().len());
159        }
160    }
161
162    tx.rollback().await?;
163
164    Ok(())
165}
166#[axum::debug_handler]
167async fn root(State(pool): State<AnyPool>) -> impl axum::response::IntoResponse {
168    test_adapter_query("sqlite://db.file?mode=memory")
169        .await
170        .unwrap();
171    //  test count
172    let user_query = UserQuery {
173        user_id: 1,
174        user_name: "axum",
175    };
176    let count = user_query.adapter_render().count(&pool).await.unwrap();
177    println!("count: {count}");
178
179    let mut conn = pool.acquire().await.unwrap();
180    let rows = user_query
181        .adapter_render()
182        .fetch_all_as(&mut *conn)
183        .await
184        .unwrap();
185    Html(IndexHtml { users: rows }.render().unwrap())
186}

Source

pub async fn fetch_one_as<Adapter, O>( &'q mut self, db_adapter: Adapter, ) -> Result<O, Error>
where Adapter: BackendDB<'c, DB> + 'c, O: Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'e,

like sqlx::QueryAs::fetch_one Execute the query, returning the first row or Error::RowNotFound otherwise.

§Note: for best performance, ensure the query returns at most one row.

Depending on the driver implementation, if your query can return more than one row, it may lead to wasted CPU time and bandwidth on the database server.

Even when the driver implementation takes this into account, ensuring the query returns at most one row can result in a more optimal query plan.

If your query has a WHERE clause filtering a unique column by a single value, you’re good.

Otherwise, you might want to add LIMIT 1 to your query.

Examples found in repository ?

examples/example_adapter.rs (line 212)

122async fn test_adapter_query(url: &str) -> Result<(), Error> {
123    let data = vec![
124        User {
125            id: 1,
126            name: "admin".to_string(),
127        },
128        User {
129            id: 99999,
130            name: "super man".to_string(),
131        },
132    ];
133    //  test count
134    let user_query = UserQuery {
135        user_id: 1,
136        user_name: "admin",
137    };
138    let pool = AnyPool::connect(url).await?;
139
140    let mut db_adatper = user_query.adapter_render();
141
142    let count = db_adatper.count(&pool).await?;
143    assert_eq!(2, count);
144
145    // test pagination
146    let user: Option<User> = user_query
147        .adapter_render()
148        .set_page(1, 1)
149        .fetch_optional_as(&pool)
150        .await?;
151    assert_eq!(data.first(), user.as_ref());
152    // println!("{user:?}");
153
154    let mut conn = pool.acquire().await?;
155    let user: Vec<User> = user_query
156        .adapter_render()
157        .set_page(1, 2)
158        .fetch_all_as(&mut *conn)
159        .await?;
160    assert_eq!(data[1..], user);
161    // println!("{user:?}");
162
163    let page_info = user_query.adapter_render().count_page(1, &pool).await?;
164    assert_eq!(PageInfo::new(2, 1), page_info);
165    // println!("{page_info:?}");
166    //fecth
167    let mut tx = pool.begin().await?;
168
169    let rows = UserQuery {
170        user_id: 1,
171        user_name: "admin",
172    }
173    .adapter_render()
174    .fetch_all(&mut *tx)
175    .await?;
176    assert_eq!(2, rows.len());
177    //println!("{:?}", rows.len());
178    let row = UserQuery {
179        user_id: 1,
180        user_name: "admin",
181    }
182    .adapter_render()
183    .fetch_optional(&mut *tx)
184    .await?;
185    assert!(row.is_some());
186    let row = UserQuery {
187        user_id: 1,
188        user_name: "admin",
189    }
190    .adapter_render()
191    .fetch_one(&mut *tx)
192    .await?;
193    assert_eq!(2, row.columns().len());
194    // fetch_as
195    let users: Vec<User> = user_query.adapter_render().fetch_all_as(&pool).await?;
196    assert_eq!(data, users);
197    //println!("{:?}", users);
198
199    let u: Option<User> = UserQuery {
200        user_id: 1,
201        user_name: "admin",
202    }
203    .adapter_render()
204    .fetch_optional_as(&mut *tx)
205    .await?;
206    assert_eq!(data.first(), u.as_ref());
207    let u: User = UserQuery {
208        user_id: 1,
209        user_name: "admin",
210    }
211    .adapter_render()
212    .fetch_one_as(&mut *tx)
213    .await?;
214    assert_eq!(data.first(), Some(&u));
215
216    // stream
217    let mut query = user_query.adapter_render();
218    {
219        let stream = query.fetch(&mut *tx);
220        pin_mut!(stream);
221        while let Some(row) = stream.try_next().await? {
222            assert_eq!(2, row.columns().len());
223        }
224    }
225
226    tx.rollback().await?;
227
228    Ok(())
229}

More examples

Hide additional examples

examples/example_axum.rs (line 148)

58async fn test_adapter_query(url: &str) -> Result<(), Error> {
59    let data = vec![
60        User {
61            id: 1,
62            name: "admin".to_string(),
63        },
64        User {
65            id: 99999,
66            name: "super man".to_string(),
67        },
68    ];
69    //  test count
70    let user_query = UserQuery {
71        user_id: 1,
72        user_name: "admin",
73    };
74    let pool = AnyPool::connect(url).await?;
75
76    let mut db_adatper = user_query.adapter_render();
77
78    let count = db_adatper.count(&pool).await?;
79    assert_eq!(2, count);
80
81    // test pagination
82    let user: Option<User> = user_query
83        .adapter_render()
84        .set_page(1, 1)
85        .fetch_optional_as(&pool)
86        .await?;
87    assert_eq!(data.first(), user.as_ref());
88    // println!("{user:?}");
89
90    let mut conn = pool.acquire().await?;
91    let user: Vec<User> = user_query
92        .adapter_render()
93        .set_page(1, 2)
94        .fetch_all_as(&mut *conn)
95        .await?;
96    assert_eq!(data[1..], user);
97    // println!("{user:?}");
98
99    let page_info = user_query.adapter_render().count_page(1, &pool).await?;
100    assert_eq!(PageInfo::new(2, 1), page_info);
101    // println!("{page_info:?}");
102    //fecth
103    let mut tx = pool.begin().await?;
104
105    let rows = UserQuery {
106        user_id: 1,
107        user_name: "admin",
108    }
109    .adapter_render()
110    .fetch_all(&mut *tx)
111    .await?;
112    assert_eq!(2, rows.len());
113    //println!("{:?}", rows.len());
114    let row = UserQuery {
115        user_id: 1,
116        user_name: "admin",
117    }
118    .adapter_render()
119    .fetch_optional(&mut *tx)
120    .await?;
121    assert!(row.is_some());
122    let row = UserQuery {
123        user_id: 1,
124        user_name: "admin",
125    }
126    .adapter_render()
127    .fetch_one(&mut *tx)
128    .await?;
129    assert_eq!(2, row.columns().len());
130    // fetch_as
131    let users: Vec<User> = user_query.adapter_render().fetch_all_as(&pool).await?;
132    assert_eq!(data, users);
133    //println!("{:?}", users);
134
135    let u: Option<User> = UserQuery {
136        user_id: 1,
137        user_name: "admin",
138    }
139    .adapter_render()
140    .fetch_optional_as(&mut *tx)
141    .await?;
142    assert_eq!(data.first(), u.as_ref());
143    let u: User = UserQuery {
144        user_id: 1,
145        user_name: "admin",
146    }
147    .adapter_render()
148    .fetch_one_as(&mut *tx)
149    .await?;
150    assert_eq!(data.first(), Some(&u));
151
152    // stream
153    let mut query = user_query.adapter_render();
154    {
155        let stream = query.fetch(&mut *tx);
156        pin_mut!(stream);
157        while let Some(row) = stream.try_next().await? {
158            assert_eq!(2, row.columns().len());
159        }
160    }
161
162    tx.rollback().await?;
163
164    Ok(())
165}

Source

pub async fn fetch_optional_as<Adapter, O>( &'q mut self, db_adapter: Adapter, ) -> Result<Option<O>, Error>
where Adapter: BackendDB<'c, DB> + 'c, O: Send + Unpin + for<'r> FromRow<'r, DB::Row>,

like sqlx::QueryAs::fetch_optional Execute the query, returning the first row or None otherwise.

§Note: for best performance, ensure the query returns at most one row.

Depending on the driver implementation, if your query can return more than one row, it may lead to wasted CPU time and bandwidth on the database server.

Even when the driver implementation takes this into account, ensuring the query returns at most one row can result in a more optimal query plan.

If your query has a WHERE clause filtering a unique column by a single value, you’re good.

Otherwise, you might want to add LIMIT 1 to your query.

Examples found in repository ?

examples/example_adapter.rs (line 149)

122async fn test_adapter_query(url: &str) -> Result<(), Error> {
123    let data = vec![
124        User {
125            id: 1,
126            name: "admin".to_string(),
127        },
128        User {
129            id: 99999,
130            name: "super man".to_string(),
131        },
132    ];
133    //  test count
134    let user_query = UserQuery {
135        user_id: 1,
136        user_name: "admin",
137    };
138    let pool = AnyPool::connect(url).await?;
139
140    let mut db_adatper = user_query.adapter_render();
141
142    let count = db_adatper.count(&pool).await?;
143    assert_eq!(2, count);
144
145    // test pagination
146    let user: Option<User> = user_query
147        .adapter_render()
148        .set_page(1, 1)
149        .fetch_optional_as(&pool)
150        .await?;
151    assert_eq!(data.first(), user.as_ref());
152    // println!("{user:?}");
153
154    let mut conn = pool.acquire().await?;
155    let user: Vec<User> = user_query
156        .adapter_render()
157        .set_page(1, 2)
158        .fetch_all_as(&mut *conn)
159        .await?;
160    assert_eq!(data[1..], user);
161    // println!("{user:?}");
162
163    let page_info = user_query.adapter_render().count_page(1, &pool).await?;
164    assert_eq!(PageInfo::new(2, 1), page_info);
165    // println!("{page_info:?}");
166    //fecth
167    let mut tx = pool.begin().await?;
168
169    let rows = UserQuery {
170        user_id: 1,
171        user_name: "admin",
172    }
173    .adapter_render()
174    .fetch_all(&mut *tx)
175    .await?;
176    assert_eq!(2, rows.len());
177    //println!("{:?}", rows.len());
178    let row = UserQuery {
179        user_id: 1,
180        user_name: "admin",
181    }
182    .adapter_render()
183    .fetch_optional(&mut *tx)
184    .await?;
185    assert!(row.is_some());
186    let row = UserQuery {
187        user_id: 1,
188        user_name: "admin",
189    }
190    .adapter_render()
191    .fetch_one(&mut *tx)
192    .await?;
193    assert_eq!(2, row.columns().len());
194    // fetch_as
195    let users: Vec<User> = user_query.adapter_render().fetch_all_as(&pool).await?;
196    assert_eq!(data, users);
197    //println!("{:?}", users);
198
199    let u: Option<User> = UserQuery {
200        user_id: 1,
201        user_name: "admin",
202    }
203    .adapter_render()
204    .fetch_optional_as(&mut *tx)
205    .await?;
206    assert_eq!(data.first(), u.as_ref());
207    let u: User = UserQuery {
208        user_id: 1,
209        user_name: "admin",
210    }
211    .adapter_render()
212    .fetch_one_as(&mut *tx)
213    .await?;
214    assert_eq!(data.first(), Some(&u));
215
216    // stream
217    let mut query = user_query.adapter_render();
218    {
219        let stream = query.fetch(&mut *tx);
220        pin_mut!(stream);
221        while let Some(row) = stream.try_next().await? {
222            assert_eq!(2, row.columns().len());
223        }
224    }
225
226    tx.rollback().await?;
227
228    Ok(())
229}

More examples

Hide additional examples

examples/example_axum.rs (line 85)

58async fn test_adapter_query(url: &str) -> Result<(), Error> {
59    let data = vec![
60        User {
61            id: 1,
62            name: "admin".to_string(),
63        },
64        User {
65            id: 99999,
66            name: "super man".to_string(),
67        },
68    ];
69    //  test count
70    let user_query = UserQuery {
71        user_id: 1,
72        user_name: "admin",
73    };
74    let pool = AnyPool::connect(url).await?;
75
76    let mut db_adatper = user_query.adapter_render();
77
78    let count = db_adatper.count(&pool).await?;
79    assert_eq!(2, count);
80
81    // test pagination
82    let user: Option<User> = user_query
83        .adapter_render()
84        .set_page(1, 1)
85        .fetch_optional_as(&pool)
86        .await?;
87    assert_eq!(data.first(), user.as_ref());
88    // println!("{user:?}");
89
90    let mut conn = pool.acquire().await?;
91    let user: Vec<User> = user_query
92        .adapter_render()
93        .set_page(1, 2)
94        .fetch_all_as(&mut *conn)
95        .await?;
96    assert_eq!(data[1..], user);
97    // println!("{user:?}");
98
99    let page_info = user_query.adapter_render().count_page(1, &pool).await?;
100    assert_eq!(PageInfo::new(2, 1), page_info);
101    // println!("{page_info:?}");
102    //fecth
103    let mut tx = pool.begin().await?;
104
105    let rows = UserQuery {
106        user_id: 1,
107        user_name: "admin",
108    }
109    .adapter_render()
110    .fetch_all(&mut *tx)
111    .await?;
112    assert_eq!(2, rows.len());
113    //println!("{:?}", rows.len());
114    let row = UserQuery {
115        user_id: 1,
116        user_name: "admin",
117    }
118    .adapter_render()
119    .fetch_optional(&mut *tx)
120    .await?;
121    assert!(row.is_some());
122    let row = UserQuery {
123        user_id: 1,
124        user_name: "admin",
125    }
126    .adapter_render()
127    .fetch_one(&mut *tx)
128    .await?;
129    assert_eq!(2, row.columns().len());
130    // fetch_as
131    let users: Vec<User> = user_query.adapter_render().fetch_all_as(&pool).await?;
132    assert_eq!(data, users);
133    //println!("{:?}", users);
134
135    let u: Option<User> = UserQuery {
136        user_id: 1,
137        user_name: "admin",
138    }
139    .adapter_render()
140    .fetch_optional_as(&mut *tx)
141    .await?;
142    assert_eq!(data.first(), u.as_ref());
143    let u: User = UserQuery {
144        user_id: 1,
145        user_name: "admin",
146    }
147    .adapter_render()
148    .fetch_one_as(&mut *tx)
149    .await?;
150    assert_eq!(data.first(), Some(&u));
151
152    // stream
153    let mut query = user_query.adapter_render();
154    {
155        let stream = query.fetch(&mut *tx);
156        pin_mut!(stream);
157        while let Some(row) = stream.try_next().await? {
158            assert_eq!(2, row.columns().len());
159        }
160    }
161
162    tx.rollback().await?;
163
164    Ok(())
165}

Auto Trait Implementations§

§

impl<'q, DB, T> Freeze for DBAdapterManager<'q, DB, T>
where T: Freeze,

§

impl<'q, DB, T> RefUnwindSafe for DBAdapterManager<'q, DB, T>
where T: RefUnwindSafe, DB: RefUnwindSafe,

§

impl<'q, DB, T> UnsafeUnpin for DBAdapterManager<'q, DB, T>
where T: UnsafeUnpin,

§

impl<'q, DB, T> UnwindSafe for DBAdapterManager<'q, DB, T>
where T: UnwindSafe, DB: RefUnwindSafe,

Blanket Implementations§

Source §

impl<T> Any for T
where T: 'static + ?Sized,

Source §

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

Source §

impl<T> Borrow<T> for T
where T: ?Sized,

Source §

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

Source §

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source §

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

Source §

impl<T> From<T> for T

Source §

fn from(t: T) -> T

Returns the argument unchanged.

Source §

impl<T> Instrument for T

Source §

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

Source §

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

Source §

impl<T, U> Into for T
where U: From<T>,

Source §

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source §

impl<T> IntoEither for T

Source §

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

Source §

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

Source §

impl<T> Same for T

Source §

type Output = T

Should always be Self

Source §

impl<T, U> TryFrom for T
where U: Into<T>,

Source §

type Error = Infallible

The type returned in the event of a conversion error.

Source §

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

Source §

impl<T, U> TryInto for T
where U: TryFrom<T>,

Source §

type Error = >::Error

The type returned in the event of a conversion error.

Source §

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

Source §

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source §

fn vzip(self) -> V

Source §

impl<T> WithSubscriber for T

Source §

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

Source §

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more

Struct DBAdapterManager Copy item path

§Generic Parameters

Implementations§

impl<'q, DB, T> DBAdapterManager<'q, DB, T>where DB: Database, T: SqlTemplate<'q, DB>,

pub fn new(template: T) -> Self

§Arguments

pub fn sql(&self) -> &String

impl<'q, 'c, 'e, DB, T> DBAdapterManager<'q, DB, T>where DB: Database + Sync, T: SqlTemplate<'q, DB> + Send + 'q, i64: Encode<'q, DB> + Type<DB>, DB::Arguments<'q>: 'q, 'q: 'e, 'c: 'e,

pub fn set_persistent(self, persistent: bool) -> Self

pub fn count<Adapter>( &'q mut self, db_adapter: Adapter, ) -> BoxFuture<'e, Result<i64, Error>>where Adapter: BackendDB<'c, DB> + 'c, (i64,): for<'r> FromRow<'r, DB::Row>,

§Arguments

pub async fn count_page<Adapter>( &'q mut self, page_size: i64, db_adapter: Adapter, ) -> Result<PageInfo, Error>where Adapter: BackendDB<'c, DB> + 'c, (i64,): for<'r> FromRow<'r, DB::Row>,

§Arguments

pub fn set_page(self, page_size: i64, page_no: i64) -> Self

pub async fn execute<Adapter>( &'q mut self, db_adapter: Adapter, ) -> Result<DB::QueryResult, Error>where Adapter: BackendDB<'c, DB> + 'c,

pub fn execute_many<Adapter>( &'q mut self, db_adapter: Adapter, ) -> impl Stream<Item = Result<DB::QueryResult, Error>>where Adapter: BackendDB<'c, DB> + 'c,

pub fn fetch<Adapter>( &'q mut self, db_adapter: Adapter, ) -> impl Stream<Item = Result<DB::Row, Error>>where Adapter: BackendDB<'c, DB> + 'c,

pub fn fetch_many<Adapter>( &'q mut self, db_adapter: Adapter, ) -> BoxStream<'e, Result<Either<DB::QueryResult, DB::Row>, Error>>where Adapter: BackendDB<'c, DB> + 'c,

pub async fn fetch_all<Adapter>( &'q mut self, db_adapter: Adapter, ) -> Result<Vec<DB::Row>, Error>where Adapter: BackendDB<'c, DB> + 'c,

§Note: beware result set size.

pub async fn fetch_one<Adapter>( &'q mut self, db_adapter: Adapter, ) -> Result<DB::Row, Error>where Adapter: BackendDB<'c, DB> + 'c,

§Note: for best performance, ensure the query returns at most one row.

pub async fn fetch_optional<Adapter>( &'q mut self, db_adapter: Adapter, ) -> Result<Option<DB::Row>, Error>where Adapter: BackendDB<'c, DB> + 'c,

§Note: for best performance, ensure the query returns at most one row.

pub async fn fetch_as<Adapter, O>( &'q mut self, db_adapter: Adapter, ) -> impl Stream<Item = Result<O, Error>>where Adapter: BackendDB<'c, DB> + 'c, O: Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'e,

pub fn fetch_many_as<Adapter, O>( &'q mut self, db_adapter: Adapter, ) -> BoxStream<'e, Result<Either<DB::QueryResult, O>, Error>>where Adapter: BackendDB<'c, DB> + 'c, O: Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'e,

pub async fn fetch_all_as<Adapter, O>( &'q mut self, db_adapter: Adapter, ) -> Result<Vec<O>, Error>where Adapter: BackendDB<'c, DB> + 'c, O: Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'e,

§Note: beware result set size.

pub async fn fetch_one_as<Adapter, O>( &'q mut self, db_adapter: Adapter, ) -> Result<O, Error>where Adapter: BackendDB<'c, DB> + 'c, O: Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'e,

§Note: for best performance, ensure the query returns at most one row.

pub async fn fetch_optional_as<Adapter, O>( &'q mut self, db_adapter: Adapter, ) -> Result<Option<O>, Error>where Adapter: BackendDB<'c, DB> + 'c, O: Send + Unpin + for<'r> FromRow<'r, DB::Row>,

§Note: for best performance, ensure the query returns at most one row.

Auto Trait Implementations§

impl<'q, DB, T> Freeze for DBAdapterManager<'q, DB, T>where T: Freeze,

impl<'q, DB, T> RefUnwindSafe for DBAdapterManager<'q, DB, T>where T: RefUnwindSafe, DB: RefUnwindSafe,

impl<'q, DB, T> Send for DBAdapterManager<'q, DB, T>where T: Send, DB: Sync,

impl<'q, DB, T> Sync for DBAdapterManager<'q, DB, T>where T: Sync, DB: Sync,

impl<'q, DB, T> Unpin for DBAdapterManager<'q, DB, T>where T: Unpin,

impl<'q, DB, T> UnsafeUnpin for DBAdapterManager<'q, DB, T>where T: UnsafeUnpin,

impl<'q, DB, T> UnwindSafe for DBAdapterManager<'q, DB, T>where T: UnwindSafe, DB: RefUnwindSafe,

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for T

fn from(t: T) -> T

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>where F: FnOnce(&Self) -> bool,

impl<T> Same for T

type Output = T

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

impl<V, T> VZip<V> for Twhere V: MultiLane<T>,

fn vzip(self) -> V

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where S: Into<Dispatch>,

fn with_current_subscriber(self) -> WithDispatch<Self>

Struct DBAdapterManager

impl<'q, DB, T> DBAdapterManager<'q, DB, T>
where DB: Database, T: SqlTemplate<'q, DB>,

impl<'q, 'c, 'e, DB, T> DBAdapterManager<'q, DB, T>
where DB: Database + Sync, T: SqlTemplate<'q, DB> + Send + 'q, i64: Encode<'q, DB> + Type<DB>, DB::Arguments<'q>: 'q, 'q: 'e, 'c: 'e,

pub fn count<Adapter>( &'q mut self, db_adapter: Adapter, ) -> BoxFuture<'e, Result<i64, Error>>
where Adapter: BackendDB<'c, DB> + 'c, (i64,): for<'r> FromRow<'r, DB::Row>,

pub async fn count_page<Adapter>( &'q mut self, page_size: i64, db_adapter: Adapter, ) -> Result<PageInfo, Error>
where Adapter: BackendDB<'c, DB> + 'c, (i64,): for<'r> FromRow<'r, DB::Row>,

pub async fn execute<Adapter>( &'q mut self, db_adapter: Adapter, ) -> Result<DB::QueryResult, Error>
where Adapter: BackendDB<'c, DB> + 'c,

pub fn execute_many<Adapter>( &'q mut self, db_adapter: Adapter, ) -> impl Stream<Item = Result<DB::QueryResult, Error>>
where Adapter: BackendDB<'c, DB> + 'c,

pub fn fetch<Adapter>( &'q mut self, db_adapter: Adapter, ) -> impl Stream<Item = Result<DB::Row, Error>>
where Adapter: BackendDB<'c, DB> + 'c,

pub fn fetch_many<Adapter>( &'q mut self, db_adapter: Adapter, ) -> BoxStream<'e, Result<Either<DB::QueryResult, DB::Row>, Error>>
where Adapter: BackendDB<'c, DB> + 'c,

pub async fn fetch_all<Adapter>( &'q mut self, db_adapter: Adapter, ) -> Result<Vec<DB::Row>, Error>
where Adapter: BackendDB<'c, DB> + 'c,

pub async fn fetch_one<Adapter>( &'q mut self, db_adapter: Adapter, ) -> Result<DB::Row, Error>
where Adapter: BackendDB<'c, DB> + 'c,

pub async fn fetch_optional<Adapter>( &'q mut self, db_adapter: Adapter, ) -> Result<Option<DB::Row>, Error>
where Adapter: BackendDB<'c, DB> + 'c,

pub async fn fetch_as<Adapter, O>( &'q mut self, db_adapter: Adapter, ) -> impl Stream<Item = Result<O, Error>>
where Adapter: BackendDB<'c, DB> + 'c, O: Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'e,

pub fn fetch_many_as<Adapter, O>( &'q mut self, db_adapter: Adapter, ) -> BoxStream<'e, Result<Either<DB::QueryResult, O>, Error>>
where Adapter: BackendDB<'c, DB> + 'c, O: Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'e,

pub async fn fetch_all_as<Adapter, O>( &'q mut self, db_adapter: Adapter, ) -> Result<Vec<O>, Error>
where Adapter: BackendDB<'c, DB> + 'c, O: Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'e,

pub async fn fetch_one_as<Adapter, O>( &'q mut self, db_adapter: Adapter, ) -> Result<O, Error>
where Adapter: BackendDB<'c, DB> + 'c, O: Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'e,

pub async fn fetch_optional_as<Adapter, O>( &'q mut self, db_adapter: Adapter, ) -> Result<Option<O>, Error>
where Adapter: BackendDB<'c, DB> + 'c, O: Send + Unpin + for<'r> FromRow<'r, DB::Row>,

impl<'q, DB, T> Freeze for DBAdapterManager<'q, DB, T>
where T: Freeze,

impl<'q, DB, T> RefUnwindSafe for DBAdapterManager<'q, DB, T>
where T: RefUnwindSafe, DB: RefUnwindSafe,

impl<'q, DB, T> Send for DBAdapterManager<'q, DB, T>
where T: Send, DB: Sync,

impl<'q, DB, T> Sync for DBAdapterManager<'q, DB, T>
where T: Sync, DB: Sync,

impl<'q, DB, T> Unpin for DBAdapterManager<'q, DB, T>
where T: Unpin,

impl<'q, DB, T> UnsafeUnpin for DBAdapterManager<'q, DB, T>
where T: UnsafeUnpin,

impl<'q, DB, T> UnwindSafe for DBAdapterManager<'q, DB, T>
where T: UnwindSafe, DB: RefUnwindSafe,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,