turso 0.1.0 → 0.1.2

data/ext/turso_ruby/Cargo.toml

@@ -1,12 +1,16 @@
+[workspace]
+
 [package]
 name = "turso_ruby"
-version = "0.1.0"
+version = "0.1.2"
 edition = "2021"
 
 [lib]
 crate-type = ["cdylib"]
+path = "../../../src/lib.rs"
 
 [dependencies]
 magnus = { version = "0.8", features = ["rb-sys"] }
-turso_sdk_kit = { path = "../../../../sdk-kit" }
-turso_core = { path = "../../../../core" }
+rb-sys = "0.9"
+turso_sdk_kit = { path = "../../../../../sdk-kit", features = ["fts"] }
+turso_core = { path = "../../../../../core", features = ["fts"] }

data/ext/turso_ruby/extconf.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require "mkmf"
-require "rb_sys"
+require "rb_sys/mkmf"
 
-create_rust_makefile("turso_ruby/turso_ruby") do |r|
-  r.auto_install_rust = true
-end
+create_rust_makefile("turso_ruby/turso_ruby")

data/lib/turso/database.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Turso
+  class Database
+    def initialize(path = ":memory:", **options)
+      options[:experimental_features] = normalize_experimental_features(options[:experimental_features])
+      @native = NativeDatabase.new(path, options)
+      @closed = false
+    end
+
+    private
+
+    def normalize_experimental_features(features)
+      return nil if features.nil? || features.empty?
+
+      Array(features).join(",")
+    end
+
+    public
+
+    def closed?
+      @closed || !@native.open?
+    end
+
+    def close
+      return if closed?
+      @native.close
+      @closed = true
+    end
+
+    def prepare(sql)
+      raise Turso::Exception, "database is closed" if closed?
+      Statement.new(@native.connection.prepare(sql), @native.connection)
+    end
+
+    def execute(sql, *bind_args)
+      stmt = prepare(sql)
+      begin
+        stmt.bind(*bind_args) unless bind_args.empty?
+        stmt.run
+      ensure
+        stmt.close
+      end
+    end
+
+    def execute_batch(sql)
+      raise Turso::Exception, "database is closed" if closed?
+      @native.connection.execute_batch(sql)
+    end
+
+    def query(sql, *bind_args)
+      stmt = prepare(sql)
+      stmt.bind(*bind_args) unless bind_args.empty?
+      ResultSet.new(stmt)
+    end
+
+    def get_first_row(sql, *bind_args)
+      stmt = prepare(sql)
+      begin
+        stmt.bind(*bind_args) unless bind_args.empty?
+        stmt.get
+      ensure
+        stmt.close
+      end
+    end
+
+    def get_first_value(sql, *bind_args)
+      row = get_first_row(sql, *bind_args)
+      row&.first
+    end
+
+    def transaction(mode = :deferred)
+      raise Turso::Exception, "database is closed" if closed?
+      execute("BEGIN #{mode.to_s.upcase}")
+      begin
+        result = yield self
+        execute("COMMIT")
+        result
+      rescue ::Exception
+        execute("ROLLBACK")
+        raise
+      end
+    end
+
+    def busy_timeout=(ms)
+      @native.connection.busy_timeout = ms
+    end
+
+    def busy_timeout
+      @native.connection.busy_timeout
+    end
+
+    def total_changes
+      @native.total_changes
+    end
+
+    def changes
+      @native.connection.changes
+    end
+
+    def last_insert_rowid
+      @native.last_insert_rowid
+    end
+
+    def interrupt
+      @native.connection.interrupt
+    end
+  end
+end

data/lib/turso/result_set.rb

@@ -8,28 +8,24 @@ module Turso
       @statement = statement
     end
 
-    def each
-      return to_enum unless block_given?
+    def fields
+      @statement.columns.map { |c| c[:name] }
+    end
+
+    def each(&block)
+      @statement.each(&block)
+    end
+
+    def next
+      @statement.get
+    end
 
