Allow databases to be shareable but only in full-mutex mode

  https://www.sqlite.org/threadsafe.html

"Full mutex" mode is the only time when a SQLite database can be shared
between multiple threads.  Multi-thread mode only means that multiple
threads can have their own instances of a database object that point at
the same file, but multiple threads cannot access the object
concurrently.

Author: tenderlove

ext/sqlite3/database.c

@@ -158,6 +158,10 @@ rb_sqlite3_open_v2(VALUE self, VALUE file, VALUE mode, VALUE zvfs)
         ctx->flags |= SQLITE3_RB_DATABASE_READONLY;
     }
 
+    if (flags & SQLITE_OPEN_FULLMUTEX) {
+        FL_SET_RAW(self, RUBY_FL_SHAREABLE);
+    }
+
     return self;
 }
 

lib/sqlite3/database.rb

@@ -181,7 +181,7 @@ def initialize file, options = {}, zvfs = nil
 
       initialize_extensions(options[:extensions])
 
-      ForkSafety.track(self)
+      ForkSafety.track(self) if Ractor.main?
 
       if block_given?
         begin

test/test_integration_ractor.rb

@@ -44,37 +44,16 @@ def test_ractor_share_database
     end
   end
 
-  def test_ractor_stress
-    skip("Requires Ruby with Ractors") unless SQLite3.ractor_safe?
-
-    # Testing with a file instead of :memory: since it can be more realistic
-    # compared with real production use, and so discover problems that in-
-    # memory testing won't find. Trivial example: STRESS_DB_NAME needs to be
-    # frozen to pass into the Ractor, but :memory: might avoid that problem by
-    # using a literal string.
-    db = SQLite3::Database.open(STRESS_DB_NAME)
-    db.execute("PRAGMA journal_mode=WAL") # A little slow without this
-    db.execute("create table stress_test (a integer primary_key, b text)")
-    random = Random.new.freeze
-    ractors = (0..9).map do |ractor_number|
-      Ractor.new(random, ractor_number) do |random, ractor_number|
-        db_in_ractor = SQLite3::Database.open(STRESS_DB_NAME)
-        db_in_ractor.busy_handler do
-          sleep random.rand / 100 # Lots of busy errors happen with multiple concurrent writers
-          true
-        end
-        100.times do |i|
-          db_in_ractor.execute("insert into stress_test(a, b) values (#{ractor_number * 100 + i}, '#{random.rand}')")
-        end
-      end
-    end
-    ractors.each { |r| r.take }
-    final_check = Ractor.new do
-      db_in_ractor = SQLite3::Database.open(STRESS_DB_NAME)
-      res = db_in_ractor.execute("select count(*) from stress_test")
-      Ractor.yield res
-    end
-    res = final_check.take
-    assert_equal 1000, res[0][0]
+  def test_shareable_db
+    # databases are shareable between ractors, but only if they're opened
+    # in "full mutex" mode
+    db = SQLite3::Database.new ":memory:",
+      flags: SQLite3::Constants::Open::FULLMUTEX |
+      SQLite3::Constants::Open::READWRITE |
+      SQLite3::Constants::Open::CREATE
+    assert Ractor.shareable?(db)
+
+    db = SQLite3::Database.new ":memory:"
+    refute Ractor.shareable?(db)
   end
 end