refactor(sqlite): add check_cursor_valid method for cursor state validation

ever0de · ever0de · commit 89d1bdc45813 · 2025-12-08T17:02:35.000+09:00
Extract cursor validity check into a separate method that doesn't hold
the lock. This is useful for executescript which only needs to verify
the cursor state but doesn't need to modify CursorInner.

- Add check_cursor_valid() method that checks if cursor is initialized
  and not closed without retaining the mutex guard
- Use check_cursor_valid() in executescript instead of inner() since
  executescript doesn't modify CursorInner
diff --git a/crates/stdlib/src/sqlite.rs b/crates/stdlib/src/sqlite.rs
@@ -1589,24 +1589,41 @@ mod _sqlite {
             Ok(())
         }
 
-        fn inner(&self, vm: &VirtualMachine) -> PyResult<PyMappedMutexGuard<'_, CursorInner>> {
-            let guard = self.inner.lock();
-            if guard.is_some() {
-                let inner_guard =
-                    PyMutexGuard::map(guard, |x| unsafe { x.as_mut().unwrap_unchecked() });
-                if inner_guard.closed {
-                    return Err(new_programming_error(
-                        vm,
-                        "Cannot operate on a closed cursor.".to_owned(),
-                    ));
-                }
-                Ok(inner_guard)
-            } else {
-                Err(new_programming_error(
+        fn cursor_state_error(
+            inner: Option<&CursorInner>,
+            vm: &VirtualMachine,
+        ) -> Option<PyBaseExceptionRef> {
+            match inner {
+                Some(inner) if inner.closed => Some(new_programming_error(
+                    vm,
+                    "Cannot operate on a closed cursor.".to_owned(),
+                )),
+                Some(_) => None,
+                None => Some(new_programming_error(
                     vm,
                     "Base Cursor.__init__ not called.".to_owned(),
-                ))
+                )),
+            }
+        }
+
+        fn inner(&self, vm: &VirtualMachine) -> PyResult<PyMappedMutexGuard<'_, CursorInner>> {
+            let guard = self.inner.lock();
+            if let Some(err) = Self::cursor_state_error(guard.as_ref(), vm) {
+                return Err(err);
             }
+            Ok(PyMutexGuard::map(guard, |x| unsafe {
+                x.as_mut().unwrap_unchecked()
+            }))
+        }
+
+        /// Check if cursor is valid without holding the lock.
+        /// Use this when you only need to verify the cursor state but don't need to modify it.
+        fn check_cursor_valid(&self, vm: &VirtualMachine) -> PyResult<()> {
+            let guard = self.inner.lock();
+            if let Some(err) = Self::cursor_state_error(guard.as_ref(), vm) {
+                return Err(err);
+            }
+            Ok(())
         }
 
         #[pymethod]
@@ -1771,7 +1788,7 @@ mod _sqlite {
             script: PyUtf8StrRef,
             vm: &VirtualMachine,
         ) -> PyResult<PyRef<Self>> {
-            let _ = zelf.clone().inner(vm)?;
+            zelf.check_cursor_valid(vm)?;
 
             let db = zelf.connection.db_lock(vm)?;
 
