Skip to content

Commit ac92f84

Browse files
chandr-andrchandr-andr
committed
Rewrite all exceptions to more readable ones
Signed-off-by: chandr-andr (Kiselev Aleksandr) <chandr@chandr.net>
1 parent e746291 commit ac92f84

File tree

7 files changed

+260
-126
lines changed

7 files changed

+260
-126
lines changed

‎src/driver/connection.rs‎

Lines changed: 83 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -54,14 +54,26 @@ impl Connection {
5454
let result = if prepared {
5555
db_client
5656
.query(
57-
&db_client.prepare_cached(&querystring).await?,
57+
&db_client
58+
.prepare_cached(&querystring)
59+
.await
60+
.map_err(|err| {
61+
RustPSQLDriverError::ConnectionExecuteError(format!(
62+
"Cannot prepare statement, error - {err}"
63+
))
64+
})?,
5865
&params
5966
.iter()
6067
.map(|param| param as &QueryParameter)
6168
.collect::<Vec<&QueryParameter>>()
6269
.into_boxed_slice(),
6370
)
64-
.await?
71+
.await
72+
.map_err(|err| {
73+
RustPSQLDriverError::ConnectionExecuteError(format!(
74+
"Cannot execute statement, error - {err}"
75+
))
76+
})?
6577
} else {
6678
db_client
6779
.query(
@@ -72,7 +84,12 @@ impl Connection {
7284
.collect::<Vec<&QueryParameter>>()
7385
.into_boxed_slice(),
7486
)
75-
.await?
87+
.await
88+
.map_err(|err| {
89+
RustPSQLDriverError::ConnectionExecuteError(format!(
90+
"Cannot execute statement, error - {err}"
91+
))
92+
})?
7693
};
7794

7895
Ok(PSQLDriverPyQueryResult::new(result))
@@ -104,15 +121,15 @@ impl Connection {
104121
let prepared = prepared.unwrap_or(true);
105122

106123
db_client.batch_execute("BEGIN;").await.map_err(|err| {
107-
RustPSQLDriverError::DataBaseTransactionError(format!(
124+
RustPSQLDriverError::TransactionBeginError(format!(
108125
"Cannot start transaction to run execute_many: {err}"
109126
))
110127
})?;
111128
for param in params {
112129
let querystring_result = if prepared {
113130
let prepared_stmt = &db_client.prepare_cached(&querystring).await;
114131
if let Err(error) = prepared_stmt {
115-
return Err(RustPSQLDriverError::DataBaseTransactionError(format!(
132+
return Err(RustPSQLDriverError::TransactionExecuteError(format!(
116133
"Cannot prepare statement in execute_many, operation rolled back {error}",
117134
)));
118135
}
@@ -141,7 +158,7 @@ impl Connection {
141158

142159
if let Err(error) = querystring_result {
143160
db_client.batch_execute("ROLLBACK;").await?;
144-
return Err(RustPSQLDriverError::DataBaseTransactionError(format!(
161+
return Err(RustPSQLDriverError::TransactionExecuteError(format!(
145162
"Error occured in `execute_many` statement, transaction is rolled back: {error}"
146163
)));
147164
}
@@ -177,14 +194,26 @@ impl Connection {
177194
let result = if prepared {
178195
db_client
179196
.query(
180-
&db_client.prepare_cached(&querystring).await?,
197+
&db_client
198+
.prepare_cached(&querystring)
199+
.await
200+
.map_err(|err| {
201+
RustPSQLDriverError::ConnectionExecuteError(format!(
202+
"Cannot prepare statement, error - {err}"
203+
))
204+
})?,
181205
&params
182206
.iter()
183207
.map(|param| param as &QueryParameter)
184208
.collect::<Vec<&QueryParameter>>()
185209
.into_boxed_slice(),
186210
)
187-
.await?
211+
.await
212+
.map_err(|err| {
213+
RustPSQLDriverError::ConnectionExecuteError(format!(
214+
"Cannot execute statement, error - {err}"
215+
))
216+
})?
188217
} else {
189218
db_client
190219
.query(
@@ -195,7 +224,12 @@ impl Connection {
195224
.collect::<Vec<&QueryParameter>>()
196225
.into_boxed_slice(),
197226
)
198-
.await?
227+
.await
228+
.map_err(|err| {
229+
RustPSQLDriverError::ConnectionExecuteError(format!(
230+
"Cannot execute statement, error - {err}"
231+
))
232+
})?
199233
};
200234

201235
Ok(PSQLDriverPyQueryResult::new(result))
@@ -232,14 +266,26 @@ impl Connection {
232266
let result = if prepared {
233267
db_client
234268
.query_one(
235-
&db_client.prepare_cached(&querystring).await?,
269+
&db_client
270+
.prepare_cached(&querystring)
271+
.await
272+
.map_err(|err| {
273+
RustPSQLDriverError::ConnectionExecuteError(format!(
274+
"Cannot prepare statement, error - {err}"
275+
))
276+
})?,
236277
&params
237278
.iter()
238279
.map(|param| param as &QueryParameter)
239280
.collect::<Vec<&QueryParameter>>()
240281
.into_boxed_slice(),
241282
)
242-
.await?
283+
.await
284+
.map_err(|err| {
285+
RustPSQLDriverError::ConnectionExecuteError(format!(
286+
"Cannot execute statement, error - {err}"
287+
))
288+
})?
243289
} else {
244290
db_client
245291
.query_one(
@@ -250,7 +296,12 @@ impl Connection {
250296
.collect::<Vec<&QueryParameter>>()
251297
.into_boxed_slice(),
252298
)
253-
.await?
299+
.await
300+
.map_err(|err| {
301+
RustPSQLDriverError::ConnectionExecuteError(format!(
302+
"Cannot execute statement, error - {err}"
303+
))
304+
})?
254305
};
255306

256307
Ok(PSQLDriverSinglePyQueryResult::new(result))
@@ -284,14 +335,26 @@ impl Connection {
284335
let result = if prepared {
285336
db_client
286337
.query_one(
287-
&db_client.prepare_cached(&querystring).await?,
338+
&db_client
339+
.prepare_cached(&querystring)
340+
.await
341+
.map_err(|err| {
342+
RustPSQLDriverError::ConnectionExecuteError(format!(
343+
"Cannot prepare statement, error - {err}"
344+
))
345+
})?,
288346
&params
289347
.iter()
290348
.map(|param| param as &QueryParameter)
291349
.collect::<Vec<&QueryParameter>>()
292350
.into_boxed_slice(),
293351
)
294-
.await?
352+
.await
353+
.map_err(|err| {
354+
RustPSQLDriverError::ConnectionExecuteError(format!(
355+
"Cannot execute statement, error - {err}"
356+
))
357+
})?
295358
} else {
296359
db_client
297360
.query_one(
@@ -302,7 +365,12 @@ impl Connection {
302365
.collect::<Vec<&QueryParameter>>()
303366
.into_boxed_slice(),
304367
)
305-
.await?
368+
.await
369+
.map_err(|err| {
370+
RustPSQLDriverError::ConnectionExecuteError(format!(
371+
"Cannot execute statement, error - {err}"
372+
))
373+
})?
306374
};
307375

308376
Python::with_gil(|gil| match result.columns().first() {

‎src/driver/connection_pool.rs‎

Lines changed: 58 additions & 50 deletions
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@ use crate::runtime::tokio_runtime;
22
use deadpool_postgres::{Manager, ManagerConfig, Object, Pool, RecyclingMethod};
33
use pyo3::{pyclass, pyfunction, pymethods, PyAny};
44
use std::vec;
5-
use tokio_postgres::{NoTls, Row};
5+
use tokio_postgres::NoTls;
66

77
use crate::{
88
exceptions::rust_errors::{RustPSQLDriverError, RustPSQLDriverPyResult},
@@ -51,7 +51,7 @@ pub fn connect(
5151
) -> RustPSQLDriverPyResult<ConnectionPool> {
5252
if let Some(max_db_pool_size) = max_db_pool_size {
5353
if max_db_pool_size < 2 {
54-
return Err(RustPSQLDriverError::DataBasePoolConfigurationError(
54+
return Err(RustPSQLDriverError::ConnectionPoolConfigurationError(
5555
"Maximum database pool size must be more than 1".into(),
5656
));
5757
}
@@ -195,35 +195,39 @@ impl ConnectionPool {
195195
let result = if prepared {
196196
tokio_runtime()
197197
.spawn(async move {
198-
Ok::<Vec<Row>, RustPSQLDriverError>(
199-
db_pool_manager
200-
.query(
201-
&db_pool_manager.prepare_cached(&querystring).await?,
202-
&params
203-
.iter()
204-
.map(|param| param as &QueryParameter)
205-
.collect::<Vec<&QueryParameter>>()
206-
.into_boxed_slice(),
207-
)
208-
.await?,
209-
)
198+
db_pool_manager
199+
.query(
200+
&db_pool_manager.prepare_cached(&querystring).await?,
201+
&params
202+
.iter()
203+
.map(|param| param as &QueryParameter)
204+
.collect::<Vec<&QueryParameter>>(),
205+
)
206+
.await
207+
.map_err(|err| {
208+
RustPSQLDriverError::ConnectionExecuteError(format!(
209+
"Cannot execute statement from ConnectionPool, error - {err}"
210+
))
211+
})
210212
})
211213
.await??
212214
} else {
213215
tokio_runtime()
214216
.spawn(async move {
215-
Ok::<Vec<Row>, RustPSQLDriverError>(
216-
db_pool_manager
217-
.query(
218-
&querystring,
219-
&params
220-
.iter()
221-
.map(|param| param as &QueryParameter)
222-
.collect::<Vec<&QueryParameter>>()
223-
.into_boxed_slice(),
224-
)
225-
.await?,
226-
)
217+
db_pool_manager
218+
.query(
219+
&querystring,
220+
&params
221+
.iter()
222+
.map(|param| param as &QueryParameter)
223+
.collect::<Vec<&QueryParameter>>(),
224+
)
225+
.await
226+
.map_err(|err| {
227+
RustPSQLDriverError::ConnectionExecuteError(format!(
228+
"Cannot execute statement from ConnectionPool, error - {err}"
229+
))
230+
})
227231
})
228232
.await??
229233
};
@@ -259,35 +263,39 @@ impl ConnectionPool {
259263
let result = if prepared {
260264
tokio_runtime()
261265
.spawn(async move {
262-
Ok::<Vec<Row>, RustPSQLDriverError>(
263-
db_pool_manager
264-
.query(
265-
&db_pool_manager.prepare_cached(&querystring).await?,
266-
&params
267-
.iter()
268-
.map(|param| param as &QueryParameter)
269-
.collect::<Vec<&QueryParameter>>()
270-
.into_boxed_slice(),
271-
)
272-
.await?,
273-
)
266+
db_pool_manager
267+
.query(
268+
&db_pool_manager.prepare_cached(&querystring).await?,
269+
&params
270+
.iter()
271+
.map(|param| param as &QueryParameter)
272+
.collect::<Vec<&QueryParameter>>(),
273+
)
274+
.await
275+
.map_err(|err| {
276+
RustPSQLDriverError::ConnectionExecuteError(format!(
277+
"Cannot execute statement from ConnectionPool, error - {err}"
278+
))
279+
})
274280
})
275281
.await??
276282
} else {
277283
tokio_runtime()
278284
.spawn(async move {
279-
Ok::<Vec<Row>, RustPSQLDriverError>(
280-
db_pool_manager
281-
.query(
282-
&querystring,
283-
&params
284-
.iter()
285-
.map(|param| param as &QueryParameter)
286-
.collect::<Vec<&QueryParameter>>()
287-
.into_boxed_slice(),
288-
)
289-
.await?,
290-
)
285+
db_pool_manager
286+
.query(
287+
&querystring,
288+
&params
289+
.iter()
290+
.map(|param| param as &QueryParameter)
291+
.collect::<Vec<&QueryParameter>>(),
292+
)
293+
.await
294+
.map_err(|err| {
295+
RustPSQLDriverError::ConnectionExecuteError(format!(
296+
"Cannot execute statement from ConnectionPool, error - {err}"
297+
))
298+
})
291299
})
292300
.await??
293301
};

0 commit comments

Comments
 (0)