-      columns = column_names
-      loop do
-        case @statement.step
-        when 1 # ROW
-          yield Row.new(columns, @statement.row)
-        when 0 # DONE
-          break
-        else
-          raise Turso::Error, "unexpected step status"
-        end
-      end
-      self
-    ensure
-      @statement.finalize
+    def reset
+      @statement.reset
     end
 
-    def column_names
-      count = @statement.column_count
-      (0...count).map { |i| @statement.column_name(i) }
+    def close
+      @statement.close
     end
   end
 end

data/lib/turso/row.rb

@@ -2,31 +2,41 @@
 
 module Turso
   class Row
-    def initialize(columns, values)
-      @columns = columns
+    include Enumerable
+
+    def initialize(values, column_names)
       @values = values
+      @column_names = column_names
+    end
+
+    def to_a
+      @values.dup
     end
 
     def [](key)
       case key
-      when Integer then @values[key]
-      when String, Symbol then @values[@columns.index(key.to_s)]
+      when Integer
+        @values[key]
+      when String, Symbol
+        @values[column_index(key.to_s)]
+      else
+        raise ArgumentError, "invalid key type: #{key.class}"
       end
     end
 
-    def to_h
-      @columns.zip(@values).to_h
+    def each(&block)
+      @values.each(&block)
     end
 
-    def keys = @columns
-    def values = @values
+    def length
+      @values.length
+    end
+    alias size length
 
-    def fetch(key, &fallback)
-      value = self[key]
-      return value unless value.nil?
-      return fallback.call(key) if fallback
+    private
 
-      raise KeyError, "key not found: #{key.inspect}"
+    def column_index(name)
+      @column_names.index(name) || raise(IndexError, "column #{name} not found")
     end
   end
 end

data/lib/turso/statement.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Turso
+  class Statement
+    def initialize(native_statement, native_database)
+      @native = native_statement
+      @database = native_database
+      @owner = Thread.current
+    end
+
+    def bind(*args)
+      check_owner!
+      return self if args.empty?
+
+      if args.size == 1 && args.first.is_a?(Hash)
+        bind_hash(args.first)
+      else
+        args.each_with_index do |value, index|
+          bind_value(index + 1, value)
+        end
+      end
+      self
+    end
+
+    def run(*bind_args)
+      check_owner!
+      bind(*bind_args) unless bind_args.empty?
+      step_loop(consume_rows: false)
+      { changes: @database.changes, last_insert_rowid: @database.last_insert_rowid }
+    end
+
+    def get(*bind_args)
+      check_owner!
+      bind(*bind_args) unless bind_args.empty?
+      row = nil
+      step_loop(consume_rows: true) { |r| row ||= r; false }
+      row
+    end
+
+    def all(*bind_args)
+      check_owner!
+      bind(*bind_args) unless bind_args.empty?
+      rows = []
+      step_loop(consume_rows: true) { |r| rows << r; true }
+      rows
+    end
+
+    def each(*bind_args)
+      return to_enum(:each, *bind_args) unless block_given?
+      check_owner!
+      bind(*bind_args) unless bind_args.empty?
+      step_loop(consume_rows: true) { |r| yield r; true }
+    end
+
+    def columns
+      check_owner!
+      (1..@native.column_count).map do |i|
+        { name: @native.column_name(i - 1), type: @native.column_decltype(i - 1) }
+      end
+    end
+
+    def reader?
+      @native.column_count > 0
+    end
+
+    def step
+      check_owner!
+      @native.step
+    end
+
+    def reset
+      check_owner!
+      @native.reset
+    end
+
+    def close
+      @native.finalize
+    end
+
+    private
+
+    def check_owner!
+      unless Thread.current.equal?(@owner)
+        raise Turso::Exception, "statement is already in use by another thread"
+      end
+    end
+
+    def bind_hash(hash)
+      hash.each do |key, value|
+        name = key.to_s
+        name = ":#{name}" unless name.start_with?(/^[:@?$]/)
+        position = @native.named_position(name)
+        bind_value(position, value)
+      end
+    end
+
+    def bind_value(position, value)
+      case value
+      when nil
+        @native.bind_null(position)
+      when Integer
+        @native.bind_int(position, value)
+      when Float
+        @native.bind_double(position, value)
+      when String
+        if value.encoding == Encoding::ASCII_8BIT
+          @native.bind_blob(position, value.b)
+        else
+          @native.bind_text(position, value)
+        end
+      when true
+        @native.bind_int(position, 1)
+      when false
+        @native.bind_int(position, 0)
+      when Symbol
+        @native.bind_text(position, value.to_s)
+      when Time
+        @native.bind_text(position, value.iso8601)
+      else
+        @native.bind_text(position, value.to_s)
+      end
+    end
+
+    def step_loop(consume_rows:)
+      loop do
+        result = @native.step
+        case result
+        when 0 # done
+          break
+        when 1 # row
+          if consume_rows
+            row = build_row
+            continue = yield row
+            break unless continue
+          end
+        end
+      end
+    end
+
+    def build_row
+      values = (0...@native.column_count).map { |i| @native.row_value(i) }
+      column_names = (0...@native.column_count).map { |i| @native.column_name(i) }
+      Row.new(values, column_names)
+    end
+  end
+end

