lancelot 0.3.4 → 0.4.0

data/ext/lancelot/src/dataset.rs

@@ -1,4 +1,4 @@
-use magnus::{Error, Ruby, RHash, RArray, Symbol, TryConvert, Value, function, method, RClass, Module, Object};
+use magnus::{Error, Ruby, RHash, RArray, Value, function, method, RClass, Module, Object};
 use std::cell::RefCell;
 use std::sync::Arc;
 use tokio::runtime::Runtime;
@@ -41,9 +41,10 @@ pub struct LancelotDataset {
 
 impl LancelotDataset {
     pub fn new(path: String) -> Result<Self, Error> {
+        let ruby = Ruby::get().unwrap();
         let runtime = Runtime::new()
-            .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
-        
+            .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+
         Ok(Self {
             dataset: RefCell::new(None),
             runtime: RefCell::new(runtime),
@@ -56,15 +57,16 @@ impl LancelotDataset {
     }
 
     pub fn create(&self, schema_hash: RHash) -> Result<(), Error> {
-        let schema = build_arrow_schema(schema_hash)?;
-        
+        let ruby = Ruby::get().unwrap();
+        let schema = build_arrow_schema(&ruby, schema_hash)?;
+
         let empty_batch = RecordBatch::new_empty(Arc::new(schema.clone()));
         let batches = vec![empty_batch];
         let reader = RecordBatchIterator::new(
             batches.into_iter().map(Ok),
             Arc::new(schema)
         );
-        
+
         let dataset = self.runtime.borrow_mut().block_on(async {
             Dataset::write(
                 reader,
@@ -72,7 +74,7 @@ impl LancelotDataset {
                 None,
             )
             .await
-            .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))
+            .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))
         })?;
 
         self.dataset.replace(Some(dataset));
@@ -80,10 +82,11 @@ impl LancelotDataset {
     }
 
     pub fn open(&self) -> Result<(), Error> {
+        let ruby = Ruby::get().unwrap();
         let dataset = self.runtime.borrow_mut().block_on(async {
             Dataset::open(&self.path)
                 .await
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))
         })?;
 
         self.dataset.replace(Some(dataset));
@@ -91,9 +94,10 @@ impl LancelotDataset {
     }
 
     pub fn add_data(&self, data: RArray) -> Result<(), Error> {
+        let ruby = Ruby::get().unwrap();
         let mut dataset = self.dataset.borrow_mut();
         let dataset = dataset.as_mut()
-            .ok_or_else(|| Error::new(magnus::exception::runtime_error(), "Dataset not opened"))?;
+            .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "Dataset not opened"))?;
 
         // Check if data is empty
         if data.len() == 0 {
@@ -104,74 +108,75 @@ impl LancelotDataset {
         let schema = self.runtime.borrow_mut().block_on(async {
             dataset.schema()
         });
-        
+
         // Convert Lance schema to Arrow schema
         let arrow_schema = schema.into();
 
-        let batch = build_record_batch(data, &arrow_schema)?;
+        let batch = build_record_batch(&ruby, data, &arrow_schema)?;
 
         let batches = vec![batch];
         let reader = RecordBatchIterator::new(
             batches.into_iter().map(Ok),
             Arc::new(arrow_schema)
         );
-        
+
         self.runtime.borrow_mut().block_on(async move {
             dataset.append(reader, None)
                 .await
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))
         })?;
 
         Ok(())
     }
 
     pub fn count_rows(&self) -> Result<i64, Error> {
+        let ruby = Ruby::get().unwrap();
         let dataset = self.dataset.borrow();
         let dataset = dataset.as_ref()
-            .ok_or_else(|| Error::new(magnus::exception::runtime_error(), "Dataset not opened"))?;
+            .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "Dataset not opened"))?;
 
         let count = self.runtime.borrow_mut().block_on(async {
             dataset.count_rows(None)
                 .await
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))
         })?;
 
         Ok(count as i64)
     }
 
     pub fn schema(&self) -> Result<RHash, Error> {
+        let ruby = Ruby::get().unwrap();
         let dataset = self.dataset.borrow();
         let dataset = dataset.as_ref()
-            .ok_or_else(|| Error::new(magnus::exception::runtime_error(), "Dataset not opened"))?;
+            .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "Dataset not opened"))?;
 
         // Get the actual schema from the Lance dataset
         let schema = self.runtime.borrow_mut().block_on(async {
             dataset.schema()
         });
