pglite 0.0.1

data/ext/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "pglite_rb_ext"
+version = "0.0.1"
+edition = "2021"
+
+[lib]
+name = "pglite_rb_ext"
+crate-type = ["cdylib"]
+
+[dependencies]
+magnus = "0.8"
+pglite-oxide = "0.1.0"
+tokio = { version = "1.0", features = ["rt", "rt-multi-thread", "macros"] }
+tokio-postgres = "0.7"
+bytes = "1.0"
+hex = "0.4"
+anyhow = "1.0"
+
+[dependencies.serde]
+version = "1.0"
+features = ["derive"]
+
+[dependencies.serde_json]
+version = "1.0"

data/ext/extconf.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "mkmf"
+require "rb_sys/mkmf"
+
+create_rust_makefile("pglite-rb/pglite_rb_ext")

data/ext/src/lib.rs

@@ -0,0 +1,487 @@
+use magnus::{
+    function, method,
+    prelude::*,
+    Error, RString, Ruby, Value, RArray,
+};
+use std::sync::OnceLock;
+
+// Global runtime for handling pglite-oxide operations
+static RUNTIME: OnceLock<()> = OnceLock::new();
+
+// Initialize pglite-oxide runtime once
+fn ensure_runtime() {
+    RUNTIME.get_or_init(|| {
+        // Initialize any global state if needed
+        ()
+    });
+}
+
+// Intermediate struct for parsing that doesn't contain Ruby values
+#[derive(Debug)]
+struct ParsedResult {
+    command: String,
+    columns: Vec<String>,
+    rows: Vec<Vec<ParsedValue>>,
+}
+
+#[derive(Debug, Clone)]
+enum ParsedValue {
+    Null,
+    Bool(bool),
+    Integer(i64),
+    Float(f64),
+    Text(String),
+}
+
+// Result struct that will be exposed to Ruby
+#[derive(Clone)]
+#[magnus::wrap(class = "PGlite::Oxide::Result")]
+struct QueryResult {
+    command: String,
+    columns: Vec<String>,
+    row_count: usize,
+    // Store raw data that can be converted to Ruby values on demand
+    raw_rows: Vec<Vec<ParsedValue>>,
+}
+
+impl QueryResult {
+    fn new(parsed: ParsedResult) -> Self {
+        let row_count = parsed.rows.len();
+        Self {
+            command: parsed.command,
+            columns: parsed.columns,
+            row_count,
+            raw_rows: parsed.rows,
+        }
+    }
+
+    // Ruby method: result.command
+    fn command(&self) -> String {
+        self.command.clone()
+    }
+
+    // Ruby method: result.columns  
+    fn columns(&self) -> Result<RArray, Error> {
+        let ruby = Ruby::get().map_err(|e| Error::new(Ruby::get().unwrap().exception_runtime_error(), format!("Ruby context unavailable: {}", e)))?;
+        let array = ruby.ary_new_capa(self.columns.len());
+        for col in &self.columns {
+            array.push(ruby.str_new(col))?;
+        }
+        Ok(array)
+    }
+
+    // Ruby method: result.rows
+    fn rows(&self) -> Result<RArray, Error> {
+        let ruby = Ruby::get().map_err(|e| Error::new(Ruby::get().unwrap().exception_runtime_error(), format!("Ruby context unavailable: {}", e)))?;
+        let rows_array = ruby.ary_new_capa(self.raw_rows.len());
+        
+        for row in &self.raw_rows {
+            let row_array = ruby.ary_new_capa(row.len());
+            for parsed_value in row {
+                let ruby_value = convert_parsed_to_ruby_value(parsed_value, &ruby)?;
+                row_array.push(ruby_value)?;
+            }
+            rows_array.push(row_array)?;
+        }
+        Ok(rows_array)
+    }
+
+    // Ruby method: result.row_count
+    fn row_count(&self) -> usize {
+        self.row_count
+    }
+
+    // Ruby method: result.first - convenience method to get first row
+    fn first(&self) -> Result<Value, Error> {
+        let ruby = Ruby::get().map_err(|e| Error::new(Ruby::get().unwrap().exception_runtime_error(), format!("Ruby context unavailable: {}", e)))?;
+        
+        if let Some(first_row) = self.raw_rows.first() {
+            let row_array = ruby.ary_new_capa(first_row.len());
+            for parsed_value in first_row {
+                let ruby_value = convert_parsed_to_ruby_value(parsed_value, &ruby)?;
+                row_array.push(ruby_value)?;
+            }
+            Ok(row_array.as_value())
+        } else {
+            Ok(ruby.qnil().as_value())
+        }
+    }
+
+    // Ruby method: result.each - iterate over rows
+    fn each(&self, block: Option<magnus::block::Proc>) -> Result<Value, Error> {
+        let ruby = Ruby::get().map_err(|e| Error::new(Ruby::get().unwrap().exception_runtime_error(), format!("Ruby context unavailable: {}", e)))?;
+        
+        match block {
+            Some(proc) => {
+                for row in &self.raw_rows {
+                    let row_array = ruby.ary_new_capa(row.len());
+                    for parsed_value in row {
+                        let ruby_value = convert_parsed_to_ruby_value(parsed_value, &ruby)?;
+                        row_array.push(ruby_value)?;
+                    }
+                    proc.call::<(RArray,), Value>((row_array,))?;
+                }
+                Ok(ruby.qnil().as_value())  // Return nil for now
+            },
+            None => {
+                // Return enumerator - for now just return self
+                Ok(ruby.qnil().as_value())  // Return nil for now
+            }
+        }
+    }
+}
+
+// Convert ParsedValue to Ruby Value
+fn convert_parsed_to_ruby_value(parsed_value: &ParsedValue, ruby: &Ruby) -> Result<Value, Error> {
+    match parsed_value {
+        ParsedValue::Null => Ok(ruby.qnil().as_value()),
+        ParsedValue::Bool(b) => Ok(ruby.into_value(*b)),
+        ParsedValue::Integer(i) => Ok(ruby.into_value(*i)),
+        ParsedValue::Float(f) => Ok(ruby.into_value(*f)),
+        ParsedValue::Text(s) => Ok(ruby.str_new(s).as_value()),
+    }
+}
+
+// PGlite::Oxide.install!(path)
+fn install(path: RString) -> Result<Value, Error> {
+    let ruby = Ruby::get().map_err(|e| Error::new(Ruby::get().unwrap().exception_runtime_error(), format!("Ruby context unavailable: {}", e)))?;
+    let path_str = path.to_string()?;
+    
+    ensure_runtime();
+    
+    match pglite_oxide::install_and_init_in(&path_str) {
+        Ok(_) => Ok(ruby.qnil().as_value()),
+        Err(e) => Err(Error::new(
+            ruby.exception_runtime_error(),
+            format!("Failed to install PGlite: {}", e)
+        ))
+    }
+}
+
+// PGlite::Oxide.version
+fn version() -> Result<RString, Error> {
+    let ruby = Ruby::get().map_err(|e| Error::new(Ruby::get().unwrap().exception_runtime_error(), format!("Ruby context unavailable: {}", e)))?;
+    
+    ensure_runtime();
+    
+    match execute_query_internal("SELECT version()") {
+        Ok(result) => {
+            // Extract version from the first row, first column
+            if let Some(first_row) = result.rows.first() {
+                if let Some(first_value) = first_row.first() {
+                    if let ParsedValue::Text(version_str) = first_value {
+                        return Ok(ruby.str_new(version_str));
+                    }
+                }
+            }
+            
+            // Fallback if parsing fails
+            Ok(ruby.str_new("PostgreSQL (via PGlite)"))
+        },
+        Err(e) => Err(Error::new(
+            ruby.exception_runtime_error(),
+            format!("Failed to get version: {}", e)
+        ))
+    }
+}
+
+// PGlite::Oxide.exec_query(sql) - returns QueryResult object
+fn exec_query(sql: RString) -> Result<QueryResult, Error> {
+    let sql_str = sql.to_string()?;
+    
+    ensure_runtime();
+    
+    match execute_query_internal(&sql_str) {
+        Ok(parsed_result) => Ok(QueryResult::new(parsed_result)),
+        Err(e) => {
+            let ruby = Ruby::get().unwrap();
+            Err(Error::new(
+                ruby.exception_runtime_error(),
+                format!("Failed to execute query: {}", e)
+            ))
+        }
+    }
+}
+
+// Internal function to execute queries
+fn execute_query_internal(sql: &str) -> Result<ParsedResult, Box<dyn std::error::Error>> {
+    let input = pglite_oxide::interactive::PokeInput::Str(sql);
+    let response_bytes = pglite_oxide::interactive::exec_interactive(input)?;
+    
+    // Parse the raw PostgreSQL protocol response
+    parse_postgres_response(response_bytes)
+}
+
+// Parse raw PostgreSQL protocol response into ParsedResult
+fn parse_postgres_response(raw_bytes: Vec<u8>) -> Result<ParsedResult, Box<dyn std::error::Error>> {
+    // Convert hex string to bytes if needed
+    let protocol_bytes = if let Ok(hex_str) = String::from_utf8(raw_bytes.clone()) {
+        // If it looks like hex (starts with hex chars), decode it
+        if hex_str.chars().all(|c| c.is_ascii_hexdigit() || c.is_whitespace()) {
+            hex::decode(hex_str.replace(|c: char| c.is_whitespace(), ""))
+                .unwrap_or(raw_bytes)
+        } else {
+            raw_bytes
+        }
+    } else {
+        raw_bytes
+    };
+
+    // Parse the PostgreSQL wire protocol response
+    parse_query_response(&protocol_bytes)
+}
+
+// Parse PostgreSQL wire protocol query response
+fn parse_query_response(data: &[u8]) -> Result<ParsedResult, Box<dyn std::error::Error>> {
+    let mut offset = 0;
+    let mut columns = Vec::new();
+    let mut rows = Vec::new();
+    let mut command_tag = String::new();
+    
+    while offset < data.len() {
+        if offset + 5 > data.len() {
+            break;
+        }
+        
+        let msg_type = data[offset];
+        let length = u32::from_be_bytes([
+            data[offset + 1],
+            data[offset + 2], 
+            data[offset + 3],
+            data[offset + 4]
+        ]) as usize;
+        
+        if offset + 1 + length > data.len() {
+            break;
+        }
+        
+        let msg_data = &data[offset + 5..offset + 1 + length];
+        
+        match msg_type {
+            b'T' => {
+                // RowDescription - column metadata
+                columns = parse_row_description(msg_data)?;
+            },
+            b'D' => {
+                // DataRow - actual data
+                if !columns.is_empty() {
+                    let row = parse_data_row(msg_data, &columns)?;
+                    rows.push(row);
+                }
+            },
+            b'C' => {
+                // CommandComplete
+                command_tag = parse_command_complete(msg_data)?;
+            },
+            b'Z' => {
+                // ReadyForQuery - end of response
+                break;
+            },
+            _ => {
+                // Skip unknown message types
+            }
+        }
+        
+        offset += 1 + length;
+    }
+    
+    let column_names = columns.into_iter().map(|col| col.name).collect();
+    Ok(ParsedResult {
+        command: command_tag,
+        columns: column_names,
+        rows,
+    })
+}
+
+#[derive(Clone)]
+struct ColumnInfo {
+    name: String,
+    oid: u32,
+    type_modifier: i32,
+}
+
+fn parse_row_description(data: &[u8]) -> Result<Vec<ColumnInfo>, Box<dyn std::error::Error>> {
+    let mut offset = 0;
+    
+    if data.len() < 2 {
+        return Err("Invalid RowDescription: too short".into());
+    }
+    
+    let num_fields = u16::from_be_bytes([data[0], data[1]]);
+    offset += 2;
+    
+    let mut columns = Vec::new();
+    
+    for _ in 0..num_fields {
+        // Field name (null-terminated string)
+        let name_start = offset;
+        while offset < data.len() && data[offset] != 0 {
+            offset += 1;
+        }
+        if offset >= data.len() {
+            return Err("Invalid RowDescription: unterminated field name".into());
+        }
+        
+        let name = String::from_utf8_lossy(&data[name_start..offset]).to_string();
+        offset += 1; // skip null terminator
+        
+        // Skip table OID (4 bytes), column number (2 bytes)
+        offset += 6;
+        
+        if offset + 8 > data.len() {
+            return Err("Invalid RowDescription: insufficient data".into());
+        }
+        
+        // Type OID (4 bytes)
+        let type_oid = u32::from_be_bytes([
+            data[offset], data[offset + 1], data[offset + 2], data[offset + 3]
+        ]);
+        offset += 4;
+        
+        // Skip type size (2 bytes)
+        offset += 2;
+        
+        // Type modifier (4 bytes) 
+        let type_modifier = i32::from_be_bytes([
+            data[offset], data[offset + 1], data[offset + 2], data[offset + 3]
+        ]);
+        offset += 4;
+        
+        // Skip format code (2 bytes)
+        offset += 2;
+        
+        columns.push(ColumnInfo {
+            name,
+            oid: type_oid,
+            type_modifier,
+        });
+    }
+    
+    Ok(columns)
+}
+
+fn parse_data_row(data: &[u8], columns: &[ColumnInfo]) -> Result<Vec<ParsedValue>, Box<dyn std::error::Error>> {
+    let mut offset = 0;
+    
+    if data.len() < 2 {
+        return Err("Invalid DataRow: too short".into());
+    }
+    
+    let num_fields = u16::from_be_bytes([data[0], data[1]]);
+    offset += 2;
+    
+    let mut row_values = Vec::new();
+    
+    for i in 0..num_fields as usize {
+        if offset + 4 > data.len() {
+            return Err("Invalid DataRow: insufficient length data".into());
+        }
+        
+        let field_len = i32::from_be_bytes([
+            data[offset], data[offset + 1], data[offset + 2], data[offset + 3]
+        ]);
+        offset += 4;
+        
+        let value = if field_len == -1 {
+            // NULL value
+            ParsedValue::Null
+        } else {
+            let field_len = field_len as usize;
+            if offset + field_len > data.len() {
+                return Err("Invalid DataRow: insufficient field data".into());
+            }
+            
+            let field_data = &data[offset..offset + field_len];
+            offset += field_len;
+            
+            // Convert based on PostgreSQL type
+            let column = columns.get(i).ok_or("Column index out of bounds")?;
+            convert_pg_value(field_data, column.oid)?
+        };
+        
+        row_values.push(value);
+    }
+    
+    Ok(row_values)
+}
+
+fn parse_command_complete(data: &[u8]) -> Result<String, Box<dyn std::error::Error>> {
+    // Command tag is a null-terminated string
+    let end = data.iter().position(|&b| b == 0).unwrap_or(data.len());
+    Ok(String::from_utf8_lossy(&data[..end]).to_string())
+}
+
+fn convert_pg_value(data: &[u8], type_oid: u32) -> Result<ParsedValue, Box<dyn std::error::Error>> {
+    match type_oid {
+        // Boolean
+        16 => Ok(ParsedValue::Bool(data[0] != 0)),
+        
+        // Integers
+        20 => { // bigint (int8)
+            if data.len() != 8 {
+                return Err("Invalid bigint data length".into());
+            }
+            let val = i64::from_be_bytes(data.try_into()?);
+            Ok(ParsedValue::Integer(val))
+        },
+        21 => { // smallint (int2) 
+            if data.len() != 2 {
+                return Err("Invalid smallint data length".into());
+            }
+            let val = i16::from_be_bytes(data.try_into()?);
+            Ok(ParsedValue::Integer(val as i64))
+        },
+        23 => { // integer (int4)
+            if data.len() != 4 {
+                return Err("Invalid integer data length".into());
+            }
+            let val = i32::from_be_bytes(data.try_into()?);
+            Ok(ParsedValue::Integer(val as i64))
+        },
+        
+        // Floating point
+        700 => { // real (float4)
+            if data.len() != 4 {
+                return Err("Invalid float4 data length".into());
+            }
+            let val = f32::from_be_bytes(data.try_into()?);
+            Ok(ParsedValue::Float(val as f64))
+        },
+        701 => { // double precision (float8)
+            if data.len() != 8 {
+                return Err("Invalid float8 data length".into());
+            }
+            let val = f64::from_be_bytes(data.try_into()?);
+            Ok(ParsedValue::Float(val))
+        },
+        
+        // Text types - most common fallback
+        25 | 1043 | 1042 | _ => {
+            // text, varchar, char, or unknown - treat as string
+            let str_val = String::from_utf8_lossy(data);
+            Ok(ParsedValue::Text(str_val.to_string()))
+        }
+    }
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let pglite_module = ruby.define_module("PGlite")?;
+    let oxide_class = pglite_module.define_class("Oxide", ruby.class_object())?;
+    
+    // Define singleton methods (class methods)
+    oxide_class.define_singleton_method("install!", function!(install, 1))?;
+    oxide_class.define_singleton_method("version", function!(version, 0))?;
+    oxide_class.define_singleton_method("exec_query", function!(exec_query, 1))?;
+    
+    // Define the Result class and its methods
+    let result_class = oxide_class.define_class("Result", ruby.class_object())?;
+    result_class.define_method("command", method!(QueryResult::command, 0))?;
+    result_class.define_method("columns", method!(QueryResult::columns, 0))?;
+    result_class.define_method("rows", method!(QueryResult::rows, 0))?;
+    result_class.define_method("row_count", method!(QueryResult::row_count, 0))?;
+    result_class.define_method("first", method!(QueryResult::first, 0))?;
+    result_class.define_method("each", method!(QueryResult::each, 1))?;
+    
+    Ok(())
+}

data/lib/pglite/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module PGlite # :nodoc:
+  VERSION = "0.0.1"
+end

data/lib/pglite.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module PGlite
+  # Main PGlite module
+end
+
+require "pglite/version"
+
+begin
+  require "pglite_rb_ext"
+rescue LoadError
+  # Extension not available
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: pglite
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Vladimir Dementyev
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: combustion
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.9'
+description: Example description
+email:
+- Vladimir Dementyev
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- ext/Cargo.lock
+- ext/Cargo.toml
+- ext/extconf.rb
+- ext/src/lib.rs
+- lib/pglite.rb
+- lib/pglite/version.rb
+homepage: https://github.com/palkan/pglite-rb
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/palkan/pglite-rb/issues
+  changelog_uri: https://github.com/palkan/pglite-rb/blob/master/CHANGELOG.md
+  documentation_uri: https://github.com/palkan/pglite-rb
+  homepage_uri: https://github.com/palkan/pglite-rb
+  source_code_uri: https://github.com/palkan/pglite-rb
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Example description
+test_files: []