activerecord-turso 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c8e05a11274a315a434eb615873a9402e8afd76ff296b8efc030d9bd4d212d9
-  data.tar.gz: 0fa05a0646df999aba45e14fc31a5e2066ad471964d7501fa3994df9882cbca8
+  metadata.gz: 04f8ecc726fa450fadcf8b819a04663b3035bed1c1b5f592d362ec07664d2f14
+  data.tar.gz: 4ce85117e6f562ead6d2defeaaa5c70fccc2c62492d9916c798e56bcf32acfca
 SHA512:
-  metadata.gz: ee153e58a81fb89d2a1578cbbd4841a5720cac7c942916c1c256c234e3c0726f6bc0a2fb500cbcd7733a357efb43b1da37e9a8774a7d2eecfd98561cf9cdda76
-  data.tar.gz: 9d5ec6478407aa7c168c29dfbd64b6dc0661e84fbbb1167041ef8b2615fb5ffab899474787c2ceb946430f2aa92bac8684adaf6ffe2b6cf6188a953eb9ced36b
+  metadata.gz: 6d18e249a927642d705959341439129523cb3f2763ab699a8c2dfbc1f38d8f52b3b831a96f140a95518f3e932a9da348184af605525d354a54893419f332c0aa
+  data.tar.gz: 8b1cec4617634414e11928453aeed21e2c382fe4a36357ca435b601f337f8b9ca3fb732f035db02ebd8a0fe8f7dfc35db961c384faffd2cf8937ea612ec6363e

data/README.md

@@ -1,23 +1,27 @@
-# activerecord-turso
+# Activerecord-turso
 
