activerecord-enhancedsqlite3-adapter 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f3c0a5d2a1ceae77db506215c35aa217521e43d152a1ca312e7b2f52887b803
-  data.tar.gz: c5d6f2ac4e34b9181ac7dc6417176fbd5b5dfd5d20376ba6b91731faca73093a
+  metadata.gz: f138b7e075e546691856c8e45f22413a1e381df3024c6ef30e467dbde830c896
+  data.tar.gz: 0e6bde9f85883cacc12893f8ab2b1ca5820deea6d6a1357a262fb24401ed4980
 SHA512:
-  metadata.gz: c26a1f83ede20d480687b01a8d1ab39b7d5c854e16fe7d3c3a6c5c984bd23812f3c5d40c531c3a964e032bc0dba1bc33f8de43a3d85c3b4eade0bd30a251f091
-  data.tar.gz: fdf1d73eaa883f932f0cbb5cb6c4defc6addcfbbf4a8059a634a08f0b773a7b854b1e85c719e2b978a5708c1263dec3901a6c7d6e289eabe8421fdbdfc55bdb6
+  metadata.gz: dafd2a35c78565843b9aa384fb5988818c48bdc6852da55363c7e18e447a752b8194ef08ea4a40c9b482f30317cd7afc8e9501e22cb38abbab51dd16f3d6c7a7
+  data.tar.gz: 5c0d6b07eb0b3e90c4fd6f8859f90d944e33d90e100ee96981f24b4d1cb1212266045f81abe935b4ad1913caf22d43cb3386a73bdb0670b15f8686e680619a77

data/lib/enhanced_sqlite3/adapter.rb

@@ -6,6 +6,7 @@
 
 require "active_record/connection_adapters/sqlite3_adapter"
 require "enhanced_sqlite3/supports_virtual_columns"
+require "enhanced_sqlite3/supports_deferrable_constraints"
 
 module EnhancedSQLite3
   module Adapter
@@ -19,29 +20,17 @@ module EnhancedSQLite3
     #
     # extends https://github.com/rails/rails/blob/main/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb#L691
     def configure_connection
-      configure_busy_handler
-
       super
 
       configure_pragmas
       configure_extensions
 
       EnhancedSQLite3::SupportsVirtualColumns.apply!
+      EnhancedSQLite3::SupportsDeferrableConstraints.apply!
     end
 
     private
 
-    def configure_busy_handler
-      if @config[:timeout] && @config[:retries]
-        raise ArgumentError, "Cannot specify both timeout and retries arguments"
-      elsif @config[:retries]
-        # see: https://www.sqlite.org/c3ref/busy_handler.html
-        @raw_connection.busy_handler do |count|
-          count <= @config[:retries]
-        end
-      end
-    end
-
     def configure_pragmas
       @config.fetch(:pragmas, []).each do |key, value|
         execute("PRAGMA #{key} = #{value}", "SCHEMA")

