activerecord-beagle-turso 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51cf88616ac49583385f9d993560cc4f5fb53169707dec16c68b3c37f6d60884
-  data.tar.gz: 21732cc614964877aeca0da6e34d066cfcfb2061747ac68f9eb2803abff60d1a
+  metadata.gz: cd2ebde88afce8658ba27c6a8ae41ffb3228e6ec7bb6c65be6ff0a5a1c56d6ec
+  data.tar.gz: 2c6ac050108dd08d75808fb5aa28854164f91835c6529ff400ff97351d81c449
 SHA512:
-  metadata.gz: fe0832ec4ae1acc466934cb0ed1a0c47f2de5e5d5f86b47091ffbe1c5e8f77c86ee50534808d2cf7dbef318aa526cd0026146ac367d1c3f56275723d8630ccc3
-  data.tar.gz: bf86e7af654df142cd722228c9245bd5456b6cfd9b2de5a43ae9067e018fee5491e17005896eec7f693ef0fc9e8d9bd9ac1d5791033bfff579879562fd69d1b9
+  metadata.gz: 0cc05e0873fd0a0d143c2bae7758320768b06bdca6f6cd676de504cc09bc61360877aa81fa7d4b88ca7836758103135d3056d15cc5587721481b826fd9d0855c
+  data.tar.gz: d0be294e7c35be6e5275cbbbcb54e80546ddb1b4c30a6f6ea32b72ec88c8554eded57b6537e128581ce599c3d1c173e49c443f7ca4e88ba7366641d351b9916d

data/README.md

@@ -63,6 +63,13 @@ some diagnostics, but these are custom `database.yml` keys, so that masking
 does not cover them automatically. Source them from encrypted credentials or
 `ENV`, as above, and avoid logging/inspecting the raw connection config.
 
+`timeout:` (milliseconds, as in the stock SQLite adapter; Rails' generated
+`database.yml` sets 5000) is how long a write waits for another connection's
+transaction to finish before raising `Beagle::Turso::BusyError`. Transactions
+begin with `BEGIN IMMEDIATE`, so a writer waits at `BEGIN`, never part-way
+through. The wait sleeps in Ruby, so other threads and fibers keep running.
+Without `timeout:` (or with 0), a busy write raises at once.
+
 An optional `bootstrap_if_empty:` (default `true`) controls whether a brand
 new/empty local file is populated from the remote on first open — see
 `Beagle::Turso::Database.open`.

data/lib/active_record/connection_adapters/beagle_turso_adapter.rb

@@ -111,9 +111,10 @@ module ActiveRecord
         attr_reader :database, :connection
 
         def initialize(database)
-          @database   = database
-          @connection = database.connect
-          @closed     = false
+          @database     = database
+          @connection   = database.connect
+          @closed       = false
+          @busy_timeout = nil
         end
 
         # A bare read of exactly +defer_foreign_keys+ or +read_uncommitted+
@@ -181,11 +182,39 @@ module ActiveRecord
         def push = database.push
         def pull = database.pull
 
-        # --- sqlite3-gem lifecycle shims the SQLite3Adapter drives ---
-        # configure_connection only touches this when config[:timeout] is set.
-        def busy_handler_timeout=(_)
-          nil
+        # --- busy handling ---
+        # configure_connection passes database.yml's `timeout:` (ms) here, as it
+        # does to the sqlite3 gem's busy handler. Unset or 0 means no waiting:
+        # a BusyError surfaces at once, as with the sqlite3 gem.
+        def busy_handler_timeout=(milliseconds)
+          @busy_timeout = milliseconds.to_i.positive? ? milliseconds.to_i / 1000.0 : nil
         end
+
+        # Retries a statement that lost the single-writer race, with capped
+        # exponential backoff, for up to the busy timeout. The engine never
+        # waits for a lock itself (from beagle-turso 0.4.0 it raises at once),
+        # so this is where the wait happens. sleep releases the GVL and yields
+        # to a fiber scheduler, so the writer holding the lock can finish. The
+        # caller decides what is safe to retry (see BeagleTursoAdapter#perform_query).
+        def retry_busy
+          deadline = nil
+          delay = 0.002
+          begin
+            yield
+          rescue ::Beagle::Turso::BusyError => e
+            raise if @busy_timeout.nil? || e.message.include?("snapshot is stale")
+
+            now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            deadline ||= now + @busy_timeout
+            raise if now + delay > deadline
+
+            sleep delay
+            delay = [delay * 2, 0.1].min
+            retry
+          end
+        end
+
+        # --- sqlite3-gem lifecycle shims the SQLite3Adapter drives ---
         # connected? => !(@raw_connection.nil? || @raw_connection.closed?)
         def closed? = @closed
         # Release the beagle-turso session eagerly rather than waiting for GC.
