Merge branch 'launchbadge:main' into add-citext-support-postgres

Author: hgranthorner

Cargo.lock

@@ -23,7 +23,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.7.0-alpha.2"
+version = "0.7.0-alpha.3"
 license = "MIT OR Apache-2.0"
 edition = "2021"
 repository = "https://github.com/launchbadge/sqlx"
@@ -114,17 +114,17 @@ regexp = ["sqlx-sqlite?/regexp"]
 
 [workspace.dependencies]
 # Core Crates
-sqlx-core = { version = "=0.7.0-alpha.2", path = "sqlx-core" }
-sqlx-macros-core = { version = "=0.7.0-alpha.2", path = "sqlx-macros-core" }
-sqlx-macros = { version = "=0.7.0-alpha.2", path = "sqlx-macros" }
+sqlx-core = { version = "=0.7.0-alpha.3", path = "sqlx-core" }
+sqlx-macros-core = { version = "=0.7.0-alpha.3", path = "sqlx-macros-core" }
+sqlx-macros = { version = "=0.7.0-alpha.3", path = "sqlx-macros" }
 
 # Driver crates
-sqlx-mysql = { version = "=0.7.0-alpha.2", path = "sqlx-mysql" }
-sqlx-postgres = { version = "=0.7.0-alpha.2", path = "sqlx-postgres" }
-sqlx-sqlite = { version = "=0.7.0-alpha.2", path = "sqlx-sqlite" }
+sqlx-mysql = { version = "=0.7.0-alpha.3", path = "sqlx-mysql" }
+sqlx-postgres = { version = "=0.7.0-alpha.3", path = "sqlx-postgres" }
+sqlx-sqlite = { version = "=0.7.0-alpha.3", path = "sqlx-sqlite" }
 
 # Facade crate (for reference from sqlx-cli)
-sqlx = { version = "=0.7.0-alpha.2", path = "." }
+sqlx = { version = "=0.7.0-alpha.3", path = "." }
 
 # Common type integrations shared by multiple driver crates.
 # These are optional unless enabled in a workspace crate.
@@ -175,8 +175,10 @@ rand = "0.8.4"
 rand_xoshiro = "0.6.0"
 hex = "0.4.3"
 tempdir = "0.3.7"
+criterion = {version = "0.4", features = ["async_tokio"]}
+
 # Needed to test SQLCipher
-libsqlite3-sys = { version = "0.25.1", features = ["bundled-sqlcipher"] }
+libsqlite3-sys = { version = "0.26", features = ["bundled-sqlcipher"] }
 
 #
 # Any
@@ -250,6 +252,12 @@ name = "sqlite-migrate"
 path = "tests/sqlite/migrate.rs"
 required-features = ["sqlite", "macros", "migrate"]
 
+[[bench]]
+name = "sqlite-describe"
+path = "benches/sqlite/describe.rs"
+harness = false
+required-features = ["sqlite"]
+
 #
 # MySQL
 #
@@ -332,3 +340,4 @@ required-features = ["postgres", "macros", "migrate"]
 name = "postgres-migrate"
 path = "tests/postgres/migrate.rs"
 required-features = ["postgres", "macros", "migrate"]
+

Cargo.toml

@@ -97,13 +97,13 @@ with C, those interactions are `unsafe`.
 
 -   Built-in connection pooling with `sqlx::Pool`.
 
--   Row streaming. Data is read asynchronously from the database and decoded on-demand.
+-   Row streaming. Data is read asynchronously from the database and decoded on demand.
 
 -   Automatic statement preparation and caching. When using the high-level query API (`sqlx::query`), statements are
-    prepared and cached per-connection.
+    prepared and cached per connection.
 
 -   Simple (unprepared) query execution including fetching results into the same `Row` types used by
-    the high-level API. Supports batch execution and returning results from all statements.
+    the high-level API. Supports batch execution and returns results from all statements.
 
 -   Transport Layer Security (TLS) where supported ([MySQL] and [PostgreSQL]).
 
@@ -115,10 +115,10 @@ with C, those interactions are `unsafe`.
 
 ## Install
 
-SQLx is compatible with the [`async-std`], [`tokio`] and [`actix`] runtimes; and, the [`native-tls`] and [`rustls`] TLS backends. When adding the dependency, you must chose a runtime feature that is `runtime` + `tls`.
+SQLx is compatible with the [`async-std`], [`tokio`], and [`actix`] runtimes; and, the [`native-tls`] and [`rustls`] TLS backends. When adding the dependency, you must choose a runtime feature that is `runtime` + `tls`.
 
 NOTE: these examples are for the coming 0.7 release, which is currently in an alpha cycle.
