Merge pull request #4540 from achanda/prepare-2.2.9

Prepare a 2.2.9 release

Author: weiznich

.github/workflows/ci.yml

@@ -126,8 +126,9 @@ jobs:
           echo "MYSQL_UNIT_TEST_DATABASE_URL=mysql://root:[email protected]/diesel_unit_test" >> $GITHUB_ENV
 
       - name: Install postgres (MacOS)
-        if: matrix.os == 'macos-13' || matrix.os == 'macos-15' && matrix.backend == 'postgres'
+        if: (matrix.os == 'macos-13' || matrix.os == 'macos-15') && matrix.backend == 'postgres'
         run: |
+          brew update
           brew install postgresql@14
           brew services start postgresql@14
           sleep 3
@@ -519,7 +520,7 @@ jobs:
       - name: Install Mysql (Linux)
         run: |
           sudo apt-get update
-          sudo apt-get -y install libmysqlclient-dev llvm
+          sudo apt-get -y install libmysqlclient-dev llvm libtirpc-dev
           sudo systemctl start mysql.service
           sleep 5
           mysql -e "create database diesel_test; create database diesel_unit_test; grant all on \`diesel_%\`.* to 'root'@'localhost';" -uroot -proot

CHANGELOG.md

@@ -10,8 +10,15 @@ Increasing the minimal supported Rust version will always be coupled at least wi
 
 ## Unreleased
 
-## [2.2.8] 2025-03-03
+## [2.2.9] 2025-04-04
+### Fixed
 
+* Fix an issue where `diesel migration generate --diff-schema` incorrectly uses the primary key of table B as the referenced column rather than the primary key of table A when B has a foreign key pointing to table A.
+* Bump maximal supported libsqlite3-sys version to 0.32.0 and add explicit feature entries for the `uuid` and `serde_json` feature.
+* Fixed an issue where diesel generated unnamed prepared statements would fail with an `unanmed prepared statement not found` error with pgbouncer.
+* Fix an issue with converting `ipnet::Ipnet` values with an subnet to SQL values
+
+## [2.2.8] 2025-03-03
 ### Fixed
 
 * Allow `#[diesel(check_for_backend(_))]` to check fields with `#[diesel(embed)]` annotations
@@ -2190,3 +2197,4 @@ queries or set `PIPES_AS_CONCAT` manually.
 [2.2.6]: https://github.com/diesel-rs/diesel/compare/v2.2.5...v2.2.6
 [2.2.7]: https://github.com/diesel-rs/diesel/compare/v2.2.6...v2.2.7
 [2.2.8]: https://github.com/diesel-rs/diesel/compare/v2.2.7...v2.2.8
+[2.2.9]: https://github.com/diesel-rs/diesel/compare/v2.2.8...v2.2.9

Cargo.toml

@@ -35,7 +35,7 @@ rust-version = "1.78.0"
 include = ["src/**/*.rs", "tests/**/*.rs", "LICENSE-*", "README.md"]
 
 [workspace.dependencies]
-libsqlite3-sys = ">=0.30.1,<0.32.0"
+libsqlite3-sys = ">=0.30.1,<0.33.0"
 
 # Config for 'cargo dist'
 [workspace.metadata.dist]

diesel/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "diesel"
-version = "2.2.8"
+version = "2.2.9"
 license = "MIT OR Apache-2.0"
 description = "A safe, extensible ORM and Query Builder for PostgreSQL, SQLite, and MySQL"
 readme = "README.md"