@@ -356,26 +385,10 @@ module ActiveRecord
             if batch
               raw_connection.execute_batch(sql)
               ::ActiveRecord::Result.empty
-            elsif write_statement?(sql)
-              if (rewritten = sql_with_returning_rowid(sql))
-                insert_returning_rowid(raw_connection, rewritten, params)
-              else
-                affected = raw_connection.execute(sql, params)
-                @last_inserted_rowid = raw_connection.last_insert_rowid
-                ::ActiveRecord::Result.empty(affected_rows: affected)
-              end
+            elsif busy_retry?(sql)
+              raw_connection.retry_busy { run_statement(raw_connection, sql, params) }
             else
-              columns, rows = raw_connection.query_result(sql, params)
-              # Belt-and-suspenders: a RETURNING insert lands here (id read from
-              # rows by last_inserted_id), and a data-modifying CTE that slips past
-              # write_statement? would too -- keep the rowid so an inserted id is
-              # never silently lost even on a heuristic miss.
-              if INSERT_REGEX.match?(sql)
-                # On a replica where last_insert_rowid is untrustworthy, never
-                # offer it as a fallback id (a RETURNING insert's id is in rows).
-                @last_inserted_rowid = insert_returning_rowid? ? nil : raw_connection.last_insert_rowid
-              end
-              ::ActiveRecord::Result.new(columns, rows)
+              run_statement(raw_connection, sql, params)
             end
 
           verified!
@@ -384,6 +397,43 @@ module ActiveRecord
           result
         end
 
+        # A busy statement is retried only when that is safe: the BEGIN that
+        # opens a transaction (Rails sends BEGIN IMMEDIATE, so a writer waits
+        # for the lock there rather than failing mid-way), or a statement
+        # outside any transaction. Inside one, a BusyError means the
+        # transaction is dead; it must surface and roll back. A multi-statement
+        # batch is never retried (it may have run in part).
+        BEGIN_REGEX = /\A\s*BEGIN\b/i
+        private_constant :BEGIN_REGEX
+
+        def busy_retry?(sql)
+          !transaction_open? || BEGIN_REGEX.match?(mask_non_code(sql))
+        end
+
+        def run_statement(raw_connection, sql, params)
+          if write_statement?(sql)
+            if (rewritten = sql_with_returning_rowid(sql))
+              insert_returning_rowid(raw_connection, rewritten, params)
+            else
+              affected = raw_connection.execute(sql, params)
+              @last_inserted_rowid = raw_connection.last_insert_rowid
+              ::ActiveRecord::Result.empty(affected_rows: affected)
+            end
+          else
+            columns, rows = raw_connection.query_result(sql, params)
+            # Belt-and-suspenders: a RETURNING insert lands here (id read from
+            # rows by last_inserted_id), and a data-modifying CTE that slips past
+            # write_statement? would too -- keep the rowid so an inserted id is
+            # never silently lost even on a heuristic miss.
+            if INSERT_REGEX.match?(sql)
+              # On a replica where last_insert_rowid is untrustworthy, never
+              # offer it as a fallback id (a RETURNING insert's id is in rows).
+              @last_inserted_rowid = insert_returning_rowid? ? nil : raw_connection.last_insert_rowid
+            end
+            ::ActiveRecord::Result.new(columns, rows)
+          end
+        end
+
         # Route to the WRITE branch (execute -> affected count + last_insert_rowid)
         # rather than the read branch. A statement is a write when SQLite3's own
         # read/write classifier says so, OR when it is a data-modifying CTE that

data/lib/activerecord/beagle_turso/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveRecord
   module BeagleTurso
-    VERSION = "0.1.7"
+    VERSION = "0.1.8"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-beagle-turso
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - BeagleSoftwareUK
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement