Skip to content

Commit 88d9f8f

Browse files
joeydewaaljoeydewaal
committed
Update Sqlite driver
1 parent d836f65 commit 88d9f8f

File tree

13 files changed

+71
-65
lines changed

13 files changed

+71
-65
lines changed

‎sqlx-sqlite/src/any.rs

Lines changed: 6 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,7 @@ use sqlx_core::any::{
1212
Any, AnyArguments, AnyColumn, AnyConnectOptions, AnyConnectionBackend, AnyQueryResult, AnyRow,
1313
AnyStatement, AnyTypeInfo, AnyTypeInfoKind, AnyValueKind,
1414
};
15+
use sqlx_core::sql_str::SqlStr;
1516

1617
use crate::type_info::DataType;
1718
use sqlx_core::connection::{ConnectOptions, Connection};
@@ -84,7 +85,7 @@ impl AnyConnectionBackend for SqliteConnection {
8485

8586
fn fetch_many<'q>(
8687
&'q mut self,
87-
query: &'q str,
88+
query: SqlStr,
8889
persistent: bool,
8990
arguments: Option<AnyArguments<'q>>,
9091
) -> BoxStream<'q, sqlx_core::Result<Either<AnyQueryResult, AnyRow>>> {
@@ -107,7 +108,7 @@ impl AnyConnectionBackend for SqliteConnection {
107108

108109
fn fetch_optional<'q>(
109110
&'q mut self,
110-
query: &'q str,
111+
query: SqlStr,
111112
persistent: bool,
112113
arguments: Option<AnyArguments<'q>>,
113114
) -> BoxFuture<'q, sqlx_core::Result<Option<AnyRow>>> {
@@ -132,16 +133,16 @@ impl AnyConnectionBackend for SqliteConnection {
132133

133134
fn prepare_with<'c, 'q: 'c>(
134135
&'c mut self,
135-
sql: &'q str,
136+
sql: SqlStr,
136137
_parameters: &[AnyTypeInfo],
137138
) -> BoxFuture<'c, sqlx_core::Result<AnyStatement>> {
138139
Box::pin(async move {
139-
let statement = Executor::prepare_with(self, sql, &[]).await?;
140+
let statement = Executor::prepare_with(self, sql.clone(), &[]).await?;
140141
AnyStatement::try_from_statement(sql, &statement, statement.column_names.clone())
141142
})
142143
}
143144

144-
fn describe<'q>(&'q mut self, sql: &'q str) -> BoxFuture<'q, sqlx_core::Result<Describe<Any>>> {
145+
fn describe<'q>(&'q mut self, sql: SqlStr) -> BoxFuture<'q, sqlx_core::Result<Describe<Any>>> {
145146
Box::pin(async move { Executor::describe(self, sql).await?.try_into_any() })
146147
}
147148
}

‎sqlx-sqlite/src/connection/describe.rs

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -5,14 +5,18 @@ use crate::error::Error;
55
use crate::statement::VirtualStatement;
66
use crate::type_info::DataType;
77
use crate::{Sqlite, SqliteColumn};
8+
use sqlx_core::sql_str::SqlStr;
89
use sqlx_core::Either;
910
use std::convert::identity;
1011