-        
+
         // Convert Lance schema to Arrow schema
         let arrow_schema: arrow_schema::Schema = schema.into();
         let arrow_schema = Arc::new(arrow_schema);
 
-        let ruby = Ruby::get().unwrap();
         let hash = ruby.hash_new();
-        
+
         // Iterate over Arrow schema fields
         for field in arrow_schema.fields() {
-            let field_name = Symbol::new(&field.name());
-            
+            let field_name = ruby.to_symbol(field.name());
+
             // Handle vector columns specially
             if let DataType::FixedSizeList(inner_field, dimension) = field.data_type() {
                 // Check if it's a vector (float list)
                 if matches!(inner_field.data_type(), DataType::Float32 | DataType::Float16) {
                     let vector_info = ruby.hash_new();
-                    vector_info.aset(Symbol::new("type"), "vector")?;
-                    vector_info.aset(Symbol::new("dimension"), *dimension)?;
+                    vector_info.aset(ruby.to_symbol("type"), "vector")?;
+                    vector_info.aset(ruby.to_symbol("dimension"), *dimension)?;
                     hash.aset(field_name, vector_info)?;
                     continue;
                 }
             }
-            
+
             let field_type = datatype_to_ruby_string(field.data_type());
             hash.aset(field_name, field_type)?;
         }
@@ -180,28 +185,28 @@ impl LancelotDataset {
     }
 
     pub fn scan_all(&self) -> Result<RArray, Error> {
+        let ruby = Ruby::get().unwrap();
         let dataset = self.dataset.borrow();
         let dataset = dataset.as_ref()
-            .ok_or_else(|| Error::new(magnus::exception::runtime_error(), "Dataset not opened"))?;
+            .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "Dataset not opened"))?;
 
         let batches: Vec<RecordBatch> = self.runtime.borrow_mut().block_on(async {
             let scanner = dataset.scan();
             let stream = scanner
                 .try_into_stream()
                 .await
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
-            
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+
             stream
                 .try_collect::<Vec<_>>()
                 .await
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))
         })?;
 
-        let ruby = Ruby::get().unwrap();
         let result_array = ruby.ary_new();
 
         for batch in batches {
-            let batch_docs = convert_batch_to_ruby(&batch)?;
+            let batch_docs = convert_batch_to_ruby(&ruby, &batch)?;
             // Merge arrays by pushing each element
             for i in 0..batch_docs.len() {
                 result_array.push(batch_docs.entry::<Value>(i as isize)?)?;
@@ -212,31 +217,31 @@ impl LancelotDataset {
     }
 
     pub fn scan_limit(&self, limit: i64) -> Result<RArray, Error> {
+        let ruby = Ruby::get().unwrap();
         let dataset = self.dataset.borrow();
         let dataset = dataset.as_ref()
-            .ok_or_else(|| Error::new(magnus::exception::runtime_error(), "Dataset not opened"))?;
+            .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "Dataset not opened"))?;
 
         let batches: Vec<RecordBatch> = self.runtime.borrow_mut().block_on(async {
             let mut scanner = dataset.scan();
             scanner.limit(Some(limit), None)
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
-            
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+
             let stream = scanner
                 .try_into_stream()
                 .await
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
-            
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+
             stream
                 .try_collect::<Vec<_>>()
                 .await
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))
         })?;
 
-        let ruby = Ruby::get().unwrap();
         let result_array = ruby.ary_new();
 
         for batch in batches {
-            let batch_docs = convert_batch_to_ruby(&batch)?;
+            let batch_docs = convert_batch_to_ruby(&ruby, &batch)?;
             // Merge arrays by pushing each element
             for i in 0..batch_docs.len() {
                 result_array.push(batch_docs.entry::<Value>(i as isize)?)?;
@@ -247,25 +252,26 @@ impl LancelotDataset {
     }
 
     pub fn create_vector_index(&self, column: String) -> Result<(), Error> {
+        let ruby = Ruby::get().unwrap();
         let mut dataset = self.dataset.borrow_mut();
         let dataset = dataset.as_mut()
-            .ok_or_else(|| Error::new(magnus::exception::runtime_error(), "Dataset not opened"))?;
+            .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "Dataset not opened"))?;
 
         self.runtime.borrow_mut().block_on(async move {
             // Get row count to determine optimal number of partitions
             let num_rows = dataset.count_rows(None).await
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
-            
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+
             // Use fewer partitions for small datasets
             let num_partitions = if num_rows < 256 {
                 std::cmp::max(1, (num_rows / 4) as usize)
             } else {
                 256
             };
-            
+
             // Create IVF_FLAT vector index parameters
             let params = VectorIndexParams::ivf_flat(num_partitions, lance_linalg::distance::MetricType::L2);
-            
+
             dataset.create_index(
                 &[&column],
                 IndexType::Vector,
@@ -274,44 +280,47 @@ impl LancelotDataset {
                 true
             )
             .await
-            .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))
+            .map(|_| ())
+            .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))
         })
     }
 
     pub fn vector_search(&self, column: String, query_vector: RArray, limit: i64) -> Result<RArray, Error> {
+        let ruby = Ruby::get().unwrap();
         let dataset = self.dataset.borrow();
         let dataset = dataset.as_ref()
-            .ok_or_else(|| Error::new(magnus::exception::runtime_error(), "Dataset not opened"))?;
-
-        // Convert Ruby array to Vec<f32>
-        let vector: Vec<f32> = query_vector
-            .into_iter()
-            .map(|v| f64::try_convert(v).map(|f| f as f32))
-            .collect::<Result<Vec<_>, _>>()?;
+            .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "Dataset not opened"))?;
+
+        // Convert Ruby array to Vec<f32> using index-based iteration
+        let len = query_vector.len();
+        let mut vector: Vec<f32> = Vec::with_capacity(len);
+        for i in 0..len {
+            let v: f64 = query_vector.entry(i as isize)?;
+            vector.push(v as f32);
+        }
 
         let batches: Vec<RecordBatch> = self.runtime.borrow_mut().block_on(async {
             let mut scanner = dataset.scan();
-            
+
             // Use nearest for vector search
             scanner.nearest(&column, &Float32Array::from(vector), limit as usize)
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
-            
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+
             let stream = scanner
                 .try_into_stream()
                 .await
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
-            
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+
             stream
                 .try_collect::<Vec<_>>()
                 .await
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))
         })?;
 
-        let ruby = Ruby::get().unwrap();
         let result_array = ruby.ary_new();
 
         for batch in batches {
-            let batch_docs = convert_batch_to_ruby(&batch)?;
+            let batch_docs = convert_batch_to_ruby(&ruby, &batch)?;
             // Merge arrays by pushing each element
             for i in 0..batch_docs.len() {
                 result_array.push(batch_docs.entry::<Value>(i as isize)?)?;
@@ -322,14 +331,15 @@ impl LancelotDataset {
     }
 
     pub fn create_text_index(&self, column: String) -> Result<(), Error> {
+        let ruby = Ruby::get().unwrap();
         let mut dataset = self.dataset.borrow_mut();
         let dataset = dataset.as_mut()
-            .ok_or_else(|| Error::new(magnus::exception::runtime_error(), "Dataset not opened"))?;
+            .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "Dataset not opened"))?;
 
         self.runtime.borrow_mut().block_on(async move {
             // Create inverted index for full-text search
             let params = InvertedIndexParams::default();
-            
+
             dataset.create_index(
                 &[&column],
                 IndexType::Inverted,
@@ -338,46 +348,47 @@ impl LancelotDataset {
                 true
             )
             .await
-            .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))
+            .map(|_| ())
+            .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))
         })
     }
 
     pub fn text_search(&self, column: String, query: String, limit: i64) -> Result<RArray, Error> {
+        let ruby = Ruby::get().unwrap();
         let dataset = self.dataset.borrow();
         let dataset = dataset.as_ref()
-            .ok_or_else(|| Error::new(magnus::exception::runtime_error(), "Dataset not opened"))?;
+            .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "Dataset not opened"))?;
 
         let batches: Vec<RecordBatch> = self.runtime.borrow_mut().block_on(async {
             let mut scanner = dataset.scan();
-            
+
             // Use full-text search with inverted index
             let fts_query = FullTextSearchQuery::new(query)
                 .with_column(column)
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
-            
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+
             scanner.full_text_search(fts_query)
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
-            
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+
             // Apply limit
             scanner.limit(Some(limit), None)
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
-            
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+
             let stream = scanner
                 .try_into_stream()
                 .await
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
-            
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+
             stream
                 .try_collect::<Vec<_>>()
                 .await
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))
         })?;
 
