activerecord-enhancedsqlite3-adapter 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd134c96488a861c3fdc36c32396547a31ea596c11243aff923995acff8ae4b5
-  data.tar.gz: d2029b2162c66df5689e65cb4e281f73d21049adafaecf9bbf78490570a10321
+  metadata.gz: e0d679b0ee45b0838fc294f50e43b806301fba662e54f280b3d0e747de3e7670
+  data.tar.gz: 5b345ff772a3cba527a4fe638724bb372f488bc8ec3ceb4d3e8b76ee40b2f434
 SHA512:
-  metadata.gz: 6803168a5f067839e6ea7416f2f067bbc044202d14fd21a9536d068bebe35d7d89a481cbfcf5e230d4063705a7b5241aeb76d8f92846e2ecf5cdc2afa8b805f0
-  data.tar.gz: 2845ea0983129dd0e6e66b66e8f10fca3538192dcdaec62ec55f497ebb8f82f52bdc2352eb1fdf85b859bbd7436e86b57d15da4ce1135c00e23f8996db5cfc59
+  metadata.gz: 47288376cd918173cce7edf28fc2a8cbb8a86c749aa44aaf88e4b2f81fc922b3b5369e579abb8e9bab7585f7c8b2ae732c3f6a8601117e935a61effcf7d86276
+  data.tar.gz: 22ae8604263b8a75379a0f9c132d60cf4616d6695665742b4a6a358f24f0fa4daf1b5b1708ecf5599617293bc4a8fc76db89fbd204deaa70b430233db2f6891a

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
+## [0.6.0] - 2024-04-10
+
+- Use the same busy_handler function as will be in the sqlite3-ruby gem ([@fractaledmind](https://github.com/fractaledmind/activerecord-enhancedsqlite3-adapter/pull/11))
+- Allow for isolated reading and writing connection pools ([@fractaledmind](https://github.com/fractaledmind/activerecord-enhancedsqlite3-adapter/pull/12))
+- Ensure that even Rails 7.0 apps can use insert returning ([@fractaledmind](https://github.com/fractaledmind/activerecord-enhancedsqlite3-adapter/pull/8))
+- Load virtual columns extension only if the app is running 7.1 or less ([@npezza93](https://github.com/fractaledmind/activerecord-enhancedsqlite3-adapter/pull/7))
+
+## [0.5.0] - 2023-12-24
+
+- Load extensions installed via project-scoped `sqlpkg`
+
 ## [0.4.0] - 2023-12-10
 
 - Ensure transactions are IMMEDIATE and not DEFERRED

data/README.md

@@ -21,6 +21,14 @@ This gem hooks into your Rails application to enhance the `SQLite3Adapter` autom
 
 Once installed, you can take advantage of the added features.
 
+### Configuration
+
+One optional advanced feature is to have this gem isolate reading and writing connection pools. This is useful if you have a large amount of write operations and want to avoid blocking reads.
+
+You can configure this gem via the Rails configuration object, under the `enhanced_sqlite3` key. Currently, only 1 configuration option is available:
+
+* `isolate_connection_pools` - Whether or not to isolate reading from writing connection pools. See [below](#isolated-connection-pools) for more information.
+
 ### Generated columns
 
 You can now create `virtual` columns, both stored and dynamic. The [SQLite docs](https://www.sqlite.org/gencol.html) explain the difference:
@@ -81,6 +89,25 @@ default: &default
     - sqlite_ulid
 ```
 
+### Isolated connection pools
+
+By default, Rails uses a single connection pool for both reading and writing. This can lead to contention if you have a large number of write operations. This gem allows you to isolate the connection pools for reading and writing.
+
+To enable this feature, set the `isolate_connection_pools` configuration option to `true` in your `config/environments/*.rb` file or `config/application.rb` file:
+
+```ruby
+config.enhanced_sqlite3.isolate_connection_pools = true
+```
+
+If enabled, the gem will patch your application in 3 ways:
+
+1. define separate `reader` and `writer` database configurations
+2. activate Rails' automatic role database switching middleware, defaulting all requests to the `reader` connection pool
+3. patch the ActiveRecord `#transaction` method to switch to the `writer` connection pool for write operations
+4. patch the ActiveRecord `#log` method to log the database name for each database operation
+
+This feature is experimental and may not work with all Rails configurations. Please report any issues you encounter.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/activerecord-enhancedsqlite3-adapter.rb

@@ -1,3 +1,15 @@
 require "active_record"
 require "enhanced_sqlite3/version"
 require "enhanced_sqlite3/railtie"
+
+module EnhancedSQLite3
+  Error = Class.new(StandardError)
+
+  mattr_writer :isolate_connection_pools
+
+  class << self
+    def isolate_connection_pools?
+      @isolate_connection_pools ||= @@isolate_connection_pools || false
+    end
+  end
+end

data/lib/enhanced_sqlite3/adapter.rb

@@ -46,8 +46,25 @@ module EnhancedSQLite3
       configure_pragmas
       configure_extensions
 
-      EnhancedSQLite3::SupportsVirtualColumns.apply!
-      EnhancedSQLite3::SupportsDeferrableConstraints.apply!
+      EnhancedSQLite3::SupportsVirtualColumns.apply! unless try(:supports_virtual_columns?)
+      EnhancedSQLite3::SupportsDeferrableConstraints.apply! unless try(:supports_deferrable_constraints?)
+    end
+
+    # Patch the #transaction method to ensure that all transactions are sent to the writing role database connection pool.
+    def transaction(...)
+      ActiveRecord::Base.connected_to(role: ActiveRecord.writing_role, prevent_writes: false) do
+        super(...)
+      end
+    end
+
+    # Patch the #log method to ensure that all log messages are tagged with the database connection name.
+    def log(...)
+      db_connection_name = ActiveRecord::Base.connection_db_config.name
+      if Rails.logger.formatter.current_tags.include? db_connection_name
+        super
+      else
+        Rails.logger.tagged(db_connection_name) { super }
+      end
     end
 
     private

data/lib/enhanced_sqlite3/railtie.rb

@@ -2,16 +2,63 @@
 
 require "rails/railtie"
 require "enhanced_sqlite3/adapter"
+require "enhanced_sqlite3/resolver"
 
 module EnhancedSQLite3
   class Railtie < ::Rails::Railtie
+    config.enhanced_sqlite3 = ActiveSupport::OrderedOptions.new
+
+    initializer "enhanced_sqlite3.config" do
+      config.enhanced_sqlite3.each do |name, value|
+        EnhancedSQLite3.public_send(:"#{name}=", value)
+      end
+    end
+
     # Enhance the SQLite3 ActiveRecord adapter with optimized defaults
     initializer "enhanced_sqlite3.enhance_active_record_sqlite3adapter" do |app|
       ActiveSupport.on_load(:active_record_sqlite3adapter) do
-        # self refers to `SQLite3Adapter` here,
-        # so we can call .prepend
+        # self refers to `SQLite3Adapter` here
         prepend EnhancedSQLite3::Adapter
       end
     end
+
+    # Enhance the application with isolated reading and writing connection pools
+    initializer "enhanced_sqlite3.setup_isolated_connection_pools" do |app|
+      next unless EnhancedSQLite3.isolate_connection_pools?
+
+      ActiveSupport.on_load(:active_record) do
+        # self refers to `ActiveRecord::Base` here
+        env_configs = configurations.configs_for env_name: Rails.env
+        remaining_configs = configurations.configurations.reject { |configuration| env_configs.include? configuration }
+        if env_configs.one?
+          config = env_configs.first
+          reader = ActiveRecord::DatabaseConfigurations::HashConfig.new(
+            Rails.env, "reader", config.configuration_hash.merge(readonly: true)
+          )
+          writer = ActiveRecord::DatabaseConfigurations::HashConfig.new(
+            Rails.env, "writer", config.configuration_hash.merge(pool: 1)
+          )
+
+          # Replace the single production configuration with two separate reader and writer configurations
+          self.configurations = remaining_configs + [reader, writer]
+        else
+          reader = env_configs.find { |config| config.name == "reader" }
+          writer = env_configs.find { |config| config.name == "writer" }
+
+          # Ensure that that there is a reader and writer configuration for the current Rails environment
+          raise Error.new("#{Rails.env} has #{env_configs.size} configurations") unless reader && writer
+        end
+
+        connects_to database: {writing: :writer, reading: :reader}
+      end
+
+      # Since we aren't actually using separate databases, only separate connections,
+      # we don't need to ensure that requests "read your own writes" with a `delay`
+      config.active_record.database_selector = {delay: 0}
+      # Use our custom resolver to ensure that benchmarking requests are sent to the reading database connection
+      config.active_record.database_resolver = EnhancedSQLite3::Resolver
+      # Keep Rails' default resolver context
+      config.active_record.database_resolver_context = ActiveRecord::Middleware::DatabaseSelector::Resolver::Session
+    end
   end
 end

data/lib/enhanced_sqlite3/resolver.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module EnhancedSQLite3
+  class Resolver < ActiveRecord::Middleware::DatabaseSelector::Resolver
+    def reading_request?(request)
+      true
+    end
+  end
+end

data/lib/enhanced_sqlite3/version.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module EnhancedSQLite3
-  VERSION = "0.4.0"
+  VERSION = "0.6.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-enhancedsqlite3-adapter
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Stephen Margheim
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-12-10 00:00:00.000000000 Z
+date: 2024-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -111,6 +111,7 @@ files:
 - lib/activerecord-enhancedsqlite3-adapter.rb
 - lib/enhanced_sqlite3/adapter.rb
 - lib/enhanced_sqlite3/railtie.rb
+- lib/enhanced_sqlite3/resolver.rb
 - lib/enhanced_sqlite3/supports_deferrable_constraints.rb
 - lib/enhanced_sqlite3/supports_virtual_columns.rb
 - lib/enhanced_sqlite3/version.rb
@@ -137,7 +138,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.5.1
 signing_key:
 specification_version: 4
 summary: ActiveRecord adapter for SQLite that enhances the default.