Check that Connection::execute has no tail

gwenn · gwenn · commit 8064d86b3c5f · 2025-04-19T14:36:44.000+02:00
Idem for Connection::query_row / Connection::query_row_and_then
diff --git a/README.md b/README.md
@@ -135,7 +135,7 @@ features](https://doc.rust-lang.org/cargo/reference/manifest.html#the-features-s
 * `i128_blob` allows storing values of type `i128` type in SQLite databases. Internally, the data is stored as a 16 byte big-endian blob, with the most significant bit flipped, which allows ordering and comparison between different blobs storing i128s to work as expected.
 * `uuid` allows storing and retrieving `Uuid` values from the [`uuid`](https://docs.rs/uuid/) crate using blobs.
 * [`session`](https://sqlite.org/sessionintro.html), Session module extension. Requires `buildtime_bindgen` feature. (Implies `hooks`.)
-* `extra_check` fails when a query passed to `execute` has tail or is readonly and has a column count > 0.
+* `extra_check` fails when a query passed to `execute` is readonly and has a column count > 0.
 * `column_decltype` provides `columns()` method for Statements and Rows; omit if linking to a version of SQLite/SQLCipher compiled with `-DSQLITE_OMIT_DECLTYPE`.
 * `collation` exposes [`sqlite3_create_collation_v2`](https://sqlite.org/c3ref/create_collation.html).
 * `serialize` exposes [`sqlite3_serialize`](http://sqlite.org/c3ref/serialize.html) (3.23.0).
diff --git a/src/lib.rs b/src/lib.rs
@@ -634,8 +634,10 @@ impl Connection {
     /// or if the underlying SQLite call fails.
     #[inline]
     pub fn execute<P: Params>(&self, sql: &str, params: P) -> Result<usize> {
-        self.prepare(sql)
-            .and_then(|mut stmt| stmt.check_no_tail().and_then(|()| stmt.execute(params)))
+        self.prepare(sql).and_then(|mut stmt| {
+            self.check_no_tail(&stmt, sql)
+                .and_then(|()| stmt.execute(params))
+        })
     }
 
     /// Returns the path to the database file, if one exists and is known.
@@ -702,10 +704,23 @@ impl Connection {
         F: FnOnce(&Row<'_>) -> Result<T>,
     {
         let mut stmt = self.prepare(sql)?;
-        stmt.check_no_tail()?;
+        self.check_no_tail(&stmt, sql)?;
         stmt.query_row(params, f)
     }
 
+    #[inline]
+    fn check_no_tail(&self, stmt: &Statement, sql: &str) -> Result<()> {
+        let tail = stmt.stmt.tail();
+        if tail != 0 {
+            eprintln!("TAIL: {}", &sql[tail..]);
+        }
+        if tail != 0 && !self.prepare(&sql[tail..])?.stmt.is_null() {
+            Err(Error::MultipleStatement)
+        } else {
+            Ok(())
+        }
+    }
+
     // https://sqlite.org/tclsqlite.html#onecolumn
     #[cfg(test)]
     pub(crate) fn one_column<T: types::FromSql>(&self, sql: &str) -> Result<T> {
@@ -745,7 +760,7 @@ impl Connection {
         E: From<Error>,
     {
         let mut stmt = self.prepare(sql)?;
-        stmt.check_no_tail()?;
+        self.check_no_tail(&stmt, sql)?;
         let mut rows = stmt.query(params)?;
 
         rows.get_expected_row().map_err(E::from).and_then(f)
@@ -1549,7 +1564,6 @@ mod test {
     }
 
     #[test]
-    #[cfg(feature = "extra_check")]
     fn test_execute_multiple() {
         let db = checked_memory_handle();
         let err = db
@@ -1562,11 +1576,8 @@ mod test {
             Error::MultipleStatement => (),
             _ => panic!("Unexpected error: {err}"),
         }
-        if false {
-            // FIXME
-            db.execute("CREATE TABLE t(c); -- bim", [])
-                .expect("Tail comment should be ignored");
-        }
+        db.execute("CREATE TABLE t(c); -- bim", [])
+            .expect("Tail comment should be ignored");
     }
 
     #[test]
@@ -1679,9 +1690,12 @@ mod test {
             err => panic!("Unexpected error {err}"),
         }
 
-        let bad_query_result = db.query_row("NOT A PROPER QUERY; test123", [], |_| Ok(()));
+        db.query_row("NOT A PROPER QUERY; test123", [], |_| Ok(()))
+            .unwrap_err();
+
+        db.query_row("SELECT 1; SELECT 2;", [], |_| Ok(()))
+            .unwrap_err();
 
-        bad_query_result.unwrap_err();
         Ok(())
     }
 
diff --git a/src/raw_statement.rs b/src/raw_statement.rs
@@ -250,12 +250,6 @@ impl RawStatement {
         unsafe { stmt_status(self.ptr, status, reset) }
     }
 
-    #[inline]
-    #[cfg(feature = "extra_check")]
-    pub fn has_tail(&self) -> bool {
-        self.tail != 0
-    }
-
     #[inline]
     pub fn tail(&self) -> usize {
         self.tail
diff --git a/src/statement.rs b/src/statement.rs
@@ -672,7 +672,6 @@ impl Statement<'_> {
     #[cfg(feature = "extra_check")]
     #[inline]
     fn check_update(&self) -> Result<()> {
-        // sqlite3_column_count works for DML but not for DDL (ie ALTER)
         if self.column_count() > 0 && self.stmt.readonly() {
             return Err(Error::ExecuteReturnedResults);
         }
@@ -723,23 +722,6 @@ impl Statement<'_> {
         self.stmt.readonly()
     }
 
-    #[cfg(feature = "extra_check")]
-    #[inline]
-    pub(crate) fn check_no_tail(&self) -> Result<()> {
-        if self.stmt.has_tail() {
-            Err(Error::MultipleStatement)
-        } else {
-            Ok(())
-        }
-    }
-
-    #[cfg(not(feature = "extra_check"))]
-    #[inline]
-    #[expect(clippy::unnecessary_wraps)]
-    pub(crate) fn check_no_tail(&self) -> Result<()> {
-        Ok(())
-    }
-
     /// Safety: This is unsafe, because using `sqlite3_stmt` after the
     /// connection has closed is illegal, but `RawStatement` does not enforce
     /// this, as it loses our protective `'conn` lifetime bound.