-        let ruby = Ruby::get().unwrap();
         let result_array = ruby.ary_new();
 
         for batch in batches {
-            let batch_docs = convert_batch_to_ruby(&batch)?;
+            let batch_docs = convert_batch_to_ruby(&ruby, &batch)?;
             // Merge arrays by pushing each element
             for i in 0..batch_docs.len() {
                 result_array.push(batch_docs.entry::<Value>(i as isize)?)?;
@@ -388,47 +399,49 @@ impl LancelotDataset {
     }
 
     pub fn multi_column_text_search(&self, columns: RArray, query: String, limit: i64) -> Result<RArray, Error> {
+        let ruby = Ruby::get().unwrap();
         let dataset = self.dataset.borrow();
         let dataset = dataset.as_ref()
-            .ok_or_else(|| Error::new(magnus::exception::runtime_error(), "Dataset not opened"))?;
-
-        // Convert Ruby array of columns to Vec<String>
-        let columns: Vec<String> = columns
-            .into_iter()
-            .map(|v| String::try_convert(v))
-            .collect::<Result<Vec<_>, _>>()?;
+            .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "Dataset not opened"))?;
+
+        // Convert Ruby array of columns to Vec<String> using index-based iteration
+        let len = columns.len();
+        let mut cols: Vec<String> = Vec::with_capacity(len);
+        for i in 0..len {
+            let v: String = columns.entry(i as isize)?;
+            cols.push(v);
+        }
 
         let batches: Vec<RecordBatch> = self.runtime.borrow_mut().block_on(async {
             let mut scanner = dataset.scan();
-            
+
             // Create a full-text search query for multiple columns
             let fts_query = FullTextSearchQuery::new(query)
-                .with_columns(&columns)
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
-            
+                .with_columns(&cols)
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+
             scanner.full_text_search(fts_query)
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
-            
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+
             // Apply limit
             scanner.limit(Some(limit), None)
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
-            
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+
             let stream = scanner
                 .try_into_stream()
                 .await
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
-            
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+
             stream
                 .try_collect::<Vec<_>>()
                 .await
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))
         })?;
 
-        let ruby = Ruby::get().unwrap();
         let result_array = ruby.ary_new();
 
         for batch in batches {
-            let batch_docs = convert_batch_to_ruby(&batch)?;
+            let batch_docs = convert_batch_to_ruby(&ruby, &batch)?;
             // Merge arrays by pushing each element
             for i in 0..batch_docs.len() {
                 result_array.push(batch_docs.entry::<Value>(i as isize)?)?;
@@ -439,39 +452,39 @@ impl LancelotDataset {
     }
 
     pub fn filter_scan(&self, filter_expr: String, limit: Option<i64>) -> Result<RArray, Error> {
+        let ruby = Ruby::get().unwrap();
         let dataset = self.dataset.borrow();
         let dataset = dataset.as_ref()
-            .ok_or_else(|| Error::new(magnus::exception::runtime_error(), "Dataset not opened"))?;
+            .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "Dataset not opened"))?;
 
         let batches: Vec<RecordBatch> = self.runtime.borrow_mut().block_on(async {
             let mut scanner = dataset.scan();
-            
+
             // Apply SQL-like filter
             scanner.filter(&filter_expr)
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
-            
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+
             // Apply limit if provided
             if let Some(lim) = limit {
                 scanner.limit(Some(lim), None)
-                    .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
+                    .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
             }
-            
+
             let stream = scanner
                 .try_into_stream()
                 .await
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
-            
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+
             stream
                 .try_collect::<Vec<_>>()
                 .await
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))
         })?;
 
-        let ruby = Ruby::get().unwrap();
         let result_array = ruby.ary_new();
 
         for batch in batches {
-            let batch_docs = convert_batch_to_ruby(&batch)?;
+            let batch_docs = convert_batch_to_ruby(&ruby, &batch)?;
             // Merge arrays by pushing each element
             for i in 0..batch_docs.len() {
                 result_array.push(batch_docs.entry::<Value>(i as isize)?)?;
@@ -501,4 +514,4 @@ impl LancelotDataset {
         class.define_method("filter_scan", method!(LancelotDataset::filter_scan, 2))?;
         Ok(())
     }
-}
+}