data/lib/turso/transaction.rb

@@ -1,14 +1,20 @@
 # frozen_string_literal: true
 
 module Turso
+  VALID_TRANSACTION_MODES = %i[deferred immediate exclusive concurrent].freeze
+
   class Transaction
-    def initialize(db)
+    def initialize(db, mode = :immediate)
+      unless VALID_TRANSACTION_MODES.include?(mode)
+        fail ArgumentError, "Invalid transaction mode: #{mode.inspect}. Valid modes: #{VALID_TRANSACTION_MODES.inspect}"
+      end
       @db = db
+      @mode = mode
       @active = false
     end
 
     def begin
-      @db.execute("BEGIN")
+      @db.execute("BEGIN #{@mode.to_s.upcase}")
       @active = true
     end
 

data/lib/turso/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Turso
+  VERSION = "0.1.2"
+end

data/lib/turso.rb

@@ -2,7 +2,13 @@
 
 require "turso/turso_ruby"
 
-require_relative "turso/db"
-require_relative "turso/result_set"
 require_relative "turso/row"
+require_relative "turso/result_set"
+require_relative "turso/statement"
+require_relative "turso/database"
 require_relative "turso/transaction"
+require_relative "turso/version"
+
+module Turso
+  Error = Exception
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: turso
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Turso Team
@@ -23,18 +23,37 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: irb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 executables: []
 extensions:
 - ext/turso_ruby/extconf.rb
 extra_rdoc_files: []
 files:
+- README.md
+- ext/turso_ruby/Cargo.lock
 - ext/turso_ruby/Cargo.toml
 - ext/turso_ruby/extconf.rb
 - lib/turso.rb
-- lib/turso/db.rb
+- lib/turso/database.rb
 - lib/turso/result_set.rb
 - lib/turso/row.rb
+- lib/turso/statement.rb
 - lib/turso/transaction.rb
+- lib/turso/turso_ruby.so
+- lib/turso/version.rb
 licenses:
 - MIT
 metadata: {}
@@ -45,7 +64,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/turso/db.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Turso
-  class DB
-    def initialize(path, **opts)
-      @database = Database.new(path, opts)
-    end
-
-    def execute(sql, params = [])
-      stmt = @database.connection.prepare(sql)
-      stmt.bind_positional(params) unless params.empty?
-      case stmt.execute
-      when Integer
-        @database.last_insert_rowid
-      when 0
-        @database.changes
-      end
-    ensure
-      stmt&.finalize
-    end
-
-    def query(sql, params = [])
-      stmt = @database.connection.prepare(sql)
-      stmt.bind_positional(params) unless params.empty?
-      ResultSet.new(stmt)
-    end
-
-    def transaction(&block)
-      if block
-        execute("BEGIN")
-        begin
-          result = block.call(self)
-          execute("COMMIT")
-          result
-        rescue StandardError
-          execute("ROLLBACK")
-          raise
-        end
-      else
-        Transaction.new(self)
-      end
-    end
-
-    def close
-      @database.close
-    end
-
-    def closed?
-      !@database.open?
-    end
-  end
-end