-ActiveRecord adapter for [Turso](https://turso.tech) (SQLite compatible).
+ActiveRecord adapter for [Turso](https://turso.tech) (SQLite compatible db).
 
 ## Status
 
-This adapter is under active development. It can run basic ActiveRecord operations against Turso today, but several production features are still being hardened. See [Limitations and Risks](#limitations-and-risks) before using it in production.
+This adapter is under **active** development. It can run basic ActiveRecord operations against Turso today, but several production features are still being hardened. See [Limitations and Risks](#limitations-and-risks) before using it in production.
 
 ## Requirements
 
-- Ruby >= 3.0
+- Ruby >= 3.2
 - ActiveRecord >= 8.0, < 8.2
-- The `turso` Ruby gem (local bindings at `~/Projects/turso/bindings/ruby` during development)
+- The `turso` Ruby gem
+
+## Runtime dependencies
+
+This adapter uses the `turso` gem and does **not** require the `sqlite3` Ruby gem at runtime.
 
 ## Installation
 
 Add to your Gemfile:
 
 ```ruby
-gem "activerecord-turso", path: "~/Projects/activerecord-turso"
+gem "activerecord-turso"
 ```
 
 Then configure `database.yml`:
@@ -47,7 +51,23 @@ end
 Post.create!(title: "Hello", body: "World", published: true)
 ```
 
-### MVCC / BEGIN CONCURRENT
+## Recommended production configuration
+
+```yaml
+production:
+  adapter: turso
+  database: db/production.sqlite3
+  journal_mode: wal
+  pool: 5
+  timeout: 5000
+  busy_timeout: 5000
+  query_timeout: 30000
+  experimental_features: "index_method"
+```
+
+### MVCC / BEGIN CONCURRENT (experimental)
+
+⚠️ **Experimental.** Do not use in production unless you understand the caveats below. Normal ActiveRecord model persistence (`create!`, `save!`, `update!`, `touch`) is **not supported** inside `transaction(concurrent: true)`.
 
 Turso supports `BEGIN CONCURRENT` for optimistic, multi-writer transactions. To opt in, pass `concurrent: true` to `transaction`:
 
@@ -94,13 +114,24 @@ class AddFtsToPosts < ActiveRecord::Migration[8.1]
 end
 ```
 
-Query with Tantivy functions:
+Query with the adapter helpers:
 
-```sql
-SELECT * FROM posts WHERE fts_match(title, body, 'database');
+```ruby
+match = ActiveRecord::Base.connection.fts_match(:posts, [:title, :body], "database")
+Post.where(match)
+
+score = ActiveRecord::Base.connection.fts_score(:posts, [:title, :body], "database")
+Post.select(:id, :title, score.as("rank")).where(match).order("rank ASC")
 ```
 
-Note: `fts5` virtual tables are not supported. Use `USING fts` indexes instead.
+Note: `fts5` virtual tables are not supported. Use `USING fts` indexes instead. This requires the `index_method` experimental feature:
+
+```yaml
+production:
+  adapter: turso
+  database: db/production.sqlite3
+  experimental_features: "index_method"
+```
 
 ### Concurrent transactions
 
@@ -112,19 +143,22 @@ development:
   database: db/dev.sqlite3
   journal_mode: mvcc
   busy_timeout: 5000
+
+  experimental_features: "index_method"
 ```
 
 Use `concurrent: true` inside the same pinned connection:
 
 ```ruby
 ActiveRecord::Base.connection.transaction(concurrent: true) do
-  # read-modify-write
 end
 ```
 
 Caveats:
 - The connection must stay checked out for the whole transaction; avoid work that yields the ActiveRecord connection back to the pool.
 - `busy_timeout` is used for lock waits, not MVCC snapshot conflicts. Snapshot conflicts retry with bounded backoff.
+- Normal ActiveRecord model persistence (`create!`, `save!`, `update!`, `touch`) is **not supported** inside a concurrent transaction because ActiveRecord opens its own internal transaction for each model change. Use raw SQL (`execute`, `exec_query`) or bulk operations (`insert_all`, `update_all`, `update_columns`) instead.
+- FTS custom index modules are not supported in MVCC mode.
 
 ## Limitations and Risks
 
@@ -138,31 +172,35 @@ The adapter builds column type maps from `column_decltype` metadata. This works
 
 The adapter's batch execution path splits multi-statement SQL on semicolons. This means SQL containing semicolons inside string literals, triggers, or stored expressions may be split incorrectly. Avoid relying on multi-statement strings other than simple schema dumps.
 
-### 3. MVCC requires opt-in and has pooling caveats
+### 3. MVCC requires opt-in and has ActiveRecord compatibility caveats
 
 `BEGIN CONCURRENT` is powerful but breaks ActiveRecord's default assumptions:
 
 - ActiveRecord expects transactions to commit unless the database returns an error. With `BEGIN CONCURRENT`, the commit can fail with a snapshot conflict and must be retried.
 - The retry loop must run on the same connection. Rails' connection pool is not MVCC-aware and may return the connection to the pool between retries.
 - Do not combine concurrent transactions with pessimistic locking (`lock!`, `with_lock`, `lock_version`).
+- Normal model persistence (`create!`, `save!`, `update!`, `touch`) is unsupported inside a concurrent transaction because ActiveRecord opens an internal transaction for each model change.
 
-Only use `transaction(concurrent: true)` after testing it under your app's concurrency patterns.
+Only use `transaction(concurrent: true)` after testing it under your app's concurrency patterns, and prefer raw SQL or bulk operations inside the block.
 
-### 4. Prepared statement cache is disabled
+### 4. Prepared statement cache is enabled with a bounded pool
 
-The adapter returns `false` for `default_prepared_statements` and uses a no-op statement pool. Each query is prepared and finalized individually. This is slower than the upstream SQLite3 adapter for high-volume repeated queries, but avoids correctness issues until the Turso bindings expose stable prepared-statement reuse.
+The adapter uses a bounded statement pool with a default limit inherited from Rails (typically `1000`). Statements are evicted with an LRU policy and finalized against the underlying Turso connection. Set `statement_limit` in `database.yml` to tune the pool size.
 
 ### 5. ActiveRecord 8.0 support is CI-tested, not locally tested
 
 Only ActiveRecord 8.1 is installed in the primary development environment. ActiveRecord 8.0 compatibility is validated through CI. If you run into 8.0-specific issues, please report them.
 
-### 6. Some SQLite-specific features are unsupported or conservatively flagged
+### 6. INSERT RETURNING is disabled (not supported by Turso)
+
+The underlying Turso SQLite build does not support `INSERT ... RETURNING` syntax. The adapter reports `supports_insert_returning?` as `false`, so ActiveRecord falls back to `last_insert_rowid()` for retrieving inserted IDs.
+
+### 7. Some SQLite-specific features are unsupported or conservatively flagged
 
 - Transaction isolation levels other than the default are reported as unsupported (`supports_transaction_isolation?` returns `false`) because Turso remote connections do not provide shared-cache read-uncommitted semantics.
-- `insert_returning` is enabled only when the reported SQLite version is `>= 3.35.0`.
 - `insert_on_conflict` is enabled only when the reported SQLite version is `>= 3.24.0`.
 
-### 7. `execute_batch` in the underlying bindings is a Ruby-side fallback
+### 8. `execute_batch` in the underlying bindings is a Ruby-side fallback
 
 The `turso` gem provides `DB#execute_batch` as a convenience that splits and executes statements one by one. It does not use a native batch API, so it carries the same semicolon-splitting risk as item 2 above.
 
@@ -175,7 +213,19 @@ bundle install
 bundle exec rake test
 ```
 
-To run against the official Rails Active Record test suite, see the CI workflow in `.github/workflows/test.yml` and the project design doc in `docs/superpowers/specs/`.
+Run with MVCC mode:
+
+```bash
+TURSO_TEST_JOURNAL_MODE=mvcc bundle exec rake test
+```
+
+Run with generated-columns experimental feature:
+
+```bash
+TURSO_TEST_EXPERIMENTAL_FEATURES=generated_columns bundle exec rake test
+```
+
+The CI workflow in `.github/workflows/ci.yml` runs all three configurations automatically.
 
 ## License
 

data/lib/active_record/connection_adapters/turso_adapter/connection_management.rb

@@ -9,14 +9,16 @@ module ActiveRecord
         end
 
         module ClassMethods
-          def new_client(config)
-            db_config = config.symbolize_keys.merge(:timeout => config[:timeout] || 5000)
-            ::Turso::AR::Connection.new(db_config)
-          end
+        def new_client(config)
+          db_config = config.symbolize_keys.merge(:timeout => config[:timeout] || 5000)
+          db_config[:experimental_features] = Array(db_config[:experimental_features])
+          ::Turso::AR::Connection.new(db_config)
+        end
         end
 
         def active?
-          @raw_connection && !@raw_connection.closed?
+          return false unless @raw_connection
+          !@raw_connection.closed?
         rescue ::Turso::Error
           false
         end
@@ -52,19 +54,18 @@ module ActiveRecord
             execute("PRAGMA journal_mode = #{mode}")
             if @config[:journal_mode].to_s.downcase == "mvcc"
               @mvcc_enabled = true
+              ActiveRecord::Base.logger&.warn(
+                "Turso journal_mode: mvcc is experimental. Concurrent transactions require careful connection handling."
+              )
             end
           end
 
           execute("PRAGMA foreign_keys = ON")
 
-          if @config[:timeout] || @config[:busy_timeout]
-            timeout = @config[:busy_timeout] || @config[:timeout]
-            @raw_connection.busy_timeout = timeout
-          end
+          timeout = @config[:busy_timeout] || @config[:timeout] || 5000
+          @raw_connection.busy_timeout = timeout
+
 
-          if @config[:query_timeout]
-            @raw_connection.query_timeout = @config[:query_timeout]
-          end
         end
       end
     end

data/lib/active_record/connection_adapters/turso_adapter/database_statements.rb

@@ -6,42 +6,7 @@ module ActiveRecord
       module DatabaseStatements
         def execute(sql, name = nil)
           materialize_transactions
-          raw_execute(sql, name)
-        end
-
-        def exec_query(sql, name = "SQL", binds = [], prepare: false)
-          materialize_transactions
-
-          type_casted_binds = type_casted_binds(binds)
-          log(sql, name, binds, type_casted_binds) do
-            with_raw_connection do |conn|
-              stmt = conn.prepare(sql)
-              stmt.bind_positional(type_casted_binds) unless type_casted_binds.empty?
-              result = build_result(stmt)
-              stmt.finalize
-              result
-            end
-          end
-        end
-
-        def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil, returning = nil)
-          if returning && supports_insert_returning?
-            return exec_query(sql, name, binds)
-          end
-
-          materialize_transactions
-
-          type_casted_binds = type_casted_binds(binds)
-          log(sql, name, binds, type_casted_binds) do
-            with_raw_connection do |conn|
-              stmt = conn.prepare(sql)
-              stmt.bind_positional(type_casted_binds) unless type_casted_binds.empty?
-              stmt.execute
-              last_id = pk ? last_inserted_id(sql) : nil
-              stmt.finalize
-              last_id
-            end
-          end
+          raw_execute(sql, name)&.to_a
         end
 
         def last_inserted_id(sql)
@@ -60,22 +25,13 @@ module ActiveRecord
           binds
         end
 
-        def select_rows(arel, name = nil)
+        def select_rows(arel, name = nil, binds = [], _options = {})
           arel = arel_from_relation(arel)
-          sql, binds = to_sql_and_binds(arel)
+          sql, binds = to_sql_and_binds(arel, binds)
           type_casted_binds = type_casted_binds(binds)
 
           log(sql, name, binds, type_casted_binds) do
-            with_raw_connection do |conn|
-              stmt = conn.prepare(sql)
-              stmt.bind_positional(type_casted_binds) unless type_casted_binds.empty?
-              rows = []
-              while stmt.step == 1
-                rows << stmt.row.to_a
-              end
-              stmt.finalize
-              rows
-            end
+            exec_query(sql, name, binds, prepare: false).rows
           end
         end
 
@@ -85,22 +41,36 @@ module ActiveRecord
             return ActiveRecord::Result.empty(affected_rows: 0)
           end
 
-          if write_query?(sql)
-            raw_connection.execute(sql, type_casted_binds)
-            affected_rows = raw_connection.changes
-            verified!
-            notification_payload[:affected_rows] = affected_rows
-            notification_payload[:row_count] = 0
-            ActiveRecord::Result.empty(affected_rows: affected_rows)
+          stmt = if prepare
+            @statements[sql] ||= raw_connection.prepare(sql)
           else
-            result = raw_connection.query(sql, type_casted_binds)
-            columns = result.column_names
-            rows = result.map(&:values)
-            affected_rows = raw_connection.changes
-            verified!
-            notification_payload[:affected_rows] = affected_rows
-            notification_payload[:row_count] = rows.length
-            ActiveRecord::Result.new(columns, rows, nil, affected_rows: affected_rows)
+            raw_connection.prepare(sql)
+          end
+
+          stmt.reset if prepare
+          stmt.bind(*type_casted_binds) unless type_casted_binds.empty?
+
+          begin
+            if write_query?(sql) && !sql.match?(/\bRETURNING\b/i)
+              result = stmt.run
+              affected_rows = result[:changes]
+              verified!
+              notification_payload[:affected_rows] = affected_rows
+              notification_payload[:row_count] = 0
+              ActiveRecord::Result.empty(affected_rows: affected_rows)
+            else
+              columns_info = stmt.columns
+              columns = columns_info.map { |c| c[:name] }
+              rows = stmt.all.map(&:to_a)
+              affected_rows = raw_connection.changes
+              verified!
+              notification_payload[:affected_rows] = affected_rows
+              notification_payload[:row_count] = rows.length
+              type_map = build_type_map(stmt)
+              ActiveRecord::Result.new(columns, rows, type_map, affected_rows: affected_rows)
+            end
+          ensure
+            stmt.close unless prepare
           end
         end
 
@@ -109,11 +79,11 @@ module ActiveRecord
           old_defer_foreign_keys = query_value("PRAGMA defer_foreign_keys")
 
           begin
-            execute("PRAGMA defer_foreign_keys = ON")
+            execute("PRAGMA defer_foreign_keys = ON") unless old_defer_foreign_keys.nil?
             execute("PRAGMA foreign_keys = OFF")
             yield
           ensure
-            if old_defer_foreign_keys
+            unless old_defer_foreign_keys.nil?
               execute("PRAGMA defer_foreign_keys = #{old_defer_foreign_keys}")
             end
             execute("PRAGMA foreign_keys = #{old_foreign_keys}")
@@ -122,21 +92,10 @@ module ActiveRecord
 
         private
 
-        def build_result(stmt)
-          columns = (0...stmt.column_count).map { |i| stmt.column_name(i) }
-          type_map = build_type_map(stmt)
-          rows = []
-          while stmt.step == 1
-            rows << stmt.row.to_a
-          end
-          ActiveRecord::Result.new(columns, rows, type_map)
-        end
-
         def build_type_map(stmt)
           type_map = {}
-          count = stmt.column_count
-          count.times do |i|
-            decltype = stmt.respond_to?(:column_decltype) ? stmt.column_decltype(i) : nil
+          stmt.columns.each_with_index do |col, i|
+            decltype = col[:type]
             next unless decltype
             type_map[i] = decltype_to_type(decltype)
           end

data/lib/active_record/connection_adapters/turso_adapter/error_translation.rb

@@ -7,15 +7,23 @@ module ActiveRecord
         def translate_exception(exception, message:, sql:, binds:)
           cause = exception.cause
           case cause
-          when ::Turso::ConstraintError
+          when ::Turso::ConstraintException
             translate_constraint_error(message, sql, binds)
-          when ::Turso::NotADatabaseError
+          when ::Turso::NotADatabaseException
             ActiveRecord::NoDatabaseError.new(message, sql: sql, binds: binds)
-          when ::Turso::BusySnapshotError
+          when ::Turso::BusySnapshotException
             ActiveRecord::SerializationFailure.new(message, sql: sql, binds: binds)
-          when ::Turso::BusyError
+          when ::Turso::BusyException
             ActiveRecord::Deadlocked.new(message, sql: sql, binds: binds)
-          when ::Turso::ReadonlyError
+          when ::Turso::ReadonlyException
+            ActiveRecord::ReadOnlyRecord.new(message, sql: sql, binds: binds)
+          when ::Turso::IoException, ::Turso::CorruptException
+            ActiveRecord::StatementInvalid.new(message, sql: sql, binds: binds)
+          when ::Turso::DatabaseFullException
+            ActiveRecord::StatementInvalid.new(message, sql: sql, binds: binds)
+          when ::Turso::InterruptException
+            ActiveRecord::QueryCanceled.new(message, sql: sql, binds: binds)
+          when ::Turso::MisuseException
             ActiveRecord::StatementInvalid.new(message, sql: sql, binds: binds)
           else
             super
@@ -26,7 +34,7 @@ module ActiveRecord
 
         def translate_constraint_error(message, sql, binds)
           case message
-          when /foreign key constraint/i
+          when /foreign key constraint|foreign key mismatch/i
             ActiveRecord::InvalidForeignKey.new(message, sql: sql, binds: binds)
           when /unique constraint|primary key/i
             ActiveRecord::RecordNotUnique.new(message, sql: sql, binds: binds)

data/lib/active_record/connection_adapters/turso_adapter/schema_statements.rb

@@ -11,6 +11,7 @@ module ActiveRecord
               AND name NOT LIKE 'sqlite_%'
               AND name NOT LIKE 'fts_dir_%'
               AND name NOT LIKE 'sqlite_fts_%'
+              AND name NOT LIKE '__turso_internal_%'
           SQL
         end
 
@@ -75,6 +76,16 @@ module ActiveRecord
           SQL
         end
 
+        def fts_match(_table_name, columns, query)
+          cols = Array(columns).map { |c| quote_table_name(c) }.join(", ")
+          Arel.sql("fts_match(#{cols}, #{quote(query)})")
+        end
+
+        def fts_score(_table_name, columns, query)
+          cols = Array(columns).map { |c| quote_table_name(c) }.join(", ")
+          Arel.sql("fts_score(#{cols}, #{quote(query)})")
+        end
+
         private
 
         def options_to_fts_options(options)

data/lib/active_record/connection_adapters/turso_adapter/statement_pool.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    class TursoAdapter < SQLite3Adapter
+      class StatementPool < ConnectionAdapters::StatementPool
+        alias reset clear
+
+        private
+
+        def dealloc(stmt)
+          stmt.close
+        rescue ::Turso::Error
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/turso_adapter/transaction_management.rb

@@ -34,6 +34,10 @@ module ActiveRecord
 
         def transaction(requires_new: nil, isolation: nil, joinable: true, **options, &block)
           if options.delete(:concurrent)
+            ActiveRecord::Base.logger&.warn(
+              "transaction(concurrent: true) is experimental and may break ActiveRecord model persistence. " \
+              "See adapter documentation."
+            )
             transaction_with_mvcc(options, &block)
           else
             super
@@ -43,35 +47,61 @@ module ActiveRecord
         private
 
         def transaction_with_mvcc(options, &block)
+          connect if @raw_connection.nil?
+
           unless @mvcc_enabled
             raise ActiveRecord::AdapterError,
                   "transaction(concurrent: true) requires journal_mode: 'mvcc' in database.yml"
           end
 
+          if options[:requires_new] == false
+            raise ActiveRecord::AdapterError,
+                  "transaction(concurrent: true) is incompatible with nested transactions"
+          end
+
           max_retries = @config.fetch(:concurrent_retry_limit, 50)
           base_delay_ms = @config.fetch(:concurrent_retry_base_ms, 2)
           retries = 0
+          pinned_connection_id = @raw_connection.object_id
 
           loop do
             begin
-              raw_execute("BEGIN CONCURRENT", "TRANSACTION")
-              yield
-              raw_execute("COMMIT", "TRANSACTION")
-              return
+              @raw_connection.execute("BEGIN CONCURRENT")
+              result = yield
+              @raw_connection.execute("COMMIT")
+              return result
             rescue ActiveRecord::StatementInvalid => e
-              raw_execute("ROLLBACK", "TRANSACTION") rescue nil
+              rollback_if_active
               raise unless concurrent_conflict?(e) && retries < max_retries
 
               retries += 1
-              sleep(base_delay_ms * retries / 1000.0)
+              verified!
+              backoff(base_delay_ms, retries)
+
+              unless @raw_connection.object_id == pinned_connection_id
+                raise ActiveRecord::AdapterError,
+                      "MVCC retry detected a different database connection. " \
+                      "transaction(concurrent: true) must run on a pinned connection."
+              end
             end
           end
         end
 
         def concurrent_conflict?(exception)
-          exception.cause.is_a?(::Turso::BusySnapshotError) ||
-            exception.cause.is_a?(::Turso::BusyError) ||
-            /snapshot conflict|busy snapshot|database is locked/i.match?(exception.message)
+          cause = exception.cause
+          conflict_classes = [::Turso::BusySnapshotException, ::Turso::BusyException]
+
+          conflict_classes.any? { |klass| cause.is_a?(klass) } ||
+            /snapshot conflict|busy snapshot|database is locked|cannot start a transaction within a transaction/i.match?(exception.message)
+        end
+
+        def rollback_if_active
+          return unless @raw_connection && !@raw_connection.closed?
+          @raw_connection.execute("ROLLBACK") rescue nil
+        end
+
+        def backoff(base_delay_ms, retries)
+          sleep(base_delay_ms * retries / 1000.0)
         end
 
         def savepoint_name(name)

data/lib/active_record/connection_adapters/turso_adapter.rb

@@ -2,7 +2,9 @@
 
 require "active_record/connection_adapters/sqlite3_adapter"
 
-Dir[File.expand_path("turso_adapter/*.rb", __dir__)].each { |f| require f }
+require_relative "turso_adapter/statement_pool"
+
+Dir[File.expand_path("turso_adapter/*.rb", __dir__)].sort.each { |f| require f }
 
 module ActiveRecord
   module ConnectionAdapters
@@ -23,6 +25,10 @@ module ActiveRecord
         false
       end
 
+      def sqlite_version
+        @sqlite_version ||= Gem::Version.new(query_value("SELECT sqlite_version()"))
+      end
+
       def supports_transaction_isolation?
         false
       end
@@ -35,14 +41,20 @@ module ActiveRecord
         true
       end
 
-      def explain(arel, binds = [])
+      def quote_string(s)
+        s.gsub("'", "''")
+      end
+
+      def explain(arel, binds = [], _options = [])
         sql = "EXPLAIN QUERY PLAN " + to_sql(arel, binds)
         result = exec_query(sql, "EXPLAIN", binds)
-        SQLite3::ExplainPrettyPrinter.new.pp(result)
+        result.rows.map do |row|
+          row.join(" | ")
+        end.join("\n")
       end
 
-      def default_prepared_statements
-        false
+      def build_statement_pool
+        StatementPool.new(self.class.type_cast_config_to_integer(@config[:statement_limit]))
       end
 
       def database_file_exists?
@@ -69,6 +81,7 @@ module ActiveRecord
       def initialize_type_map(m)
         super
         m.register_type(%r(boolean)i, Type::Boolean.new)
+        m.register_type(%r(json)i, Type::Json.new)
       end
     end
   end

data/lib/activerecord-turso/version.rb

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

data/lib/turso/ar/connection.rb

@@ -9,15 +9,21 @@ module Turso
 
       def_delegators :@db, :close, :closed?, :changes, :total_changes
 
+      DEFAULT_BUSY_TIMEOUT_MS = 5000
+      DEFAULT_QUERY_TIMEOUT_MS = 30_000
+
       def initialize(config)
         @config = config
-        @db = ::Turso::DB.new(config[:database].to_s,
-          busy_timeout: config[:busy_timeout] || config[:timeout],
-          query_timeout: config[:query_timeout])
+        db_opts = {
+          busy_timeout: config[:busy_timeout] || config[:timeout] || DEFAULT_BUSY_TIMEOUT_MS,
+          query_timeout: config[:query_timeout] || DEFAULT_QUERY_TIMEOUT_MS
+        }
+        db_opts[:experimental_features] = config[:experimental_features] if config[:experimental_features]
+        @db = ::Turso::Database.new(config[:database].to_s, **db_opts)
       end
 
       def last_insert_rowid
-        query("SELECT last_insert_rowid()").first&.values&.first.to_i
+        query("SELECT last_insert_rowid()").first&.to_a&.first.to_i
       end
 
       def raw_connection
@@ -33,39 +39,116 @@ module Turso
       end
 
       def execute(sql, binds = [])
-        @db.execute(sql, normalize_binds(binds))
+        @db.execute(sql, *normalize_binds(binds))
         nil
       end
 
       def query(sql, params = [])
-        @db.query(sql, normalize_binds(params))
+        @db.query(sql, *normalize_binds(params))
       end
 
       def execute_batch(sql)
-        sql.split(";").each do |stmt|
-          s = stmt.strip
-          @db.execute(s) unless s.empty?
+        split_batch(sql).each do |stmt|
+          @db.execute(stmt)
         end
       end
 
       def prepare(sql)
-        @db.instance_variable_get(:@database).connection.prepare(sql)
+        @db.prepare(sql)
       end
 
       def busy_timeout=(ms)
         @db.busy_timeout = ms.to_i
       end
 
-      def query_timeout=(ms)
-        @db.query_timeout = ms.to_i
-      end
-
       def interrupt
         @db.interrupt
       end
 
       private
 
+      def split_batch(sql)
+        statements = []
+        current = +""
+        in_string = false
+        in_line_comment = false
+        in_block_comment = false
+        i = 0
+        while i < sql.length
+          char = sql[i]
+          next_char = sql[i + 1]
+
+          if in_line_comment
+            if char == "\n"
+              in_line_comment = false
+            end
+            i += 1
+            next
+          end
+
+          if in_block_comment
+            if char == "*" && next_char == "/"
+              in_block_comment = false
+              i += 2
+            else
+              i += 1
+            end
+            next
+          end
+
+          if in_string
+            if char == "'" && next_char == "'"
+              current << char << next_char
+              i += 2
+              next
+            elsif char == "'"
+              in_string = false
+              current << char
+              i += 1
+              next
+            end
+            current << char
+            i += 1
+            next
+          end
+
+          case char
+          when "'"
+            in_string = true
+            current << char
+          when "-"
+            if next_char == "-"
+              in_line_comment = true
+              i += 2
+              next
+            end
+            current << char
+          when "#"
+            in_line_comment = true
+            i += 1
+            next
+          when "/"
+            if next_char == "*"
+              in_block_comment = true
+              i += 2
+              next
+            end
+            current << char
+          when ";"
+            stmt = current.strip
+            statements << stmt unless stmt.empty?
+            current = +""
+          else
+            current << char
+          end
+          i += 1
+        end
+
+        stmt = current.strip
+        statements << stmt unless stmt.empty?
+        statements
+      end
+
       def normalize_binds(binds)
         binds.map do |value|
           case value

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-turso
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Ben D'Angelo
@@ -43,6 +43,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.1'
+- !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: []
 extra_rdoc_files: []
@@ -53,8 +67,10 @@ files:
 - lib/active_record/connection_adapters/turso_adapter/database_statements.rb
 - lib/active_record/connection_adapters/turso_adapter/error_translation.rb
 - lib/active_record/connection_adapters/turso_adapter/schema_statements.rb
+- lib/active_record/connection_adapters/turso_adapter/statement_pool.rb
 - lib/active_record/connection_adapters/turso_adapter/transaction_management.rb
 - lib/activerecord-turso.rb
+- lib/activerecord-turso/version.rb
 - lib/turso/ar/connection.rb
 licenses:
 - MIT
@@ -66,7 +82,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:
   - - ">="