data/ext/lancelot/src/lib.rs

@@ -1,4 +1,4 @@
-use magnus::{define_module, Error, Ruby, Module};
+use magnus::{Error, Ruby, Module};
 
 mod dataset;
 mod schema;
@@ -8,10 +8,10 @@ use dataset::LancelotDataset;
 
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<(), Error> {
-    let module = define_module("Lancelot")?;
-    
+    let module = ruby.define_module("Lancelot")?;
+
     let dataset_class = module.define_class("Dataset", ruby.class_object())?;
     LancelotDataset::bind(&dataset_class)?;
-    
+
     Ok(())
-}
+}

data/ext/lancelot/src/schema.rs

@@ -1,28 +1,26 @@
-use magnus::{Error, RHash, Symbol, Value, TryConvert, r_hash::ForEach, value::ReprValue};
+use magnus::{Error, Ruby, RHash, Symbol, Value, TryConvert, r_hash::ForEach};
 use arrow_schema::{DataType, Field, Schema as ArrowSchema};
 use std::sync::Arc;
 
-pub fn build_arrow_schema(schema_hash: RHash) -> Result<ArrowSchema, Error> {
+pub fn build_arrow_schema(ruby: &Ruby, schema_hash: RHash) -> Result<ArrowSchema, Error> {
     let mut fields = Vec::new();
 
     schema_hash.foreach(|key: Symbol, value: Value| {
         let field_name = key.name()?.to_string();
-        
-        let data_type = if value.is_kind_of(magnus::class::hash()) {
-            let hash = RHash::from_value(value)
-                .ok_or_else(|| Error::new(magnus::exception::arg_error(), "Invalid hash value"))?;
-            let type_str: String = hash.fetch(Symbol::new("type"))?;
-            
+
+        let data_type = if let Some(hash) = RHash::from_value(value) {
+            let type_str: String = hash.fetch(ruby.to_symbol("type"))?;
+
             match type_str.as_str() {
                 "vector" => {
-                    let dimension: i32 = hash.fetch(Symbol::new("dimension"))?;
+                    let dimension: i32 = hash.fetch(ruby.to_symbol("dimension"))?;
                     DataType::FixedSizeList(
                         Arc::new(Field::new("item", DataType::Float32, true)),
                         dimension,
                     )
                 }
                 _ => return Err(Error::new(
-                    magnus::exception::arg_error(),
+                    ruby.exception_arg_error(),
                     format!("Unknown field type: {}", type_str)
                 ))
             }
@@ -36,7 +34,7 @@ pub fn build_arrow_schema(schema_hash: RHash) -> Result<ArrowSchema, Error> {
                 "int64" => DataType::Int64,
                 "boolean" => DataType::Boolean,
                 _ => return Err(Error::new(
-                    magnus::exception::arg_error(),
+                    ruby.exception_arg_error(),
                     format!("Unknown field type: {}", type_str)
                 ))
             }
@@ -47,4 +45,4 @@ pub fn build_arrow_schema(schema_hash: RHash) -> Result<ArrowSchema, Error> {
     })?;
 
     Ok(ArrowSchema::new(fields))
-}
+}

data/lib/lancelot/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lancelot
-  VERSION = "0.3.4"
+  VERSION = "0.4.0"
 end

data/lib/lancelot.rb

@@ -1,7 +1,20 @@
 # frozen_string_literal: true
 
 require_relative "lancelot/version"
-require_relative "lancelot/lancelot"
+
+# Load the compiled Rust extension. Precompiled (platform) gems install it into a
+# Ruby-ABI-versioned subdir (lib/lancelot/<major.minor>/lancelot.{so,bundle}) so a
+# single fat gem can carry a binary per Ruby version; source/dev builds place it flat
+# at lib/lancelot/lancelot.{so,bundle}. Try the versioned path first, fall back to the
+# flat one. Resolution goes through $LOAD_PATH (`require`, never `require_relative`)
+# because RubyGems installs native extensions outside the gem's lib/ dir.
+begin
+  RUBY_VERSION =~ /(\d+\.\d+)/
+  require "lancelot/#{Regexp.last_match(1)}/lancelot"
+rescue LoadError
+  require "lancelot/lancelot"
+end
+
 require_relative "lancelot/dataset"
 require_relative "lancelot/rank_fusion"