-For the last stable release, 0.6.2, see [the previous verison of this document](https://github.com/launchbadge/sqlx/blob/v0.6.2/README.md).
+For the last stable release, 0.6.2, see [the previous version of this document](https://github.com/launchbadge/sqlx/blob/v0.6.2/README.md).
 
 [`async-std`]: https://github.com/async-rs/async-std
 [`tokio`]: https://github.com/tokio-rs/tokio
@@ -148,10 +148,10 @@ sqlx = { version = "0.7", features = [ "runtime-async-std", "tls-rustls" ] }
 
 #### Cargo Feature Flags
 
-For backwards-compatibility reasons, the runtime and TLS features can either be chosen together as a single feature,
+For backward-compatibility reasons, the runtime and TLS features can either be chosen together as a single feature,
 or separately.
 
-For forward-compatibility, you should use the separate runtime and TLS features as the combination features may
+For forward compatibility, you should use the separate runtime and TLS features as the combination features may
 be removed in the future.
 
 -   `runtime-async-std`: Use the `async-std` runtime without enabling a TLS backend.
@@ -170,7 +170,7 @@ be removed in the future.
 
 -   `tls-native`: Use the `native-tls` TLS backend (OpenSSL on *nix, SChannel on Windows, Secure Transport on macOS).
 
--   `tls-rustls`: Use the `rustls` TLS backend (crossplatform backend, only supports TLS 1.2 and 1.3).
+-   `tls-rustls`: Use the `rustls` TLS backend (cross-platform backend, only supports TLS 1.2 and 1.3).
 
 -   `postgres`: Add support for the Postgres database server.
 
@@ -182,7 +182,7 @@ be removed in the future.
 
 -   `any`: Add support for the `Any` database driver, which can proxy to a database driver at runtime.
 
--   `macros`: Add support for the `query*!` macros, which allow compile-time checked queries.
+-   `macros`: Add support for the `query*!` macros, which allows compile-time checked queries.
 
 -   `migrate`: Add support for the migration management and `migrate!` macro, which allow compile-time embedded migrations.
 
@@ -210,7 +210,7 @@ be removed in the future.
 
 SQLx supports **compile-time checked queries**. It does not, however, do this by providing a Rust
 API or DSL (domain-specific language) for building queries. Instead, it provides macros that take
-regular SQL as an input and ensure that it is valid for your database. The way this works is that
+regular SQL as input and ensure that it is valid for your database. The way this works is that
 SQLx connects to your development DB at compile time to have the database itself verify (and return
 some info on) your SQL queries. This has some potentially surprising implications:
 
@@ -231,7 +231,7 @@ See the `examples/` folder for more in-depth usage.
 ### Quickstart
 
 NOTE: these examples are for the coming 0.7.0 release, which is currently in an alpha cycle.
-For the last stable release, 0.6.2, see [the previous verison of this document](https://github.com/launchbadge/sqlx/blob/v0.6.2/README.md).
+For the last stable release, 0.6.2, see [the previous version of this document](https://github.com/launchbadge/sqlx/blob/v0.6.2/README.md).
 
 ```rust
 use sqlx::postgres::PgPoolOptions;
@@ -271,7 +271,7 @@ use sqlx::Connection;
 let conn = SqliteConnection::connect("sqlite::memory:").await?;
 ```
 
-Generally, you will want to instead create a connection pool (`sqlx::Pool`) in order for your application to
+Generally, you will want to instead create a connection pool (`sqlx::Pool`) for the application to
 regulate how many server-side connections it's using.
 
 ```rust
@@ -282,10 +282,10 @@ let pool = MySqlPool::connect("mysql://user:pass@host/database").await?;
 
 In SQL, queries can be separated into prepared (parameterized) or unprepared (simple). Prepared queries have their
 query plan _cached_, use a binary mode of communication (lower bandwidth and faster decoding), and utilize parameters
-to avoid SQL injection. Unprepared queries are simple and intended only for use case where a prepared statement
+to avoid SQL injection. Unprepared queries are simple and intended only for use where a prepared statement
 will not work, such as various database commands (e.g., `PRAGMA` or `SET` or `BEGIN`).
 
-SQLx supports all operations with both types of queries. In SQLx, a `&str` is treated as an unprepared query
+SQLx supports all operations with both types of queries. In SQLx, a `&str` is treated as an unprepared query,
 and a `Query` or `QueryAs` struct is treated as a prepared query.
 
 ```rust
@@ -294,7 +294,7 @@ conn.execute("BEGIN").await?; // unprepared, simple query
 conn.execute(sqlx::query("DELETE FROM table")).await?; // prepared, cached query
 ```
 
-We should prefer to use the high level, `query` interface whenever possible. To make this easier, there are finalizers
+We should prefer to use the high-level `query` interface whenever possible. To make this easier, there are finalizers
 on the type to avoid the need to wrap with an executor.
 
 ```rust
@@ -325,7 +325,7 @@ while let Some(row) = rows.try_next().await? {
 }
 ```
 
-To assist with mapping the row into a domain type, there are two idioms that may be used:
+To assist with mapping the row into a domain type, one of two idioms may be used:
 
 ```rust
 let mut stream = sqlx::query("SELECT * FROM users")
@@ -422,7 +422,7 @@ modifications (to the database-accessing parts of the code) are done, you can en
 to cache the results of the SQL query analysis using the `sqlx` command-line tool. See
 [sqlx-cli/README.md](./sqlx-cli/README.md#enable-building-in-offline-mode-with-query).
 
-Compile time verified queries do quite a bit of work at compile time. Incremental actions like
+Compile-time verified queries do quite a bit of work at compile time. Incremental actions like
 `cargo check` and `cargo build` can be significantly faster when using an optimized build by
 putting the following in your `Cargo.toml` (More information in the
 [Profiles section](https://doc.rust-lang.org/cargo/reference/profiles.html) of The Cargo Book)
@@ -455,6 +455,6 @@ at your option.
 
 ## Contribution
 
-Unless you explicitly state otherwise, any contribution intentionally submitted
+Unless you explicitly state otherwise, any Contribution intentionally submitted
 for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
 dual licensed as above, without any additional terms or conditions.

README.md

@@ -0,0 +1,141 @@
+use criterion::BenchmarkId;
+use criterion::Criterion;
+use criterion::{criterion_group, criterion_main};
+
+use sqlx::sqlite::{Sqlite, SqliteConnection};
+use sqlx::{Connection, Executor};
+use sqlx_test::new;
+
+// Here we have an async function to benchmark
+async fn do_describe_trivial(db: &std::cell::RefCell<SqliteConnection>) {
+    db.borrow_mut().describe("select 1").await.unwrap();
+}
+
+async fn do_describe_recursive(db: &std::cell::RefCell<SqliteConnection>) {
+    db.borrow_mut()
+        .describe(
+            r#"
+            WITH RECURSIVE schedule(begin_date) AS MATERIALIZED (
+                SELECT datetime('2022-10-01')
+                WHERE datetime('2022-10-01') < datetime('2022-11-03')
+                UNION ALL
+                SELECT datetime(begin_date,'+1 day')
+                FROM schedule
+                WHERE datetime(begin_date) < datetime(?2)
+            )
+            SELECT
+            begin_date
+            FROM schedule
+            GROUP BY begin_date
+            "#,
+        )
+        .await
+        .unwrap();
+}
+
+async fn do_describe_insert(db: &std::cell::RefCell<SqliteConnection>) {
+    db.borrow_mut()
+        .describe("INSERT INTO tweet (id, text) VALUES (2, 'Hello') RETURNING *")
+        .await
+        .unwrap();
+}
+
+async fn do_describe_insert_fks(db: &std::cell::RefCell<SqliteConnection>) {
+    db.borrow_mut()
+        .describe("insert into statements (text) values ('a') returning id")
+        .await
+        .unwrap();
+}
+
+async fn init_connection() -> SqliteConnection {
+    let mut conn = new::<Sqlite>().await.unwrap();
+
+    conn.execute(
+        r#"
+        CREATE TEMPORARY TABLE statements (
+          id integer not null primary key,
+          text text not null
+        );
+
+        CREATE TEMPORARY TABLE votes1 (statement_id integer not null references statements(id));
+        CREATE TEMPORARY TABLE votes2 (statement_id integer not null references statements(id));
+        CREATE TEMPORARY TABLE votes3 (statement_id integer not null references statements(id));
+        CREATE TEMPORARY TABLE votes4 (statement_id integer not null references statements(id));
+        CREATE TEMPORARY TABLE votes5 (statement_id integer not null references statements(id));
+        CREATE TEMPORARY TABLE votes6 (statement_id integer not null references statements(id));
+        --CREATE TEMPORARY TABLE votes7 (statement_id integer not null references statements(id));
+        --CREATE TEMPORARY TABLE votes8 (statement_id integer not null references statements(id));
+        --CREATE TEMPORARY TABLE votes9 (statement_id integer not null references statements(id));
+        --CREATE TEMPORARY TABLE votes10 (statement_id integer not null references statements(id));
+        --CREATE TEMPORARY TABLE votes11 (statement_id integer not null references statements(id));
+    "#,
+    )
+    .await
+    .unwrap();
+    conn
+}
+
+fn describe_trivial(c: &mut Criterion) {
+    let runtime = tokio::runtime::Runtime::new().unwrap();
+    let db = std::cell::RefCell::new(runtime.block_on(init_connection()));
+
+    c.bench_with_input(
+        BenchmarkId::new("select", "trivial"),
+        &db,
+        move |b, db_ref| {
+            // Insert a call to `to_async` to convert the bencher to async mode.
+            // The timing loops are the same as with the normal bencher.
+            b.to_async(&runtime).iter(|| do_describe_trivial(db_ref));
+        },
+    );
+}
+
+fn describe_recursive(c: &mut Criterion) {
+    let runtime = tokio::runtime::Runtime::new().unwrap();
+    let db = std::cell::RefCell::new(runtime.block_on(init_connection()));
+
+    c.bench_with_input(
+        BenchmarkId::new("select", "recursive"),
+        &db,
+        move |b, db_ref| {
+            // Insert a call to `to_async` to convert the bencher to async mode.
+            // The timing loops are the same as with the normal bencher.
+            b.to_async(&runtime).iter(|| do_describe_recursive(db_ref));
+        },
+    );
+}
+
+fn describe_insert(c: &mut Criterion) {
+    let runtime = tokio::runtime::Runtime::new().unwrap();
+    let db = std::cell::RefCell::new(runtime.block_on(init_connection()));
+
+    c.bench_with_input(
+        BenchmarkId::new("insert", "returning"),
+        &db,
+        move |b, db_ref| {
+            // Insert a call to `to_async` to convert the bencher to async mode.
+            // The timing loops are the same as with the normal bencher.
+            b.to_async(&runtime).iter(|| do_describe_insert(db_ref));
+        },
+    );
+}
+
+fn describe_insert_fks(c: &mut Criterion) {
+    let runtime = tokio::runtime::Runtime::new().unwrap();
+    let db = std::cell::RefCell::new(runtime.block_on(init_connection()));
+
+    c.bench_with_input(BenchmarkId::new("insert", "fks"), &db, move |b, db_ref| {
+        // Insert a call to `to_async` to convert the bencher to async mode.
+        // The timing loops are the same as with the normal bencher.
+        b.to_async(&runtime).iter(|| do_describe_insert_fks(db_ref));
+    });
+}
+
+criterion_group!(
+    benches,
+    describe_trivial,
+    describe_recursive,
+    describe_insert,
+    describe_insert_fks
+);
+criterion_main!(benches);

benches/sqlite/describe.rs

@@ -36,9 +36,9 @@ tokio = { workspace = true, optional = true }
 # TLS
 native-tls = { version = "0.2.10", optional = true }
 
-rustls = { version = "0.20.6", default-features = false, features = ["dangerous_configuration", "tls12"], optional = true }
+rustls = { version = "0.21", default-features = false, features = ["dangerous_configuration", "tls12"], optional = true }
 rustls-pemfile = { version = "1.0", optional = true }
-webpki-roots = { version = "0.22.0", optional = true }
+webpki-roots = { version = "0.23", optional = true }
 
 # Type Integrations
 bit-vec = { workspace = true, optional = true }

sqlx-core/Cargo.toml

@@ -6,7 +6,8 @@ use std::time::SystemTime;
 
 use rustls::{
     client::{ServerCertVerified, ServerCertVerifier, WebPkiVerifier},
-    ClientConfig, ClientConnection, Error as TlsError, OwnedTrustAnchor, RootCertStore, ServerName,
+    CertificateError, ClientConfig, ClientConnection, Error as TlsError, OwnedTrustAnchor,
+    RootCertStore, ServerName,
 };
 
 use crate::error::Error;
@@ -234,8 +235,8 @@ impl ServerCertVerifier for NoHostnameTlsVerifier {
             ocsp_response,
             now,
         ) {
-            Err(TlsError::InvalidCertificateData(reason))
-                if reason.contains("CertNotValidForName") =>
+            Err(TlsError::InvalidCertificate(reason))
+                if reason == CertificateError::NotValidForName =>
             {
                 Ok(ServerCertVerified::assertion())
             }

sqlx-core/src/net/tls/tls_rustls.rs

@@ -19,8 +19,6 @@
     feature(track_path)
 )]
 
-use once_cell::sync::Lazy;
-
 use crate::query::QueryDriver;
 
 pub type Error = Box<dyn std::error::Error>;
@@ -54,6 +52,7 @@ where
 {
     #[cfg(feature = "_rt-tokio")]
     {
+        use once_cell::sync::Lazy;
         use tokio::runtime::{self, Runtime};
 
         // We need a single, persistent Tokio runtime since we're caching connections,