Fix: Improve SQLite type conversions and pool handling

cursoragent · lovasoa · cursoragent · commit 9ca44d6ca9d4 · 2025-09-16T12:57:21.000Z
Co-authored-by: contact &lt;contact@ophir.dev&gt;
diff --git a/sqlx-core/src/pool/inner.rs b/sqlx-core/src/pool/inner.rs
@@ -142,7 +142,8 @@ impl<DB: Database> PoolInner<DB> {
 
                 if parent_close_event.as_mut().poll(cx).is_ready() {
                     // Propagate the parent's close event to the child.
-                    let _ = self.close();
+                    let pool = Arc::clone(self);
+                    sqlx_rt::spawn(async move { let _ = pool.close().await; });
                     return Poll::Ready(Err(Error::PoolClosed));
                 }
 
@@ -197,7 +198,7 @@ impl<DB: Database> PoolInner<DB> {
 
         let Floating { inner: idle, guard } = floating.into_idle();
 
-        if !self.idle_conns.push(idle).is_ok() {
+        if self.idle_conns.push(idle).is_err() {
             panic!("BUG: connection queue overflow in release()");
         }
 
@@ -458,7 +459,7 @@ async fn check_idle_conn<DB: Database>(
 }
 
 fn spawn_maintenance_tasks<DB: Database>(pool: &Arc<PoolInner<DB>>) {
-    let pool = Arc::clone(&pool);
+    let pool = Arc::clone(pool);
 
     let period = match (pool.options.max_lifetime, pool.options.idle_timeout) {
         (Some(it), None) | (None, Some(it)) => it,
diff --git a/sqlx-core/src/sqlite/connection/explain.rs b/sqlx-core/src/sqlite/connection/explain.rs
@@ -364,14 +364,14 @@ pub(super) fn explain(
                 OP_INIT => {
                     // start at <p2>
                     state.visited[state.program_i] = true;
-                    state.program_i = p2 as usize;
+                    state.program_i = usize::try_from(p2).unwrap_or(0);
                     continue;
                 }
 
                 OP_GOTO => {
                     // goto <p2>
                     state.visited[state.program_i] = true;
-                    state.program_i = p2 as usize;
+                    state.program_i = usize::try_from(p2).unwrap_or(0);
                     continue;
                 }
 
@@ -388,7 +388,7 @@ pub(super) fn explain(
                     state.visited[state.program_i] = true;
 
                     let mut branch_state = state.clone();
-                    branch_state.program_i = p2 as usize;
+                    branch_state.program_i = usize::try_from(p2).unwrap_or(0);
                     states.push(branch_state);
 
                     state.program_i += 1;
@@ -401,7 +401,7 @@ pub(super) fn explain(
                     state.r.insert(p1, RegDataType::Int(p3));
 
                     if p2 != 0 {
-                        state.program_i = p2 as usize;
+                        state.program_i = usize::try_from(p2).unwrap_or(0);
                     } else {
                         state.program_i += 1;
                     }
@@ -413,10 +413,10 @@ pub(super) fn explain(
                     state.visited[state.program_i] = true;
                     if let Some(RegDataType::Int(yield_i)) = state.r.get(&p1) {
                         if let Some((_, yield_op, _, yield_p2, _, _)) =
-                            program.get(*yield_i as usize)
+                            program.get(usize::try_from(*yield_i).unwrap_or(0))
                         {
                             if OP_YIELD == yield_op.as_str() {
-                                state.program_i = (*yield_p2) as usize;
+                                state.program_i = usize::try_from(*yield_p2).unwrap_or(0);
                                 state.r.remove(&p1);
                                 continue;
                             } else {
@@ -434,7 +434,7 @@ pub(super) fn explain(
                     // jump to the instruction after the instruction pointed at by register p1
                     state.visited[state.program_i] = true;
                     if let Some(RegDataType::Int(return_i)) = state.r.get(&p1) {
-                        state.program_i = (*return_i + 1) as usize;
+                        state.program_i = usize::try_from(*return_i + 1).unwrap_or(0);
                         state.r.remove(&p1);
                         continue;
                     } else {
@@ -450,15 +450,15 @@ pub(super) fn explain(
 
                         //if yielding to a yield operation, go to the NEXT instruction after that instruction
                         if program
-                            .get(*yield_i as usize)
+                            .get(usize::try_from(*yield_i).unwrap_or(0))
                             .map(|(_, yield_op, _, _, _, _)| yield_op.as_str())
                             == Some(OP_YIELD)
                         {
-                            state.program_i = (*yield_i + 1) as usize;
+                            state.program_i = usize::try_from(*yield_i + 1).unwrap_or(0);
                             *yield_i = program_i as i64;
                             continue;
                         } else {
-                            state.program_i = *yield_i as usize;
+                            state.program_i = usize::try_from(*yield_i).unwrap_or(0);
                             *yield_i = program_i as i64;
                             continue;
                         }
@@ -472,15 +472,15 @@ pub(super) fn explain(
                     state.visited[state.program_i] = true;
 
                     let mut branch_state = state.clone();
-                    branch_state.program_i = p1 as usize;
+                    branch_state.program_i = usize::try_from(p1).unwrap_or(0);
                     states.push(branch_state);
 
                     let mut branch_state = state.clone();
-                    branch_state.program_i = p2 as usize;
+                    branch_state.program_i = usize::try_from(p2).unwrap_or(0);
                     states.push(branch_state);
 
                     let mut branch_state = state.clone();
-                    branch_state.program_i = p3 as usize;
+                    branch_state.program_i = usize::try_from(p3).unwrap_or(0);
                     states.push(branch_state);
                 }
 
@@ -515,7 +515,7 @@ pub(super) fn explain(
 
                 OP_MAKE_RECORD => {
                     // p3 = Record([p1 .. p1 + p2])
-                    let mut record = Vec::with_capacity(p2 as usize);
+                    let mut record = Vec::with_capacity(usize::try_from(p2).unwrap_or(0));
                     for reg in p1..p1 + p2 {
                         record.push(
                             state
@@ -565,7 +565,7 @@ pub(super) fn explain(
                     //Create a new pointer which is referenced by p1
                     state.p.insert(
                         p1,
-                        CursorDataType::from_dense_record(&vec![ColumnType::null(); p2 as usize]),
+                        CursorDataType::from_dense_record(&vec![ColumnType::null(); usize::try_from(p2).unwrap_or(0)]),
                     );
                 }
 
@@ -666,7 +666,7 @@ pub(super) fn explain(
                     state.r.insert(
                         p2,
                         RegDataType::Single(ColumnType {
-                            datatype: opcode_to_type(&opcode),
+                            datatype: opcode_to_type(opcode),
                             nullable: Some(false),
                         }),
                     );
diff --git a/sqlx-core/src/sqlite/statement/handle.rs b/sqlx-core/src/sqlite/statement/handle.rs
@@ -243,7 +243,7 @@ impl StatementHandle {
 
     #[inline]
     pub(crate) fn bind_null(&self, index: usize) -> c_int {
-        unsafe { sqlite3_bind_null(self.0.as_ptr(), index as c_int) }
+        unsafe { sqlite3_bind_null(self.0.as_ptr(), c_int::try_from(index).unwrap_or(c_int::MAX)) }
     }
 
     // result values from the query
diff --git a/sqlx-core/src/sqlite/types/float.rs b/sqlx-core/src/sqlite/types/float.rs
@@ -21,7 +21,13 @@ impl<'q> Encode<'q, Sqlite> for f32 {
 
 impl<'r> Decode<'r, Sqlite> for f32 {
     fn decode(value: SqliteValueRef<'r>) -> Result<f32, BoxDynError> {
-        Ok(value.double() as f32)
+        let dbl = value.double();
+        let clamped = if dbl.is_finite() {
+            dbl.clamp(f32::MIN as f64, f32::MAX as f64)
+        } else {
+            dbl
+        };
+        Ok(clamped as f32)
     }
 }
 
diff --git a/sqlx-core/src/sqlite/value.rs b/sqlx-core/src/sqlite/value.rs
@@ -126,7 +126,10 @@ impl SqliteValue {
     }
 
     fn blob(&self) -> &[u8] {
-        let len = unsafe { sqlite3_value_bytes(self.handle.0.as_ptr()) } as usize;
+        let len: usize = match usize::try_from(unsafe { sqlite3_value_bytes(self.handle.0.as_ptr()) }) {
+            Ok(v) => v,
+            Err(_) => return &[],
+        };
 
         if len == 0 {
             // empty blobs are NULL so just return an empty slice

Original file line number	Diff line number	Diff line change
`@@ -142,7 +142,8 @@ impl<DB: Database> PoolInner<DB> {`
`142`	`142`
`143`	`143`	`if parent_close_event.as_mut().poll(cx).is_ready() {`
`144`	`144`	`// Propagate the parent's close event to the child.`
`145`		`- let _ = self.close();`
	`145`	`+ let pool = Arc::clone(self);`
	`146`	`+ sqlx_rt::spawn(async move { let _ = pool.close().await; });`
`146`	`147`	`return Poll::Ready(Err(Error::PoolClosed));`
`147`	`148`	`}`
`148`	`149`
`@@ -197,7 +198,7 @@ impl<DB: Database> PoolInner<DB> {`
`197`	`198`
`198`	`199`	`let Floating { inner: idle, guard } = floating.into_idle();`
`199`	`200`
`200`		`- if !self.idle_conns.push(idle).is_ok() {`
	`201`	`+ if self.idle_conns.push(idle).is_err() {`
`201`	`202`	`panic!("BUG: connection queue overflow in release()");`
`202`	`203`	`}`
`203`	`204`
`@@ -458,7 +459,7 @@ async fn check_idle_conn<DB: Database>(`
`458`	`459`	`}`
`459`	`460`
`460`	`461`	`fn spawn_maintenance_tasks<DB: Database>(pool: &Arc<PoolInner<DB>>) {`
`461`		`- let pool = Arc::clone(&pool);`
	`462`	`+ let pool = Arc::clone(pool);`
`462`	`463`
`463`	`464`	`let period = match (pool.options.max_lifetime, pool.options.idle_timeout) {`
`464`	`465`	`(Some(it), None) \| (None, Some(it)) => it,`
Original file line number	Diff line number	Diff line change
`@@ -243,7 +243,7 @@ impl StatementHandle {`
`243`	`243`
`244`	`244`	`#[inline]`
`245`	`245`	`pub(crate) fn bind_null(&self, index: usize) -> c_int {`
`246`		`- unsafe { sqlite3_bind_null(self.0.as_ptr(), index as c_int) }`
	`246`	`+ unsafe { sqlite3_bind_null(self.0.as_ptr(), c_int::try_from(index).unwrap_or(c_int::MAX)) }`
`247`	`247`	`}`
`248`	`248`
`249`	`249`	`// result values from the query`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,13 @@ impl<'q> Encode<'q, Sqlite> for f32 {`
`21`	`21`
`22`	`22`	`impl<'r> Decode<'r, Sqlite> for f32 {`
`23`	`23`	`fn decode(value: SqliteValueRef<'r>) -> Result<f32, BoxDynError> {`
`24`		`- Ok(value.double() as f32)`
	`24`	`+ let dbl = value.double();`
	`25`	`+ let clamped = if dbl.is_finite() {`
	`26`	`+ dbl.clamp(f32::MIN as f64, f32::MAX as f64)`
	`27`	`+ } else {`
	`28`	`+ dbl`
	`29`	`+ };`
	`30`	`+ Ok(clamped as f32)`
`25`	`31`	`}`
`26`	`32`	`}`
`27`	`33`