Clippy

Author: kakserpom

Cargo.lock

@@ -24,6 +24,7 @@ trim-in-place = "0.1.7"
 serde = { version = "1.0", features = ["derive"] }
 strum_macros = "0.27"
 url = "2.5.4"
+saturating_cast = "0.1.0"
 
 [features]
 default = [

Cargo.toml

@@ -53,12 +53,12 @@ fn bench_ast(c: &mut Criterion) {
     c.bench_function("Ast::parse_small", |b| {
         b.iter(|| {
             let _res = black_box(Ast::parse(QUERY_SMALL, &SETTINGS));
-        })
+        });
     });
     c.bench_function("Ast::parse_big", |b| {
         b.iter(|| {
             let _res = black_box(Ast::parse(QUERY_BIG, &SETTINGS));
-        })
+        });
     });
 
     c.bench_function("Ast::render_big", |b| {
@@ -72,7 +72,7 @@ fn bench_ast(c: &mut Criterion) {
                 ]),
                 &SETTINGS,
             ));
-        })
+        });
     });
 }
 

benches/benchmark.rs

@@ -1,4 +1,4 @@
-//! MySQL query result iterator.
+//! `MySQL` query result iterator.
 
 crate::php_sqlx_impl_query_result!(
     MySqlQueryResult,

php-sqlx-cdylib/Cargo.lock

@@ -1,4 +1,4 @@
-//! PostgreSQL query result iterator.
+//! `PostgreSQL` query result iterator.
 
 crate::php_sqlx_impl_query_result!(
     PgQueryResult,

src/dbms/mysql/query_result.rs

@@ -658,7 +658,7 @@ macro_rules! php_sqlx_impl_driver {
                 self.driver_inner.query_all(query, parameters, None)
             }
 
-            /// Executes an SQL query and returns a lazy QueryResult iterator.
+            /// Executes an SQL query and returns a lazy `QueryResult` iterator.
             ///
             /// This method returns a `QueryResult` object that implements PHP's `Iterator`
             /// interface, streaming rows from the database as you iterate.
@@ -702,7 +702,7 @@ macro_rules! php_sqlx_impl_driver {
                 Ok($query_result::new(receiver, assoc, batch_size))
             }
 
-            /// Executes an SQL query and returns a lazy QueryResult iterator with rows as associative arrays.
+            /// Executes an SQL query and returns a lazy `QueryResult` iterator with rows as associative arrays.
             ///
             /// Same as `query()`, but forces rows to be returned as associative arrays
             /// regardless of the driver's default configuration.
@@ -725,7 +725,7 @@ macro_rules! php_sqlx_impl_driver {
                 Ok($query_result::new(receiver, true, batch_size))
             }
 
-            /// Executes an SQL query and returns a lazy QueryResult iterator with rows as objects.
+            /// Executes an SQL query and returns a lazy `QueryResult` iterator with rows as objects.
             ///
             /// Same as `query()`, but forces rows to be returned as PHP objects
             /// regardless of the driver's default configuration.

src/dbms/postgres/query_result.rs

@@ -141,7 +141,7 @@ macro_rules! php_sqlx_impl_driver_inner {
         /// Type alias for the row stream used in lazy iteration.
         /// Rows are streamed through this channel from a background task.
         pub type RowReceiver = tokio::sync::mpsc::Receiver<
-            Result<<$database as sqlx_oldapi::Database>::Row, $crate::error::Error>
+            Result<<$database as sqlx_oldapi::Database>::Row, $crate::error::Error>,
         >;
 
         impl $struct {
@@ -873,15 +873,18 @@ macro_rules! php_sqlx_impl_driver_inner {
                 // the connection to stay in the current context
                 if self.has_active_transaction() || self.has_pinned_connection() {
                     // Fall back to fetching all rows in the current context
-                    let rows_result = if let Some(mut conn_tx) = self.retrieve_ongoing_transaction() {
+                    let rows_result = if let Some(mut conn_tx) = self.retrieve_ongoing_transaction()
+                    {
                         let val = RUNTIME.block_on(
-                            bind_values(sqlx_oldapi::query(&rendered_query), &values)?.fetch_all(&mut *conn_tx),
+                            bind_values(sqlx_oldapi::query(&rendered_query), &values)?
+                                .fetch_all(&mut *conn_tx),
                         );
                         self.place_ongoing_transaction(conn_tx);
                         val
                     } else if let Some(mut conn) = self.retrieve_pinned_connection() {
                         let val = RUNTIME.block_on(
-                            bind_values(sqlx_oldapi::query(&rendered_query), &values)?.fetch_all(&mut *conn),
+                            bind_values(sqlx_oldapi::query(&rendered_query), &values)?
+                                .fetch_all(&mut *conn),
                         );
                         self.return_pinned_connection(conn);
                         val
@@ -899,7 +902,10 @@ macro_rules! php_sqlx_impl_driver_inner {
                             }
                         }
                         Err(err) => {
-                            let _ = tx.blocking_send(Err(SqlxError::query_with_source(&rendered_query, err)));
+                            let _ = tx.blocking_send(Err(SqlxError::query_with_source(
+                                &rendered_query,
+                                err,
+                            )));
                         }
                     }
 
@@ -913,13 +919,14 @@ macro_rules! php_sqlx_impl_driver_inner {
                 // Spawn a background task that streams rows and sends through channel
                 RUNTIME.spawn(async move {
                     // Bind the query with values
-                    let bound_query = match bind_values(sqlx_oldapi::query(&rendered_query), &values) {
-                        Ok(q) => q,
-                        Err(e) => {
-                            let _ = tx.send(Err(e)).await;
-                            return;
-                        }
-                    };
+                    let bound_query =
+                        match bind_values(sqlx_oldapi::query(&rendered_query), &values) {
+                            Ok(q) => q,
+                            Err(e) => {
+                                let _ = tx.send(Err(e)).await;
+                                return;
+                            }
+                        };
 
                     // Create the stream from the pool
                     let mut stream = bound_query.fetch(&pool);

src/driver.rs

@@ -2747,7 +2747,7 @@ macro_rules! php_sqlx_impl_query_builder {
                     .query_all(&self.query, merged_params, Some(false))
             }
 
-            /// Executes the query and returns a lazy QueryResult iterator.
+            /// Executes the query and returns a lazy `QueryResult` iterator.
             ///
             /// This method returns a `QueryResult` object that implements PHP's `Iterator`
             /// interface, streaming rows from the database as you iterate.
@@ -2770,7 +2770,7 @@ macro_rules! php_sqlx_impl_query_builder {
                 Ok(super::query_result::$query_result::new(receiver, assoc, batch_size))
             }
 
-            /// Executes the query and returns a lazy QueryResult iterator with rows as associative arrays.
+            /// Executes the query and returns a lazy `QueryResult` iterator with rows as associative arrays.
             ///
             /// # Arguments
             /// - `parameters`: Optional array of indexed/named parameters to bind.
@@ -2789,7 +2789,7 @@ macro_rules! php_sqlx_impl_query_builder {
                 Ok(super::query_result::$query_result::new(receiver, true, batch_size))
             }
 
-            /// Executes the query and returns a lazy QueryResult iterator with rows as objects.
+            /// Executes the query and returns a lazy `QueryResult` iterator with rows as objects.
             ///
             /// # Arguments
             /// - `parameters`: Optional array of indexed/named parameters to bind.

src/inner_driver.rs

@@ -10,23 +10,24 @@
 /// Default batch size for lazy row fetching (channel buffer size).
 pub const DEFAULT_BATCH_SIZE: usize = 100;
 
-/// Generates a database-specific QueryResult implementation with lazy streaming.
+/// Generates a database-specific `QueryResult` implementation with lazy streaming.
 ///
-/// The generated QueryResult implements PHP's `Iterator` interface,
+/// The generated `QueryResult` implements PHP's `Iterator` interface,
 /// receiving rows from a background streaming task as iteration progresses.
 ///
 /// # Arguments
 ///
 /// - `$struct` - The Rust struct name for the query result (e.g., `PgQueryResult`)
 /// - `$class` - The PHP class name as a string literal (e.g., `"Sqlx\\PgQueryResult"`)
-/// - `$database` - The SQLx database type (e.g., `Postgres`)
+/// - `$database` - The `SQLx` database type (e.g., `Postgres`)
 /// - `$inner` - The inner driver type
 #[macro_export]
 macro_rules! php_sqlx_impl_query_result {
     ( $struct:ident, $class:literal, $database:ident, $inner:ident ) => {
         use ext_php_rs::prelude::*;
         use ext_php_rs::types::Zval;
         use ext_php_rs::zend::ce;
+        use saturating_cast::SaturatingCast;
 
         /// A lazy query result iterator that streams rows on demand.
         ///
@@ -48,7 +49,10 @@ macro_rules! php_sqlx_impl_query_result {
         pub struct $struct {
             /// Channel receiver for streaming rows from background task
             receiver: tokio::sync::mpsc::Receiver<
-                Result<<sqlx_oldapi::$database as sqlx_oldapi::Database>::Row, $crate::error::Error>
+                Result<
+                    <sqlx_oldapi::$database as sqlx_oldapi::Database>::Row,
+                    $crate::error::Error,
+                >,
             >,
             /// Current row (converted to Zval)
             current: Option<Zval>,
@@ -69,11 +73,14 @@ macro_rules! php_sqlx_impl_query_result {
         }
 
         impl $struct {
-            /// Creates a new streaming QueryResult.
+            /// Creates a new streaming `QueryResult`.
             #[allow(dead_code)]
             pub fn new(
                 receiver: tokio::sync::mpsc::Receiver<
-                    Result<<sqlx_oldapi::$database as sqlx_oldapi::Database>::Row, $crate::error::Error>
+                    Result<
+                        <sqlx_oldapi::$database as sqlx_oldapi::Database>::Row,
+                        $crate::error::Error,
+                    >,
                 >,
                 associative_arrays: bool,
                 buffer_size: usize,
@@ -178,7 +185,7 @@ macro_rules! php_sqlx_impl_query_result {
             /// Note: This returns the count of rows fetched, not the total
             /// result set size (which may not be known until iteration completes).
             pub fn count(&self) -> i64 {
-                self.total_fetched as i64
+                self.total_fetched.saturating_cast::<i64>()
             }
 
             /// Returns true if the result set has been fully consumed.
@@ -188,13 +195,14 @@ macro_rules! php_sqlx_impl_query_result {
 
             /// Returns the configured buffer size for streaming.
             pub fn get_batch_size(&self) -> i64 {
-                self.buffer_size as i64
+                self.buffer_size.saturating_cast::<i64>()
             }
 
             /// Consumes all remaining rows and returns them as an array.
             ///
             /// This will fetch all remaining rows from the stream.
             /// Use with caution on large result sets.
+            #[allow(clippy::wrong_self_convention)]
             pub fn to_array(&mut self) -> $crate::error::Result<Vec<Zval>> {
                 let mut all_rows = Vec::new();