@@ -24,7 +24,7 @@ include = [
 byteorder = { version = "1.0", optional = true }
 chrono = { version = "0.4.20", optional = true, default-features = false, features = ["clock", "std"] }
 libc = { version = "0.2.0", optional = true }
-libsqlite3-sys = { version = ">=0.17.2, <0.32.0", optional = true, features = ["bundled_bindings"] }
+libsqlite3-sys = { version = ">=0.17.2, <0.33.0", optional = true, features = ["bundled_bindings"] }
 mysqlclient-sys = { version = ">=0.2.5, <0.5.0",  optional = true }
 mysqlclient-src = { version = "0.1.0", optional = true }
 pq-sys = { version = ">=0.4.0, <0.8.0", optional = true }
@@ -80,6 +80,8 @@ i-implement-a-third-party-backend-and-opt-into-breaking-changes = []
 r2d2 = ["diesel_derives/r2d2", "dep:r2d2"]
 chrono = ["diesel_derives/chrono", "dep:chrono"]
 time = ["diesel_derives/time", "dep:time"]
+uuid = ["dep:uuid"]
+serde_json = ["dep:serde_json"]
 __with_asan_tests = [
     "libsqlite3-sys?/bundled",
     "libsqlite3-sys?/with-asan",

diesel/src/connection/statement_cache.rs

@@ -30,9 +30,9 @@
 //! - queries containing `IN` with bind parameters
 //!     - This requires 1 bind parameter per value, and is therefore unbounded
 //!     - `IN` with subselects are cached (assuming the subselect is safe to
-//!        cache)
+//!       cache)
 //!     - `IN` statements for postgresql are cached as they use `= ANY($1)` instead
-//!        which does not cause a unbound number of binds
+//!       which does not cause an unbound number of binds
 //! - `INSERT` statements with a variable number of rows
 //!     - The SQL varies based on the number of rows being inserted.
 //! - `UPDATE` statements

diesel/src/lib.rs

@@ -97,41 +97,41 @@
 //! The following error messages are common:
 //!
 //! * `the trait bound (diesel::sql_types::Integer, …, diesel::sql_types::Text): load_dsl::private::CompatibleType<YourModel, Pg> is not satisfied`
-//!    while trying to execute a query:
-//!    This error indicates a mismatch between what your query returns and what your model struct
-//!    expects the query to return. The fields need to match in terms of field order, field type
-//!    and field count. If you are sure that everything matches, double check the enabled diesel
-//!    features (for support for types from other crates) and double check (via `cargo tree`)
-//!    that there is only one version of such a shared crate in your dependency tree.
-//!    Consider using [`#[derive(Selectable)]`](derive@crate::prelude::Selectable) +
-//!    `#[diesel(check_for_backend(diesel::pg::Pg))]`
-//!    to improve the generated error message.
+//!   while trying to execute a query:
+//!   This error indicates a mismatch between what your query returns and what your model struct
+//!   expects the query to return. The fields need to match in terms of field order, field type
+//!   and field count. If you are sure that everything matches, double check the enabled diesel
+//!   features (for support for types from other crates) and double check (via `cargo tree`)
+//!   that there is only one version of such a shared crate in your dependency tree.
+//!   Consider using [`#[derive(Selectable)]`](derive@crate::prelude::Selectable) +
+//!   `#[diesel(check_for_backend(diesel::pg::Pg))]`
+//!   to improve the generated error message.
 //! * `the trait bound i32: diesel::Expression is not satisfied` in the context of `Insertable`
-//!    model structs:
-//!    This error indicates a type mismatch between the field you are trying to insert into the database
-//!    and the actual database type. These error messages contain a line
-//!    like ` = note: required for i32 to implement AsExpression<diesel::sql_types::Text>`
-//!    that show both the provided rust side type (`i32` in that case) and the expected
-//!    database side type (`Text` in that case).
+//!   model structs:
+//!   This error indicates a type mismatch between the field you are trying to insert into the database
+//!   and the actual database type. These error messages contain a line
+//!   like ` = note: required for i32 to implement AsExpression<diesel::sql_types::Text>`
+//!   that show both the provided rust side type (`i32` in that case) and the expected
+//!   database side type (`Text` in that case).
 //! * `the trait bound i32: AppearsOnTable<users::table> is not satisfied` in the context of `AsChangeset`
-//!    model structs:
-//!    This error indicates a type mismatch between the field you are trying to update and the actual
-//!    database type. Double check your type mapping.
+//!   model structs:
+//!   This error indicates a type mismatch between the field you are trying to update and the actual
+//!   database type. Double check your type mapping.
 //! * `the trait bound SomeLargeType: QueryFragment<Sqlite, SomeMarkerType> is not satisfied` while
-//!    trying to execute a query.
-//!    This error message indicates that a given query is not supported by your backend. This usually
-//!    means that you are trying to use SQL features from one SQL dialect on a different database
-//!    system. Double check your query that everything required is supported by the selected
-//!    backend. If that's the case double check that the relevant feature flags are enabled
-//!    (for example, `returning_clauses_for_sqlite_3_35` for enabling support for returning clauses in newer
-//!    sqlite versions)
+//!   trying to execute a query.
+//!   This error message indicates that a given query is not supported by your backend. This usually
+//!   means that you are trying to use SQL features from one SQL dialect on a different database
+//!   system. Double check your query that everything required is supported by the selected
+//!   backend. If that's the case double check that the relevant feature flags are enabled
+//!   (for example, `returning_clauses_for_sqlite_3_35` for enabling support for returning clauses in newer
+//!   sqlite versions)
 //! * `the trait bound posts::title: SelectableExpression<users::table> is not satisfied` while
-//!    executing a query:
-//!    This error message indicates that you're trying to select a field from a table
-//!    that does not appear in your from clause. If your query joins the relevant table via
-//!    [`left_join`](crate::query_dsl::QueryDsl::left_join) you need to call
-//!    [`.nullable()`](crate::expression_methods::NullableExpressionMethods::nullable)
-//!    on the relevant column in your select clause.
+//!   executing a query:
+//!   This error message indicates that you're trying to select a field from a table
+//!   that does not appear in your from clause. If your query joins the relevant table via
+//!   [`left_join`](crate::query_dsl::QueryDsl::left_join) you need to call
+//!   [`.nullable()`](crate::expression_methods::NullableExpressionMethods::nullable)
+//!   on the relevant column in your select clause.
 //!
 //!
 //! ## Getting help

diesel/src/mysql/connection/mod.rs

@@ -24,8 +24,8 @@ use crate::RunQueryDsl;
 /// `mysql://[user[:password]@]host/database_name[?unix_socket=socket-path&ssl_mode=SSL_MODE*&ssl_ca=/etc/ssl/certs/ca-certificates.crt&ssl_cert=/etc/ssl/certs/client-cert.crt&ssl_key=/etc/ssl/certs/client-key.crt]`
 ///
 ///* `host` can be an IP address or a hostname. If it is set to `localhost`, a connection
-///   will be attempted through the socket at `/tmp/mysql.sock`. If you want to connect to
-///   a local server via TCP (e.g. docker containers), use `0.0.0.0` or `127.0.0.1` instead.
+///  will be attempted through the socket at `/tmp/mysql.sock`. If you want to connect to
+///  a local server via TCP (e.g. docker containers), use `0.0.0.0` or `127.0.0.1` instead.
 /// * `unix_socket` expects the path to the unix socket
 /// * `ssl_ca` accepts a path to the system's certificate roots
 /// * `ssl_cert` accepts a path to the client's certificate file

diesel/src/pg/connection/raw.rs

@@ -64,6 +64,40 @@ impl RawConnection {
         RawResult::new(PQexec(self.internal_connection.as_ptr(), query), self)
     }
 
+    /// Sends a query and parameters to the server without using the prepare/bind cycle.
+    ///
+    /// This method uses PQsendQueryParams which combines the prepare and bind steps
+    /// and is more compatible with connection poolers like PgBouncer.
+    pub(super) unsafe fn send_query_params(
+        &self,
+        query: *const libc::c_char,
+        param_count: libc::c_int,
+        param_types: *const Oid,
+        param_values: *const *const libc::c_char,
+        param_lengths: *const libc::c_int,
+        param_formats: *const libc::c_int,
+        result_format: libc::c_int,
+    ) -> QueryResult<()> {
+        let res = PQsendQueryParams(
+            self.internal_connection.as_ptr(),
+            query,
+            param_count,
+            param_types,
+            param_values,
+            param_lengths,
+            param_formats,
+            result_format,
+        );
+        if res == 1 {
+            Ok(())
+        } else {
+            Err(Error::DatabaseError(
+                DatabaseErrorKind::UnableToSendCommand,
+                Box::new(self.last_error_message()),
+            ))
+        }
+    }
+
     pub(super) unsafe fn send_query_prepared(
         &self,
         stmt_name: *const libc::c_char,

diesel/src/pg/connection/stmt/mod.rs

@@ -11,8 +11,13 @@ use crate::result::QueryResult;
 
 use super::raw::RawConnection;
 
+enum StatementKind {
+    Unnamed { sql: CString, param_types: Vec<u32> },
+    Named { name: CString },
+}
+
 pub(crate) struct Statement {
-    name: CString,
+    kind: StatementKind,
     param_formats: Vec<libc::c_int>,
 }
 
@@ -40,16 +45,39 @@ impl Statement {
             .len()
             .try_into()
             .map_err(|e| crate::result::Error::SerializationError(Box::new(e)))?;
-        unsafe {
-            raw_connection.send_query_prepared(
-                self.name.as_ptr(),
-                param_count,
-                params_pointer.as_ptr(),
-                param_lengths.as_ptr(),
-                self.param_formats.as_ptr(),
-                1,
-            )
-        }?;
+
+        match &self.kind {
+            StatementKind::Named { name } => {
+                unsafe {
+                    // execute the previously prepared statement
+                    // in autocommit mode, this will be a new transaction
+                    raw_connection.send_query_prepared(
+                        name.as_ptr(),
+                        param_count,
+                        params_pointer.as_ptr(),
+                        param_lengths.as_ptr(),
+                        self.param_formats.as_ptr(),
+                        1,
+                    )
+                }?
+            }
+            StatementKind::Unnamed { sql, param_types } => unsafe {
+                // execute the unnamed prepared statement using send_query_params
+                // which internally calls PQsendQueryParams, making sure the
+                // prepare and execute happens in a single transaction. This
+                // makes sure these are handled by PgBouncer.
+                // See https://github.com/diesel-rs/diesel/pull/4539
+                raw_connection.send_query_params(
+                    sql.as_ptr(),
+                    param_count,
+                    param_types.as_ptr(),
+                    params_pointer.as_ptr(),
+                    param_lengths.as_ptr(),
+                    self.param_formats.as_ptr(),
+                    1,
+                )
+            }?,
+        };
         if row_by_row {
             raw_connection.enable_row_by_row_mode()?;
         }
@@ -62,32 +90,48 @@ impl Statement {
         name: Option<&str>,
         param_types: &[PgTypeMetadata],
     ) -> QueryResult<Self> {
-        let name = CString::new(name.unwrap_or(""))?;
         let sql = CString::new(sql)?;
         let param_types_vec = param_types
             .iter()
             .map(|x| x.oid())
             .collect::<Result<Vec<_>, _>>()
             .map_err(|e| crate::result::Error::SerializationError(Box::new(e)))?;
 
-        let internal_result = unsafe {
+        if let Some(name) = name {
+            let name = CString::new(name)?;
             let param_count: libc::c_int = param_types
                 .len()
                 .try_into()
                 .map_err(|e| crate::result::Error::SerializationError(Box::new(e)))?;
-            raw_connection.prepare(
-                name.as_ptr(),
-                sql.as_ptr(),
-                param_count,
-                param_types_to_ptr(Some(&param_types_vec)),
-            )
-        };
-        PgResult::new(internal_result?, raw_connection)?;
+            let internal_result = unsafe {
+                raw_connection.prepare(
+                    name.as_ptr(),
+                    sql.as_ptr(),
+                    param_count,
+                    param_types_to_ptr(Some(&param_types_vec)),
+                )
+            };
+            PgResult::new(internal_result?, raw_connection)?;
 
-        Ok(Statement {
-            name,
-            param_formats: vec![1; param_types.len()],
-        })
+            Ok(Statement {
+                kind: StatementKind::Named { name },
+                param_formats: vec![1; param_types.len()],
+            })
+        } else {
+            // For unnamed statements, we'll return a Statement object without
+            // actually preparing it. This allows us to use send_query_params
+            // later in the execute call. This is needed to better interface
+            // with PgBouncer which cannot handle unnamed prepared statements
+            // when those are prepared and executed in separate transactions.
+            // See https://github.com/diesel-rs/diesel/pull/4539
+            Ok(Statement {
+                kind: StatementKind::Unnamed {
+                    sql,
+                    param_types: param_types_vec,
+                },
+                param_formats: vec![1; param_types.len()],
+            })
+        }
     }
 }
 

diesel/src/pg/expression/expression_methods.rs

@@ -466,12 +466,12 @@ pub trait PgSortExpressionMethods: Sized {
     ///
     /// let asc_default_nulls = nullable_numbers.select(nullable_number)
     ///     .order(nullable_number.asc())
-    ///     .load(connection)?;
+    ///     .load::<Option<i32>>(connection)?;
     /// assert_eq!(vec![Some(1), Some(2), None], asc_default_nulls);
     ///
     /// let asc_nulls_first = nullable_numbers.select(nullable_number)
     ///     .order(nullable_number.asc().nulls_first())
-    ///     .load(connection)?;
+    ///     .load::<Option<i32>>(connection)?;
     /// assert_eq!(vec![None, Some(1), Some(2)], asc_nulls_first);
     /// #     Ok(())
     /// # }
@@ -514,12 +514,12 @@ pub trait PgSortExpressionMethods: Sized {
     ///
     /// let desc_default_nulls = nullable_numbers.select(nullable_number)
     ///     .order(nullable_number.desc())
-    ///     .load(connection)?;
+    ///     .load::<Option<i32>>(connection)?;
     /// assert_eq!(vec![None, Some(2), Some(1)], desc_default_nulls);
     ///
     /// let desc_nulls_last = nullable_numbers.select(nullable_number)
     ///     .order(nullable_number.desc().nulls_last())
-    ///     .load(connection)?;
+    ///     .load::<Option<i32>>(connection)?;
     /// assert_eq!(vec![Some(2), Some(1), None], desc_nulls_last);
     /// #     Ok(())
     /// # }