chore: codefmt

Author: KKould

.gitignore

@@ -16,8 +16,7 @@ target/
 /.obsidian
 .DS_Store
 
-/hello_world
-/transaction
+/example_data
 
 kitesql_data
 kitesql_bench

examples/hello_world.rs

@@ -28,7 +28,7 @@ implement_from_tuple!(
 
 #[cfg(feature = "macros")]
 fn main() -> Result<(), DatabaseError> {
-    let database = DataBaseBuilder::path("./hello_world").build()?;
+    let database = DataBaseBuilder::path("./example_data/hello_world").build()?;
 
     // 1) Create table and insert multiple rows with mixed types.
     database

examples/transaction.rs

@@ -2,24 +2,34 @@
 
 use kite_sql::db::{DataBaseBuilder, ResultIter};
 use kite_sql::errors::DatabaseError;
+use kite_sql::types::tuple::Tuple;
+use kite_sql::types::value::DataValue;
 
 fn main() -> Result<(), DatabaseError> {
-    let database = DataBaseBuilder::path("./transaction").build_optimistic()?;
-    let mut transaction = database.new_transaction()?;
-
-    // Scenario: create table and insert rows inside a transaction; visible after commit.
-    transaction
+    let database = DataBaseBuilder::path("./example_data/transaction").build_optimistic()?;
+    database
         .run("create table if not exists t1 (c1 int primary key, c2 int)")?
         .done()?;
+    let mut transaction = database.new_transaction()?;
+
     transaction
         .run("insert into t1 values(0, 0), (1, 1)")?
         .done()?;
 
-    assert!(database.run("select * from t1").is_err());
+    assert!(database.run("select * from t1")?.next().is_none());
 
     transaction.commit()?;
 
-    assert!(database.run("select * from t1").is_ok());
+    let mut iter = database.run("select * from t1")?;
+    assert_eq!(
+        iter.next().unwrap()?,
+        Tuple::new(None, vec![DataValue::Int32(0), DataValue::Int32(0)])
+    );
+    assert_eq!(
+        iter.next().unwrap()?,
+        Tuple::new(None, vec![DataValue::Int32(1), DataValue::Int32(1)])
+    );
+    assert!(iter.next().is_none());
 
     // Scenario: another transaction updates but does not commit; changes stay invisible.
     let mut tx2 = database.new_transaction()?;

examples/wasm_index_usage.test.mjs

@@ -1,7 +1,6 @@
 // Verify index usage in wasm build: create table, build indexes, analyze, and query with filters.
 import assert from "node:assert/strict";
 import { createRequire } from "module";
-import fs from "node:fs";
 
 // Minimal localStorage polyfill for wasm code paths (statistics persistence).
 class LocalStorage {
@@ -36,22 +35,18 @@ global.window = windowShim;
 const require = createRequire(import.meta.url);
 const { WasmDatabase } = require("../pkg/kite_sql.js");
 
-// Load the shared test dataset for richer coverage.
-function loadTestData() {
-  const csvPath = new URL("../tests/data/row_20000.csv", import.meta.url);
-  return fs.readFileSync(csvPath, "utf8").trim();
-}
-
 async function main() {
   const db = new WasmDatabase();
 
   await db.execute("drop table if exists t1");
   await db.execute("create table t1(id int primary key, c1 int, c2 int)");
 
-  // Insert data in bulk
-  const data = loadTestData();
-  for (const line of data.split("\n")) {
-    const [id, c1, c2] = line.split("|").map((v) => parseInt(v, 10));
+  // Insert data in bulk (20k rows) without reading from disk.
+  // Each row matches the old CSV pattern: id = i*3, c1 = i*3+1, c2 = i*3+2.
+  for (let i = 0; i < 20_000; i += 1) {
+    const id = i * 3;
+    const c1 = id + 1;
+    const c2 = id + 2;
     await db.execute(`insert into t1 values(${id}, ${c1}, ${c2})`);
   }
 

src/db.rs

@@ -103,7 +103,6 @@ impl DataBaseBuilder {
         Self::_build::<RocksStorage>(storage, self.scala_functions, self.table_functions)
     }
 
-    #[cfg(not(target_arch = "wasm32"))]
     pub fn build_in_memory(self) -> Result<Database<MemoryStorage>, DatabaseError> {
         let storage = MemoryStorage::new();
 

src/storage/memory.rs

@@ -99,23 +99,153 @@ impl Transaction for MemoryTransaction {
     }
 }
 
-#[cfg(test)]
-mod test {
+#[cfg(all(test, target_arch = "wasm32"))]
+mod wasm_tests {
+    use super::*;
+    use crate::catalog::{ColumnCatalog, ColumnDesc, ColumnRef, TableName};
+    use crate::db::{DataBaseBuilder, ResultIter};
+    use crate::expression::range_detacher::Range;
     use crate::storage::Iter;
+    use crate::types::tuple::Tuple;
+    use crate::types::value::DataValue;
+    use crate::types::LogicalType;
+    use crate::utils::lru::SharedLruCache;
+    use itertools::Itertools;
     use std::collections::{BTreeMap, Bound};
     use std::hash::RandomState;
     use std::sync::Arc;
-    use itertools::Itertools;
+    use wasm_bindgen_test::*;
+
+    #[wasm_bindgen_test]
+    fn memory_storage_roundtrip() -> Result<(), DatabaseError> {
+        let storage = MemoryStorage::new();
+        let mut transaction = storage.transaction()?;
+        let table_cache = Arc::new(SharedLruCache::new(4, 1, RandomState::new())?);
+        let columns = Arc::new(vec![
+            ColumnRef::from(ColumnCatalog::new(
+                "c1".to_string(),
+                false,
+                ColumnDesc::new(LogicalType::Integer, Some(0), false, None).unwrap(),
+            )),
+            ColumnRef::from(ColumnCatalog::new(
+                "c2".to_string(),
+                false,
+                ColumnDesc::new(LogicalType::Boolean, None, false, None).unwrap(),
+            )),
+        ]);
+
+        let source_columns = columns
+            .iter()
+            .map(|col_ref| ColumnCatalog::clone(col_ref))
+            .collect_vec();
+        transaction.create_table(
+            &table_cache,
+            "test".to_string().into(),
+            source_columns,
+            false,
+        )?;
+
+        transaction.append_tuple(
+            &"test".to_string(),
+            Tuple::new(
+                Some(DataValue::Int32(1)),
+                vec![DataValue::Int32(1), DataValue::Boolean(true)],
+            ),
+            &[
+                LogicalType::Integer.serializable(),
+                LogicalType::Boolean.serializable(),
+            ],
+            false,
+        )?;
+        transaction.append_tuple(
+            &"test".to_string(),
+            Tuple::new(
+                Some(DataValue::Int32(2)),
+                vec![DataValue::Int32(2), DataValue::Boolean(true)],
+            ),
+            &[
+                LogicalType::Integer.serializable(),
+                LogicalType::Boolean.serializable(),
+            ],
+            false,
+        )?;
+
+        let mut read_columns = BTreeMap::new();
+        read_columns.insert(0, columns[0].clone());
+
+        let mut iter = transaction.read(
+            &table_cache,
+            "test".to_string().into(),
+            (Some(1), Some(1)),
+            read_columns,
+            true,
+        )?;
+
+        let option_1 = iter.next_tuple()?;
+        assert_eq!(option_1.unwrap().pk, Some(DataValue::Int32(2)));
+
+        let option_2 = iter.next_tuple()?;
+        assert_eq!(option_2, None);
+
+        Ok(())
+    }
+
+    #[wasm_bindgen_test]
+    fn memory_storage_read_by_index() -> Result<(), DatabaseError> {
+        let kite_sql = DataBaseBuilder::path("./memory").build_in_memory()?;
+        kite_sql
+            .run("create table t1 (a int primary key, b int)")?
+            .done()?;
+        kite_sql
+            .run("insert into t1 (a, b) values (0, 0), (1, 1), (2, 2), (3, 4)")?
+            .done()?;
+
+        let transaction = kite_sql.storage.transaction()?;
+        let table_name: TableName = "t1".to_string().into();
+        let table = transaction
+            .table(kite_sql.state.table_cache(), table_name.clone())?
+            .unwrap()
+            .clone();
+        let pk_index = table.indexes().next().unwrap().clone();
+        let mut iter = transaction.read_by_index(
+            kite_sql.state.table_cache(),
+            table_name,
+            (Some(0), None),
+            table.columns().cloned().enumerate().collect(),
+            pk_index,
+            vec![Range::Scope {
+                min: Bound::Excluded(DataValue::Int32(0)),
+                max: Bound::Included(DataValue::Int32(2)),
+            }],
+            true,
+        )?;
+
+        let mut result = Vec::new();
+        while let Some(tuple) = iter.next_tuple()? {
+            result.push(tuple.pk.unwrap());
+        }
+
+        assert_eq!(result, vec![DataValue::Int32(1), DataValue::Int32(2)]);
+
+        Ok(())
+    }
+}
+
+#[cfg(all(test, not(target_arch = "wasm32")))]
+mod native_tests {
+    use super::*;
     use crate::catalog::{ColumnCatalog, ColumnDesc, ColumnRef, TableName};
     use crate::db::{DataBaseBuilder, ResultIter};
-    use crate::errors::DatabaseError;
     use crate::expression::range_detacher::Range;
-    use crate::storage::memory::MemoryStorage;
-    use crate::storage::{Storage, Transaction};
-    use crate::types::LogicalType;
+    use crate::storage::Iter;
     use crate::types::tuple::Tuple;
     use crate::types::value::DataValue;
+    use crate::types::LogicalType;
     use crate::utils::lru::SharedLruCache;
+    use itertools::Itertools;
+    use std::collections::{BTreeMap, Bound};
+    use std::hash::RandomState;
+    use std::sync::Arc;
 
     #[test]
     fn memory_storage_roundtrip() -> Result<(), DatabaseError> {
@@ -139,7 +269,12 @@ mod test {
             .iter()
             .map(|col_ref| ColumnCatalog::clone(col_ref))
             .collect_vec();
-        transaction.create_table(&table_cache, "test".to_string().into(), source_columns, false)?;
+        transaction.create_table(
+            &table_cache,
+            "test".to_string().into(),
+            source_columns,
+            false,
+        )?;
 
         transaction.append_tuple(
             &"test".to_string(),
@@ -221,10 +356,7 @@ mod test {
             result.push(tuple.pk.unwrap());
         }
 
-        assert_eq!(
-            result,
-            vec![DataValue::Int32(1), DataValue::Int32(2)]
-        );
+        assert_eq!(result, vec![DataValue::Int32(1), DataValue::Int32(2)]);
 
         Ok(())
     }