data/lib/enhanced_sqlite3/supports_deferrable_constraints.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+# see: https://github.com/rails/rails/pull/49376
+module EnhancedSQLite3
+  module SupportsDeferrableConstraints
+    def self.apply!
+      EnhancedSQLite3::Adapter.include(Adapter)
+      ActiveRecord::ConnectionAdapters::SQLite3::SchemaCreation.include(SchemaCreation)
+    end
+
+    module Adapter
+      def supports_deferrable_constraints?
+        true
+      end
+
+      FK_REGEX = /.*FOREIGN KEY\s+\("(\w+)"\)\s+REFERENCES\s+"(\w+)"\s+\("(\w+)"\)/
+      DEFERRABLE_REGEX = /DEFERRABLE INITIALLY (\w+)/
+      def foreign_keys(table_name)
+        # SQLite returns 1 row for each column of composite foreign keys.
+        fk_info = internal_exec_query("PRAGMA foreign_key_list(#{quote(table_name)})", "SCHEMA")
+        # Deferred or immediate foreign keys can only be seen in the CREATE TABLE sql
+        fk_defs = table_structure_sql(table_name)
+          .select do |column_string|
+                    column_string.start_with?("CONSTRAINT") &&
+                      column_string.include?("FOREIGN KEY")
+                  end
+          .to_h do |fk_string|
+          _, from, table, to = fk_string.match(FK_REGEX).to_a
+          _, mode = fk_string.match(DEFERRABLE_REGEX).to_a
+          deferred = mode&.downcase&.to_sym || false
+          [[table, from, to], deferred]
+        end
+
+        grouped_fk = fk_info.group_by { |row| row["id"] }.values.each { |group| group.sort_by! { |row| row["seq"] } }
+        grouped_fk.map do |group|
+          row = group.first
+          options = {
+            on_delete: extract_foreign_key_action(row["on_delete"]),
+            on_update: extract_foreign_key_action(row["on_update"]),
+            deferrable: fk_defs[[row["table"], row["from"], row["to"]]]
+          }
+
+          if group.one?
+            options[:column] = row["from"]
+            options[:primary_key] = row["to"]
+          else
+            options[:column] = group.map { |row| row["from"] }
+            options[:primary_key] = group.map { |row| row["to"] }
+          end
+          ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(table_name, row["table"], options)
+        end
+      end
+
+      def add_foreign_key(from_table, to_table, **options)
+        if options[:deferrable] == true
+          ActiveRecord.deprecator.warn(<<~MSG)
+            `deferrable: true` is deprecated in favor of `deferrable: :immediate`, and will be removed in Rails 7.2.
+          MSG
+
+          options[:deferrable] = :immediate
+        end
+
+        assert_valid_deferrable(options[:deferrable])
+
+        super
+      end
+
+      def table_structure_sql(table_name)
+        sql = <<~SQL
+          SELECT sql FROM
+            (SELECT * FROM sqlite_master UNION ALL
+             SELECT * FROM sqlite_temp_master)
+          WHERE type = 'table' AND name = #{quote(table_name)}
+        SQL
+
+        # Result will have following sample string
+        # CREATE TABLE "users" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+        #                       "password_digest" varchar COLLATE "NOCASE");
+        result = query_value(sql, "SCHEMA")
+
+        return [] unless result
+
+        # Splitting with left parentheses and discarding the first part will return all
+        # columns separated with comma(,).
+        columns_string = result.split("(", 2).last
+
+        columns_string.split(",").map(&:strip)
+      end
+
+      def assert_valid_deferrable(deferrable)
+        return if !deferrable || %i[immediate deferred].include?(deferrable)
+
+        raise ArgumentError, "deferrable must be `:immediate` or `:deferred`, got: `#{deferrable.inspect}`"
+      end
+    end
+
+    module SchemaCreation
+      def visit_AddForeignKey(o)
+        super.dup.tap do |sql|
+          sql << " DEFERRABLE INITIALLY #{o.options[:deferrable].to_s.upcase}" if o.deferrable
+        end
+      end
+
+      def visit_ForeignKeyDefinition(o)
+        super.dup.tap do |sql|
+          sql << " DEFERRABLE INITIALLY #{o.deferrable.to_s.upcase}" if o.deferrable
+        end
+      end
+    end
+  end
+end

data/lib/enhanced_sqlite3/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EnhancedSQLite3
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-enhancedsqlite3-adapter
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Stephen Margheim
@@ -111,6 +111,7 @@ files:
 - lib/activerecord-enhancedsqlite3-adapter.rb
 - lib/enhanced_sqlite3/adapter.rb
 - lib/enhanced_sqlite3/railtie.rb
+- lib/enhanced_sqlite3/supports_deferrable_constraints.rb
 - lib/enhanced_sqlite3/supports_virtual_columns.rb
 - lib/enhanced_sqlite3/version.rb
 homepage: https://github.com/fractaledmind/activerecord-enhancedsqlite3-adapter