11-
pub(crate) fn describe(conn: &mut ConnectionState, query: &str) -> Result<Describe<Sqlite>, Error> {
12+
pub(crate) fn describe(
13+
conn: &mut ConnectionState,
14+
query: SqlStr,
15+
) -> Result<Describe<Sqlite>, Error> {
1216
// describing a statement from SQLite can be involved
1317
// each SQLx statement is comprised of multiple SQL statements
1418

15-
let mut statement = VirtualStatement::new(query, false)?;
19+
let mut statement = VirtualStatement::new(query.as_str(), false)?;
1620

1721
let mut columns = Vec::new();
1822
let mut nullable = Vec::new();

‎sqlx-sqlite/src/connection/execute.rs

Lines changed: 5 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -3,12 +3,13 @@ use crate::error::Error;
33
use crate::logger::QueryLogger;
44
use crate::statement::{StatementHandle, VirtualStatement};
55
use crate::{SqliteArguments, SqliteQueryResult, SqliteRow};
6+
use sqlx_core::sql_str::SqlSafeStr;
67
use sqlx_core::Either;
78

89
pub struct ExecuteIter<'a> {
910
handle: &'a mut ConnectionHandle,
1011
statement: &'a mut VirtualStatement,
11-
logger: QueryLogger<'a>,
12+
logger: QueryLogger,
1213
args: Option<SqliteArguments<'a>>,
1314

1415
/// since a `VirtualStatement` can encompass multiple actual statements,
@@ -20,12 +21,13 @@ pub struct ExecuteIter<'a> {
2021

2122
pub(crate) fn iter<'a>(
2223
conn: &'a mut ConnectionState,
23-
query: &'a str,
24+
query: impl SqlSafeStr,
2425
args: Option<SqliteArguments<'a>>,
2526
persistent: bool,
2627
) -> Result<ExecuteIter<'a>, Error> {
28+
let query = query.into_sql_str();
2729
// fetch the cached statement or allocate a new one
28-
let statement = conn.statements.get(query, persistent)?;
30+
let statement = conn.statements.get(query.as_str(), persistent)?;
2931

3032
let logger = QueryLogger::new(query, conn.log_settings.clone());
3133

‎sqlx-sqlite/src/connection/executor.rs

Lines changed: 10 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@ use futures_util::{stream, FutureExt, StreamExt, TryFutureExt, TryStreamExt};
77
use sqlx_core::describe::Describe;
88
use sqlx_core::error::Error;
99
use sqlx_core::executor::{Execute, Executor};
10-
use sqlx_core::sql_str::{AssertSqlSafe, SqlSafeStr};
10+
use sqlx_core::sql_str::SqlSafeStr;
1111
use sqlx_core::Either;
1212
use std::{future, pin::pin};
1313

@@ -24,12 +24,12 @@ impl<'c> Executor<'c> for &'c mut SqliteConnection {
2424
'q: 'e,
2525
E: 'q,
2626
{
27-
let sql = query.sql();
2827
let arguments = match query.take_arguments().map_err(Error::Encode) {
2928
Ok(arguments) => arguments,
3029
Err(error) => return stream::once(future::ready(Err(error))).boxed(),
3130
};
3231
let persistent = query.persistent() && arguments.is_some();
32+
let sql = query.sql();
3333

3434
Box::pin(
3535
self.worker
@@ -49,14 +49,14 @@ impl<'c> Executor<'c> for &'c mut SqliteConnection {
4949
'q: 'e,
5050
E: 'q,
5151
{
52-
let sql = query.sql();
5352
let arguments = match query.take_arguments().map_err(Error::Encode) {
5453
Ok(arguments) => arguments,
5554
Err(error) => return future::ready(Err(error)).boxed(),
5655
};
5756
let persistent = query.persistent() && arguments.is_some();
5857

5958
Box::pin(async move {
59+
let sql = query.sql();
6060
let mut stream = pin!(self
6161
.worker
6262
.execute(sql, arguments, self.row_channel_size, persistent, Some(1))
@@ -73,29 +73,28 @@ impl<'c> Executor<'c> for &'c mut SqliteConnection {
7373
})
7474
}
7575

76-
fn prepare_with<'e, 'q: 'e>(
76+
fn prepare_with<'e>(
7777
self,
78-
sql: &'q str,
78+
sql: impl SqlSafeStr,
7979
_parameters: &[SqliteTypeInfo],
8080
) -> BoxFuture<'e, Result<SqliteStatement, Error>>
8181
where
8282
'c: 'e,
8383
{
84+
let sql = sql.into_sql_str();
8485
Box::pin(async move {
8586
let statement = self.worker.prepare(sql).await?;
8687

87-
Ok(SqliteStatement {
88-
sql: AssertSqlSafe(sql).into_sql_str(),
89-
..statement
90-
})
88+
Ok(statement)
9189
})
9290
}
9391

9492
#[doc(hidden)]
95-
fn describe<'e, 'q: 'e>(self, sql: &'q str) -> BoxFuture<'e, Result<Describe<Sqlite>, Error>>
93+
fn describe<'e>(self, sql: impl SqlSafeStr) -> BoxFuture<'e, Result<Describe<Sqlite>, Error>>
9694
where
9795
'c: 'e,
9896
{
99-
Box::pin(self.worker.describe(sql))
97+
let sql = sql.into_sql_str();
98+
Box::pin(async move { self.worker.describe(sql).await })
10099
}
101100
}

‎sqlx-sqlite/src/connection/explain.rs

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,7 @@ use crate::from_row::FromRow;
1212
use crate::logger::{BranchParent, BranchResult, DebugDiff};
1313
use crate::type_info::DataType;
1414
use crate::SqliteTypeInfo;
15+
use sqlx_core::sql_str::AssertSqlSafe;
1516
use sqlx_core::{hash_map, HashMap};
1617
use std::fmt::Debug;
1718
use std::str::from_utf8;
@@ -567,7 +568,7 @@ pub(super) fn explain(
567568
) -> Result<(Vec<SqliteTypeInfo>, Vec<Option<bool>>), Error> {
568569
let root_block_cols = root_block_columns(conn)?;
569570
let program: Vec<(i64, String, i64, i64, i64, Vec<u8>)> =
570-
execute::iter(conn, &format!("EXPLAIN {query}"), None, false)?
571+
execute::iter(conn, AssertSqlSafe(format!("EXPLAIN {query}")), None, false)?
571572
.filter_map(|res| res.map(|either| either.right()).transpose())
572573
.map(|row| FromRow::from_row(&row?))
573574
.collect::<Result<Vec<_>, Error>>()?;

‎sqlx-sqlite/src/connection/mod.rs

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -23,6 +23,7 @@ use sqlx_core::common::StatementCache;
2323
pub(crate) use sqlx_core::connection::*;
2424
use sqlx_core::error::Error;
2525
use sqlx_core::executor::Executor;
26+
use sqlx_core::sql_str::AssertSqlSafe;
2627
use sqlx_core::transaction::Transaction;
2728

2829
use crate::connection::establish::EstablishParams;
@@ -224,7 +225,7 @@ impl Connection for SqliteConnection {
224225
write!(pragma_string, "PRAGMA analysis_limit = {limit}; ").ok();
225226
}
226227
pragma_string.push_str("PRAGMA optimize;");
227-
self.execute(&*pragma_string).await?;
228+
self.execute(AssertSqlSafe(pragma_string)).await?;
228229
}
229230
let shutdown = self.worker.shutdown();
230231
// Drop the statement worker, which should

‎sqlx-sqlite/src/connection/worker.rs

Lines changed: 22 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@ use std::thread;
55

66
use futures_channel::oneshot;
77
use futures_intrusive::sync::{Mutex, MutexGuard};
8-
use sqlx_core::sql_str::{AssertSqlSafe, SqlSafeStr};
8+
use sqlx_core::sql_str::SqlStr;
99
use tracing::span::Span;
1010

1111
use sqlx_core::describe::Describe;
@@ -53,15 +53,15 @@ impl WorkerSharedState {
5353

5454
enum Command {
5555
Prepare {
56-
query: Box<str>,
56+
query: SqlStr,
5757
tx: oneshot::Sender<Result<SqliteStatement, Error>>,
5858
},
5959
Describe {
60-
query: Box<str>,
60+
query: SqlStr,
6161
tx: oneshot::Sender<Result<Describe<Sqlite>, Error>>,
6262
},
6363
Execute {
64-
query: Box<str>,
64+
query: SqlStr,
6565
arguments: Option<SqliteArguments<'static>>,
6666
persistent: bool,
6767
tx: flume::Sender<Result<Either<SqliteQueryResult, SqliteRow>, Error>>,
@@ -145,7 +145,7 @@ impl ConnectionWorker {
145145
let _guard = span.enter();
146146
match cmd {
147147
Command::Prepare { query, tx } => {
148-
tx.send(prepare(&mut conn, &query).map(|prepared| {
148+
tx.send(prepare(&mut conn, query).map(|prepared| {
149149
update_cached_statements_size(
150150
&conn,
151151
&shared.cached_statements_size,
@@ -155,7 +155,7 @@ impl ConnectionWorker {
155155
.ok();
156156
}
157157
Command::Describe { query, tx } => {
158-
tx.send(describe(&mut conn, &query)).ok();
158+
tx.send(describe(&mut conn, query)).ok();
159159
}
160160
Command::Execute {
161161
query,
@@ -164,7 +164,7 @@ impl ConnectionWorker {
164164
tx,
165165
limit
166166
} => {
167-
let iter = match execute::iter(&mut conn, &query, arguments, persistent)
167+
let iter = match execute::iter(&mut conn, query, arguments, persistent)
168168
{
169169
Ok(iter) => iter,
170170
Err(e) => {
@@ -225,7 +225,7 @@ impl ConnectionWorker {
225225
};
226226
let res =
227227
conn.handle
228-
.exec(statement)
228+
.exec(begin_ansi_transaction_sql(depth).as_str())
229229
.map(|_| {
230230
shared.transaction_depth.fetch_add(1, Ordering::Release);
231231
});
@@ -238,7 +238,7 @@ impl ConnectionWorker {
238238
// immediately otherwise it would remain started forever.
239239
if let Err(error) = conn
240240
.handle
241-
.exec(rollback_ansi_transaction_sql(depth + 1))
241+
.exec(rollback_ansi_transaction_sql(depth + 1).as_str())
242242
.map(|_| {
243243
shared.transaction_depth.fetch_sub(1, Ordering::Release);
244244
})
@@ -256,7 +256,7 @@ impl ConnectionWorker {
256256

257257
let res = if depth > 0 {
258258
conn.handle
259-
.exec(commit_ansi_transaction_sql(depth))
259+
.exec(commit_ansi_transaction_sql(depth).as_str())
260260
.map(|_| {
261261
shared.transaction_depth.fetch_sub(1, Ordering::Release);
262262
})
@@ -282,7 +282,7 @@ impl ConnectionWorker {
282282

283283
let res = if depth > 0 {
284284
conn.handle
285-
.exec(rollback_ansi_transaction_sql(depth))
285+
.exec(rollback_ansi_transaction_sql(depth).as_str())
286286
.map(|_| {
287287
shared.transaction_depth.fetch_sub(1, Ordering::Release);
288288
})
@@ -335,25 +335,19 @@ impl ConnectionWorker {
335335
establish_rx.await.map_err(|_| Error::WorkerCrashed)?
336336
}
337337

338-
pub(crate) async fn prepare(&mut self, query: &str) -> Result<SqliteStatement, Error> {
339-
self.oneshot_cmd(|tx| Command::Prepare {
340-
query: query.into(),
341-
tx,
342-
})
343-
.await?
338+
pub(crate) async fn prepare(&mut self, query: SqlStr) -> Result<SqliteStatement, Error> {
339+
self.oneshot_cmd(|tx| Command::Prepare { query, tx })
340+
.await?
344341
}
345342

346-
pub(crate) async fn describe(&mut self, query: &str) -> Result<Describe<Sqlite>, Error> {
347-
self.oneshot_cmd(|tx| Command::Describe {
348-
query: query.into(),
349-
tx,
350-
})
351-
.await?
343+
pub(crate) async fn describe(&mut self, query: SqlStr) -> Result<Describe<Sqlite>, Error> {
344+
self.oneshot_cmd(|tx| Command::Describe { query, tx })
345+
.await?
352346
}
353347

354348
pub(crate) async fn execute(
355349
&mut self,
356-
query: &str,
350+
query: SqlStr,
357351
args: Option<SqliteArguments<'_>>,
358352
chan_size: usize,
359353
persistent: bool,
@@ -364,7 +358,7 @@ impl ConnectionWorker {
364358
self.command_tx
365359
.send_async((
366360
Command::Execute {
367-
query: query.into(),
361+
query,
368362
arguments: args.map(SqliteArguments::into_static),
369363
persistent,
370364
tx,
@@ -495,9 +489,9 @@ impl ConnectionWorker {
495489
}
496490
}
497491

498-
fn prepare(conn: &mut ConnectionState, query: &str) -> Result<SqliteStatement, Error> {
492+
fn prepare(conn: &mut ConnectionState, query: SqlStr) -> Result<SqliteStatement, Error> {
499493
// prepare statement object (or checkout from cache)
500-
let statement = conn.statements.get(query, true)?;
494+
let statement = conn.statements.get(query.as_str(), true)?;
501495

502496
let mut parameters = 0;
503497
let mut columns = None;
@@ -514,7 +508,7 @@ fn prepare(conn: &mut ConnectionState, query: &str) -> Result<SqliteStatement, E
514508
}
515509

516510
Ok(SqliteStatement {
517-
sql: AssertSqlSafe(query).into_sql_str(),
511+
sql: query,
518512
columns: columns.unwrap_or_default(),
519513
column_names: column_names.unwrap_or_default(),
520514
parameters,

‎sqlx-sqlite/src/lib.rs

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -57,6 +57,7 @@ pub use options::{
5757
};
5858
pub use query_result::SqliteQueryResult;
5959
pub use row::SqliteRow;
60+
use sqlx_core::sql_str::{AssertSqlSafe, SqlSafeStr};
6061
pub use statement::SqliteStatement;
6162
pub use transaction::SqliteTransactionManager;
6263
pub use type_info::SqliteTypeInfo;
@@ -132,9 +133,10 @@ pub fn describe_blocking(query: &str, database_url: &str) -> Result<Describe<Sql
132133
let mut conn = params.establish()?;
133134

134135
// Execute any ancillary `PRAGMA`s
135-
connection::execute::iter(&mut conn, &opts.pragma_string(), None, false)?.finish()?;
136+
connection::execute::iter(&mut conn, AssertSqlSafe(opts.pragma_string()), None, false)?
137+
.finish()?;
136138

137-
connection::describe::describe(&mut conn, query)
139+
connection::describe::describe(&mut conn, AssertSqlSafe(query.to_string()).into_sql_str())
138140

139141
// SQLite database is closed immediately when `conn` is dropped
140142
}

0 commit comments

Comments
 (0)