activerecord-enhancedsqlite3-adapter 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6bd667df1779690780802a3f91133b9a6b8155f9f3c040393b5a722a299ce370
-  data.tar.gz: ed4008074efd597d2bc79ab2a4b3aea8e7ccccb37fd8158892843d20918b0015
+  metadata.gz: 97af786ab4b105a44e48a8501611f13b6a090545b1fa5516138aaebd4a2c203f
+  data.tar.gz: 0f8eec83e65a55ee39a043d5a0d23861dbebd8d2fee1ee554ecc9ca6cf836fb9
 SHA512:
-  metadata.gz: 3252cf16cc3619a857488b450542ef6b9402b666bdb1a5458d3615d880c073226cbf8d7472032b74bcfa205196f4febf0aaa8bc1fa2e6e00f00dc0d66e975d97
-  data.tar.gz: ddbafb131266c8edcf5e66303083ab964e8ac9248eaa12eeea4c377501f00e820b54edf406280eb832f0996120e666434e256e308a108d6df945bb21168f8416
+  metadata.gz: 04f39dc81145d1f2a2e39cb41c562675f1bdcbf036291f885d5cfe75203c4a1e36b2575c2cf8762a07c184f7d3ada02fec6403eb0284c4ec82c900b80fd362c5
+  data.tar.gz: 5d7a13c12e202fa5bd5e4da274271194cd7fb770510bb235dc85ede7ead91893c3615c4e8b424073c1416931003bba42c06afc93d0ce3e96353bfa6a6bb7bf89

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
+## [0.7.0] - 2024-04-29
+
+- Loosen the `sqlite3` dependency to allow for `>= 1.4.0` (including 2.x) ([@fractaledmind](https://github.com/fractaledmind/activerecord-enhancedsqlite3-adapter/pull/15))
+
+## [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`

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

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 # supports concatenation in default functions: https://github.com/rails/rails/pull/49287
-# supports insert returning values: https://github.com/rails/rails/pull/49290
 # supports configuring busy_handler: https://github.com/rails/rails/pull/49352
 
 require "active_record/connection_adapters/sqlite3_adapter"
 require "enhanced_sqlite3/supports_virtual_columns"
 require "enhanced_sqlite3/supports_deferrable_constraints"
+require "enhanced_sqlite3/supports_insert_returning"
 
 module EnhancedSQLite3
   module Adapter
@@ -44,10 +44,28 @@ module EnhancedSQLite3
       configure_busy_handler_timeout
       check_version
       configure_pragmas
-      load_extensions
+      configure_extensions
 
-      EnhancedSQLite3::SupportsVirtualColumns.apply!
-      EnhancedSQLite3::SupportsDeferrableConstraints.apply!
+      EnhancedSQLite3::SupportsVirtualColumns.apply! unless try(:supports_virtual_columns?)
+      EnhancedSQLite3::SupportsDeferrableConstraints.apply! unless try(:supports_deferrable_constraints?)
+      EnhancedSQLite3::SupportsInsertReturning.apply! unless try(:supports_insert_returning?)
+    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
@@ -55,22 +73,17 @@ module EnhancedSQLite3
     def configure_busy_handler_timeout
       return unless @config.key?(:timeout)
 
-      timeout = self.class.type_cast_config_to_integer(@config[:timeout])
-      timeout_seconds = timeout.fdiv(1000)
-      retry_interval = 6e-5 # 60 microseconds
+      timeout_milliseconds = self.class.type_cast_config_to_integer(@config[:timeout])
+      timeout_seconds = timeout_milliseconds.fdiv(1000)
 
       @raw_connection.busy_handler do |count|
-        timed_out = false
-        # keep track of elapsed time every 100 iterations (to lower load)
-        if (count % 100).zero?
-          # fail if we exceed the timeout value (captured from the timeout config option, converted to seconds)
-          timed_out = (count * retry_interval) > timeout_seconds
-        end
-        if timed_out
-          false # this will cause the BusyException to be raised
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        if count.zero?
+          @timeout_deadline = now + timeout_seconds
+        elsif now > @timeout_deadline
+          next false
         else
-          sleep(retry_interval)
-          true
+          sleep(0.001)
         end
       end
     end
@@ -110,13 +123,8 @@ module EnhancedSQLite3
       end
     end
 
-    def load_extensions
+    def configure_extensions
       @raw_connection.enable_load_extension(true)
-      # first, load any extensions installed via `sqlpkg`
-      Dir.glob(".sqlpkg/**/*.{dll,so,dylib}") do |extension_path|
-        @raw_connection.load_extension(extension_path)
-      end
-      # then, load any extensions specified in the `database.yml`
       @config.fetch(:extensions, []).each do |extension_name|
         require extension_name
         extension_classname = extension_name.camelize

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 + [writer, reader]
+        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/supports_insert_returning.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# see: https://github.com/rails/rails/pull/49290
+module EnhancedSQLite3
+  module SupportsInsertReturning
+    def self.apply!
+      EnhancedSQLite3::Adapter.include(Adapter)
+      ActiveRecord::ConnectionAdapters::SQLite3::DatabaseStatements.include(DatabaseStatements)
+    end
+
+    module Adapter
+      def supports_insert_returning?
+        database_version >= "3.35.0"
+      end
+
+      def return_value_after_insert?(column) # :nodoc:
+        column.auto_populated?
+      end
+
+      def use_insert_returning?
+        @use_insert_returning ||= @config.key?(:insert_returning) ? self.class.type_cast_config_to_boolean(@config[:insert_returning]) : true
+      end
+
+      def build_insert_sql(insert) # :nodoc:
+        sql = super(insert)
+        sql << " RETURNING #{insert.returning}" if insert.returning
+        sql
+      end
+    end
+
+    module DatabaseStatements
+      def sql_for_insert(sql, pk, binds, returning) # :nodoc:
+        if supports_insert_returning?
+          if pk.nil?
+            # Extract the table from the insert sql. Yuck.
+            table_ref = extract_table_ref_from_insert_sql(sql)
+            pk = primary_key(table_ref) if table_ref
+          end
+
+          returning_columns = returning || Array(pk)
+
+          returning_columns_statement = returning_columns.map { |c| quote_column_name(c) }.join(", ")
+          sql = "#{sql} RETURNING #{returning_columns_statement}" if returning_columns.any?
+        end
+
+        [sql, binds]
+      end
+
+      def extract_table_ref_from_insert_sql(sql)
+        if sql =~ /into\s("[A-Za-z0-9_."\[\]\s]+"|[A-Za-z0-9_."\[\]]+)\s*/im
+          $1.strip
+        end
+      end
+    end
+  end
+end

data/lib/enhanced_sqlite3/version.rb

@@ -1,3 +1,3 @@
 module EnhancedSQLite3
-  VERSION = "0.5.0"
+  VERSION = "0.7.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-enhancedsqlite3-adapter
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Stephen Margheim
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-12-23 00:00:00.000000000 Z
+date: 2024-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -28,14 +28,14 @@ dependencies:
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.6'
 - !ruby/object:Gem::Dependency
@@ -111,7 +111,9 @@ 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_insert_returning.rb
 - lib/enhanced_sqlite3/supports_virtual_columns.rb
 - lib/enhanced_sqlite3/version.rb
 homepage: https://github.com/fractaledmind/activerecord-enhancedsqlite3-adapter