HACKS

Author: penberg

index.d.ts

@@ -51,6 +51,6 @@ export declare class RowsIterator {
   next(): Record
 }
 export declare class Record {
-  get value(): unknown | null
+  get value(): unknown
   get done(): boolean
 }

perf/package.json

@@ -3,7 +3,7 @@
   "type": "module",
   "private": true,
   "dependencies": {
-    "better-sqlite3": "^9.5.0",
+    "better-sqlite3": "^11.10.0",
     "libsql": "..",
     "mitata": "^0.1.11"
   }

src/lib.rs

@@ -597,10 +597,14 @@ impl Statement {
             let rows = stmt.lock().await.query(params).await.map_err(Error::from)?;
             Ok::<_, napi::Error>(rows)
         };
-        env.execute_tokio_future(future, move |&mut env, result| {
+        env.execute_tokio_future(future, move |&mut _env, result| {
+            let mut column_names = vec![];
+            for i in 0..result.column_count() {
+                column_names.push(result.column_name(i).unwrap().to_string());
+            }
             let iter = RowsIterator::new(
-                env,
                 Arc::new(tokio::sync::Mutex::new(result)),
+                column_names,
                 safe_ints,
                 raw,
                 pluck,
@@ -628,12 +632,16 @@ impl Statement {
                 params
             };
             let rows = stmt.query(params).await.map_err(Error::from)?;
-            Ok::<_, napi::Error>(rows)
+            let mut column_names = vec![];  
+            for i in 0..rows.column_count() {
+                column_names.push(rows.column_name(i).unwrap().to_string());
+            }
+            Ok::<_, napi::Error>((rows, column_names))
         };
-        let rows = rt.block_on(future)?;
+        let (rows, column_names) = rt.block_on(future)?;
         let iter = RowsIterator::new(
-            env,
             Arc::new(tokio::sync::Mutex::new(rows)),
+            column_names,
             safe_ints,
             raw,
             pluck,
@@ -715,15 +723,19 @@ impl Statement {
                 libsql::params::Params::None
             };
             let mut rows = stmt.query(params).await.map_err(Error::from)?;
+            let mut column_names = vec![];
+            for i in 0..rows.column_count() {
+                column_names.push(rows.column_name(i).unwrap().to_string());
+            }
             let row = rows.next().await.map_err(Error::from)?;
             let duration = start.elapsed().as_secs_f64();
             let result = match row {
                 Some(row) => {
                     if raw {
-                        let js_array = map_row_raw(&env, &rows, &row, safe_ints, pluck)?;
+                        let js_array = map_row_raw(&env, &column_names, &row, safe_ints, pluck)?;
                         Ok(js_array.into_unknown())
                     } else {
-                        let mut js_object = map_row_object(&env, &rows, &row, safe_ints, pluck)?
+                        let mut js_object = map_row_object(&env, &column_names, &row, safe_ints, pluck)?
                             .coerce_to_object()?;
                         let mut metadata = env.create_object()?;
                         let js_duration = env.create_double(duration)?;
@@ -764,6 +776,7 @@ impl Statement {
 #[napi]
 pub struct RowsIterator {
     rows: Arc<tokio::sync::Mutex<libsql::Rows>>,
+    column_names: Vec<String>,
     safe_ints: bool,
     raw: bool,
     pluck: bool,
@@ -772,14 +785,15 @@ pub struct RowsIterator {
 #[napi]
 impl RowsIterator {
     pub fn new(
-        env: Env,
         rows: Arc<tokio::sync::Mutex<libsql::Rows>>,
+        column_names: Vec<String>,
         safe_ints: bool,
         raw: bool,
         pluck: bool,
     ) -> Result<Self> {
         let iter = RowsIterator {
             rows,
+            column_names,
             safe_ints,
             raw,
             pluck,
@@ -796,14 +810,14 @@ impl RowsIterator {
             let next_row = rows.next().await.map_err(Error::from)?;
             let record = match next_row {
                 Some(row) => Record {
-                    rows: self.rows.clone(),
+                    column_names: self.column_names.clone(),
                     row: Some(row),
                     safe_ints: self.safe_ints,
                     raw: self.raw,
                     pluck: self.pluck,
                 },
                 None => Record {
-                    rows: self.rows.clone(),
+                    column_names: self.column_names.clone(),
                     row: None,
                     safe_ints: self.safe_ints,
                     raw: self.raw,
@@ -817,7 +831,7 @@ impl RowsIterator {
 
 #[napi]
 pub struct Record {
-    rows: Arc<tokio::sync::Mutex<libsql::Rows>>,
+    column_names: Vec<String>,
     row: Option<libsql::Row>,
     safe_ints: bool,
     raw: bool,
@@ -827,19 +841,11 @@ pub struct Record {
 #[napi]
 impl Record {
     #[napi(getter)]
-    pub fn value(&self, env: Env) -> Option<napi::JsUnknown> {
+    pub fn value(&self, env: Env) -> napi::Result<napi::JsUnknown> {
         if let Some(row) = &self.row {
-            let rt = runtime().unwrap();
-            let rows = self.rows.clone();
-            let value = rt
-                .block_on(async move {
-                    let rows = rows.lock().await;
-                    map_row(&env, &rows, &row, self.safe_ints, self.raw, self.pluck)
-                })
-                .unwrap();
-            Some(value)
+            Ok(map_row(&env, &self.column_names, &row, self.safe_ints, self.raw, self.pluck)?)
         } else {
-            None
+            Ok(env.get_null()?.into_unknown())
         }
     }
 
@@ -858,16 +864,16 @@ fn runtime() -> Result<&'static Runtime> {
 
 fn map_row(
     env: &Env,
-    rows: &libsql::Rows,
+    column_names: &[String],
     row: &libsql::Row,
     safe_ints: bool,
     raw: bool,
     pluck: bool,
 ) -> Result<napi::JsUnknown> {
     let result = if raw {
-        map_row_raw(env, rows, row, safe_ints, pluck)?
+        map_row_raw(env, column_names, row, safe_ints, pluck)?
     } else {
-        map_row_object(env, rows, row, safe_ints, pluck)?.into_unknown()
+        map_row_object(env, column_names, row, safe_ints, pluck)?.into_unknown()
     };
     Ok(result)
 }
@@ -894,12 +900,12 @@ fn convert_value_to_js(
 
 fn map_row_object(
     env: &Env,
-    rows: &libsql::Rows,
+    column_names: &[String],
     row: &libsql::Row,
     safe_ints: bool,
     pluck: bool,
 ) -> Result<napi::JsUnknown> {
-    let column_count = rows.column_count();
+    let column_count = column_names.len();
 
     let result = if pluck {
         if column_count > 0 {
@@ -915,12 +921,12 @@ fn map_row_object(
         let mut result = env.create_object()?;
         // If not plucking, get all columns
         for idx in 0..column_count {
-            let value = match row.get_value(idx) {
+            let value = match row.get_value(idx as i32) {
                 Ok(v) => v,
                 Err(e) => return Err(napi::Error::from_reason(e.to_string())),
             };
 
-            let column_name = rows.column_name(idx).unwrap();
+            let column_name = column_names[idx].as_str();
             let js_value = convert_value_to_js(env, &value, safe_ints)?;
             result.set_named_property(column_name, js_value)?;
         }
@@ -931,16 +937,16 @@ fn map_row_object(
 
 fn map_row_raw(
     env: &Env,
-    rows: &libsql::Rows,
+    column_names: &[String],
     row: &libsql::Row,
     safe_ints: bool,
     pluck: bool,
 ) -> Result<napi::JsUnknown> {
-    let column_count = rows.column_count();
+    let column_count = column_names.len();
     let mut js_array = env.create_array(column_count as u32)?;
 
     for idx in 0..column_count {
-        let value = match row.get_value(idx) {
+        let value = match row.get_value(idx as i32) {
             Ok(v) => v,
             Err(e) => return Err(napi::Error::from_reason(e.to_string())),
         };