add resultset and finalise statements

 - ResultSet as a GC-safe, enumerable hybrid result set. ...exposed changes() for same reason
 - fix ruby exception maps

Author: Pavan-Nambi

bindings/ruby/ext/turso/src/connection.rs

@@ -1,10 +1,11 @@
+use magnus::value::ReprValue;
 use magnus::{block::Proc, method, Error, Module, Ruby, TryConvert, Value};
 use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::Arc;
 use turso_sdk_kit::rsapi::{TursoConnection, TursoStatusCode};
 
 use crate::errors::map_turso_error;
-use crate::statement::{RbExecutionResult, RbStatement};
+use crate::statement::{RbResultSet, RbStatement};
 use crate::value;
 
 #[magnus::wrap(class = "Turso::Connection", free_immediately, size)]
@@ -41,7 +42,7 @@ impl RbConnection {
         Ok(RbStatement::new(stmt))
     }
 
-    pub fn execute(&self, args: &[Value]) -> Result<RbExecutionResult, Error> {
+    pub fn execute(&self, args: &[Value]) -> Result<RbResultSet, Error> {
         self.ensure_open()?;
 
         if args.is_empty() {
@@ -59,8 +60,25 @@ impl RbConnection {
             value::bind_value(&mut stmt, i + 1, *arg)?;
         }
 
-        let result = stmt.execute().map_err(map_turso_error)?;
-        Ok(RbExecutionResult::from_rsapi(result.rows_changed))
+        let mut rows: Vec<Value> = Vec::new();
+        loop {
+            match stmt.step().map_err(map_turso_error)? {
+                TursoStatusCode::Row => {
+                    rows.push(value::extract_row(&stmt)?.as_value());
+                }
+                TursoStatusCode::Done => break,
+                TursoStatusCode::Io => {
+                    stmt.run_io().map_err(map_turso_error)?;
+                }
+                _ => break,
+            }
+        }
+
+        let changes = self.inner.changes();
+        stmt.finalize().map_err(map_turso_error)?;
+        self.last_changes.store(changes, Ordering::Relaxed);
+
+        Ok(RbResultSet::new(rows, changes))
     }
 
     pub fn transaction(&self, block: Proc) -> Result<Value, Error> {

bindings/ruby/ext/turso/src/errors.rs

@@ -1,9 +1,9 @@
-use magnus::{exception::ExceptionClass, Error, Module, Ruby};
-use std::cell::RefCell;
+use magnus::{exception::ExceptionClass, Class, Error, Module, Ruby};
+
 use turso_sdk_kit::rsapi::{TursoError, TursoStatusCode};
 
 pub fn define_exceptions(ruby: &Ruby, module: &impl Module) -> Result<(), Error> {
-    let error = module.define_class("Error", ruby.exception_standard_error())?;
+    let error = module.define_class("Error", ruby.exception_standard_error().as_r_class())?;
     module.define_class("BusyError", error)?;
     module.define_class("InterruptError", error)?;
     module.define_class("MisuseError", error)?;

bindings/ruby/ext/turso/src/statement.rs

@@ -1,25 +1,59 @@
-use magnus::prelude::*;
-use magnus::{method, Error, Module, RArray, Ruby, Value};
+use magnus::value::ReprValue;
+use magnus::{method, DataTypeFunctions, Error, Module, Ruby, TryConvert, TypedData, Value};
 use std::cell::RefCell;
 use std::sync::atomic::{AtomicBool, Ordering};
 use turso_sdk_kit::rsapi::{TursoStatement, TursoStatusCode};
 
 use crate::errors::{map_turso_error, statement_closed_error};
 use crate::value;
 
-#[magnus::wrap(class = "Turso::ExecutionResult", free_immediately, size)]
-pub struct RbExecutionResult {
+/// ResultSet containing query results and execution metadata.
+/// Implements `Enumerable`, so you can use `.each`, `.map`, `.select`, etc.
+#[derive(TypedData)]
+#[magnus(class = "Turso::ResultSet", mark, size)]
+pub struct RbResultSet {
+    rows: Vec<Value>,
     rows_changed: u64,
 }
 
-impl RbExecutionResult {
-    pub(crate) fn from_rsapi(rows_changed: u64) -> Self {
-        Self { rows_changed }
+
+unsafe impl Send for RbResultSet {}
+unsafe impl Sync for RbResultSet {}
+
+impl RbResultSet {
+    pub(crate) fn new(rows: Vec<Value>, rows_changed: u64) -> Self {
+        Self { rows, rows_changed }
     }
 
     pub fn rows_changed(&self) -> u64 {
         self.rows_changed
     }
+
+    pub fn each(
+        ruby: &Ruby,
+        rb_self: Value,
+    ) -> Result<magnus::block::Yield<impl Iterator<Item = Value>>, Error> {
+        let this: &Self = TryConvert::try_convert(rb_self)?;
+        if ruby.block_given() {
+            Ok(magnus::block::Yield::Iter(this.rows.iter().copied()))
+        } else {
+            Ok(magnus::block::Yield::Enumerator(
+                rb_self.enumeratorize("each", ()),
+            ))
+        }
+    }
+}
+
+impl DataTypeFunctions for RbResultSet {
+    fn mark(&self, marker: &magnus::gc::Marker) {
+        for row in &self.rows {
+            marker.mark(*row);
+        }
+    }
+
+    fn size(&self) -> usize {
+        std::mem::size_of::<Self>() + self.rows.len() * std::mem::size_of::<Value>()
+    }
 }
 
 #[magnus::wrap(class = "Turso::Statement", free_immediately, size)]
@@ -68,17 +102,31 @@ impl RbStatement {
         }
     }
 
-    pub fn execute(&self, args: &[Value]) -> Result<RbExecutionResult, Error> {
+    pub fn execute(&self, args: &[Value]) -> Result<RbResultSet, Error> {
         self.ensure_open()?;
         self.bind(args)?;
 
-        let result = self.inner.borrow_mut().execute().map_err(map_turso_error)?;
-        Ok(RbExecutionResult {
-            rows_changed: result.rows_changed,
-        })
+        let mut stmt = self.inner.borrow_mut();
+        let mut rows: Vec<Value> = Vec::new();
+        loop {
+            match stmt.step().map_err(map_turso_error)? {
+                TursoStatusCode::Row => {
+                    rows.push(value::extract_row(&stmt)?.as_value());
+                }
+                TursoStatusCode::Done => break,
+                TursoStatusCode::Io => {
+                    stmt.run_io().map_err(map_turso_error)?;
+                }
+                _ => break,
+            }
+        }
+        let changes = stmt.n_change();
+        stmt.reset().map_err(map_turso_error)?;
+
+        Ok(RbResultSet::new(rows, changes))
     }
 
-    pub fn columns(&self) -> Result<RArray, Error> {
+    pub fn columns(&self) -> Result<magnus::RArray, Error> {
         self.ensure_open()?;
         let ruby = Ruby::get().expect("Ruby not initialized");
         let stmt = self.inner.borrow();
@@ -124,9 +172,17 @@ impl Drop for RbStatement {
     }
 }
 
+pub fn define_result_set(ruby: &Ruby, module: &impl Module) -> Result<(), Error> {
+    let class = module.define_class("ResultSet", ruby.class_object())?;
+    class.include_module(ruby.module_enumerable())?;
+    class.define_method("rows_changed", method!(RbResultSet::rows_changed, 0))?;
+    class.define_method("each", method!(RbResultSet::each, 0))?;
+    Ok(())
+}
+
+
 pub fn define_statement(ruby: &Ruby, module: &impl Module) -> Result<(), Error> {
-    let result_class = module.define_class("ExecutionResult", ruby.class_object())?;
-    result_class.define_method("rows_changed", method!(RbExecutionResult::rows_changed, 0))?;
+    define_result_set(ruby, module)?;
 
     let class = module.define_class("Statement", ruby.class_object())?;
     class.define_method("bind", method!(RbStatement::bind, -1))?;

sdk-kit/src/rsapi.rs

@@ -589,6 +589,9 @@ impl TursoConnection {
     pub fn last_insert_rowid(&self) -> i64 {
         self.connection.last_insert_rowid()
     }
+    pub fn changes(&self) -> u64 {
+        self.connection.changes() as u64
+    }
     /// prepares single SQL statement
     pub fn prepare_single(&self, sql: impl AsRef<str>) -> Result<Box<TursoStatement>, TursoError> {
         match self.connection.prepare(sql) {
@@ -679,6 +682,10 @@ impl TursoStatement {
     pub fn parameters_count(&self) -> usize {
         self.statement.parameters_count()
     }
+    /// returns number of changes made by the statement
+    pub fn n_change(&self) -> u64 {
+        self.statement.n_change() as u64
+    }
     /// binds positional parameter at the corresponding index (1-based)
     pub fn bind_positional(
         &mut self,