activerecord 6.1.4.1 → 7.0.0.rc2

data/lib/active_record/connection_adapters/sqlite3/database_statements.rb

@@ -18,10 +18,9 @@ module ActiveRecord
           SQLite3::ExplainPrettyPrinter.new.pp(exec_query(sql, "EXPLAIN", []))
         end
 
-        def execute(sql, name = nil) #:nodoc:
-          if preventing_writes? && write_query?(sql)
-            raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
-          end
+        def execute(sql, name = nil) # :nodoc:
+          sql = transform_query(sql)
+          check_if_write_query(sql)
 
           materialize_transactions
           mark_transaction_written_if_write(sql)
@@ -33,17 +32,16 @@ module ActiveRecord
           end
         end
 
-        def exec_query(sql, name = nil, binds = [], prepare: false)
-          if preventing_writes? && write_query?(sql)
-            raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
-          end
+        def exec_query(sql, name = nil, binds = [], prepare: false, async: false) # :nodoc:
+          sql = transform_query(sql)
+          check_if_write_query(sql)
 
           materialize_transactions
           mark_transaction_written_if_write(sql)
 
           type_casted_binds = type_casted_binds(binds)
 
-          log(sql, name, binds, type_casted_binds) do
+          log(sql, name, binds, type_casted_binds, async: async) do
             ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
               # Don't cache statements if they are not prepared
               unless prepare
@@ -70,49 +68,57 @@ module ActiveRecord
           end
         end
 
-        def exec_delete(sql, name = "SQL", binds = [])
+        def exec_delete(sql, name = "SQL", binds = []) # :nodoc:
           exec_query(sql, name, binds)
           @connection.changes
         end
         alias :exec_update :exec_delete
 
-        def begin_isolated_db_transaction(isolation) #:nodoc
+        def begin_isolated_db_transaction(isolation) # :nodoc:
           raise TransactionIsolationError, "SQLite3 only supports the `read_uncommitted` transaction isolation level" if isolation != :read_uncommitted
           raise StandardError, "You need to enable the shared-cache mode in SQLite mode before attempting to change the transaction isolation level" unless shared_cache?
 
-          Thread.current.thread_variable_set("read_uncommitted", @connection.get_first_value("PRAGMA read_uncommitted"))
+          ActiveSupport::IsolatedExecutionState[:active_record_read_uncommitted] = @connection.get_first_value("PRAGMA read_uncommitted")
           @connection.read_uncommitted = true
           begin_db_transaction
         end
 
-        def begin_db_transaction #:nodoc:
+        def begin_db_transaction # :nodoc:
           log("begin transaction", "TRANSACTION") { @connection.transaction }
         end
 
-        def commit_db_transaction #:nodoc:
+        def commit_db_transaction # :nodoc:
           log("commit transaction", "TRANSACTION") { @connection.commit }
           reset_read_uncommitted
         end
 
-        def exec_rollback_db_transaction #:nodoc:
+        def exec_rollback_db_transaction # :nodoc:
           log("rollback transaction", "TRANSACTION") { @connection.rollback }
           reset_read_uncommitted
         end
 
+        # https://stackoverflow.com/questions/17574784
+        # https://www.sqlite.org/lang_datefunc.html
+        HIGH_PRECISION_CURRENT_TIMESTAMP = Arel.sql("STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')").freeze # :nodoc:
+        private_constant :HIGH_PRECISION_CURRENT_TIMESTAMP
+
+        def high_precision_current_timestamp
+          HIGH_PRECISION_CURRENT_TIMESTAMP
+        end
+
         private
           def reset_read_uncommitted
-            read_uncommitted = Thread.current.thread_variable_get("read_uncommitted")
+            read_uncommitted = ActiveSupport::IsolatedExecutionState[:active_record_read_uncommitted]
             return unless read_uncommitted
 
             @connection.read_uncommitted = read_uncommitted
           end
 
           def execute_batch(statements, name = nil)
+            statements = statements.map { |sql| transform_query(sql) }
             sql = combine_multi_statements(statements)
 
-            if preventing_writes? && write_query?(sql)
-              raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
-            end
+            check_if_write_query(sql)
 
             materialize_transactions
             mark_transaction_written_if_write(sql)

data/lib/active_record/connection_adapters/sqlite3/quoting.rb

@@ -45,6 +45,21 @@ module ActiveRecord
           0
         end
 
+        def type_cast(value) # :nodoc:
+          case value
+          when BigDecimal
+            value.to_f
+          when String
+            if value.encoding == Encoding::ASCII_8BIT
+              super(value.encode(Encoding::UTF_8))
+            else
+              super
+            end
+          else
+            super
+          end
+        end
+
         def column_name_matcher
           COLUMN_NAME
         end
@@ -80,22 +95,6 @@ module ActiveRecord
         /ix
 
         private_constant :COLUMN_NAME, :COLUMN_NAME_WITH_ORDER
-
-        private
-          def _type_cast(value)
-            case value
-            when BigDecimal
-              value.to_f
-            when String
-              if value.encoding == Encoding::ASCII_8BIT
-                super(value.encode(Encoding::UTF_8))
-              else
-                super
-              end
-            else
-              super
-            end
-          end
       end
     end
   end

data/lib/active_record/connection_adapters/sqlite3/schema_statements.rb

@@ -6,7 +6,7 @@ module ActiveRecord
       module SchemaStatements # :nodoc:
         # Returns an array of indexes for the given table.
         def indexes(table_name)
-          exec_query("PRAGMA index_list(#{quote_table_name(table_name)})", "SCHEMA").map do |row|
+          exec_query("PRAGMA index_list(#{quote_table_name(table_name)})", "SCHEMA").filter_map do |row|
             # Indexes SQLite creates implicitly for internal use start with "sqlite_".
             # See https://www.sqlite.org/fileformat2.html#intschema
             next if row["name"].start_with?("sqlite_")
@@ -49,7 +49,7 @@ module ActiveRecord
               where: where,
               orders: orders
             )
-          end.compact
+          end
         end
 
         def add_foreign_key(from_table, to_table, **options)
@@ -60,6 +60,8 @@ module ActiveRecord
         end
 
         def remove_foreign_key(from_table, to_table = nil, **options)
+          return if options[:if_exists] == true && !foreign_key_exists?(from_table, to_table)
+
           to_table ||= options[:to_table]
           options = options.except(:name, :to_table, :validate)
           foreign_keys = foreign_keys(from_table)

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -47,7 +47,7 @@ module ActiveRecord
     end
   end
 
-  module ConnectionAdapters #:nodoc:
+  module ConnectionAdapters # :nodoc:
     # The SQLite3 adapter works with the sqlite3-ruby drivers
     # (available as gem from https://rubygems.org/gems/sqlite3).
     #
@@ -84,6 +84,7 @@ module ActiveRecord
       end
 
       def initialize(connection, logger, connection_options, config)
+        @memory_database = config[:database] == ":memory:"
         super(connection, logger, config)
         configure_connection
       end
@@ -153,6 +154,10 @@ module ActiveRecord
       alias supports_insert_on_duplicate_update? supports_insert_on_conflict?
       alias supports_insert_conflict_target? supports_insert_on_conflict?
 
+      def supports_concurrent_connections?
+        !@memory_database
+      end
+
       def active?
         !@connection.closed?
       end
@@ -173,11 +178,11 @@ module ActiveRecord
         true
       end
 
-      def native_database_types #:nodoc:
+      def native_database_types # :nodoc:
         NATIVE_DATABASE_TYPES
       end
 
-      # Returns the current database encoding format as a string, eg: 'UTF-8'
+      # Returns the current database encoding format as a string, e.g. 'UTF-8'
       def encoding
         @connection.encoding.to_s
       end
@@ -206,6 +211,10 @@ module ActiveRecord
         end
       end
 
+      def all_foreign_keys_valid? # :nodoc:
+        execute("PRAGMA foreign_key_check").blank?
+      end
+
       # SCHEMA STATEMENTS ========================================
 
       def primary_keys(table_name) # :nodoc:
@@ -232,7 +241,7 @@ module ActiveRecord
         rename_table_indexes(table_name, new_name)
       end
 
-      def add_column(table_name, column_name, type, **options) #:nodoc:
+      def add_column(table_name, column_name, type, **options) # :nodoc:
         if invalid_alter_table_type?(type, options)
           alter_table(table_name) do |definition|
             definition.column(column_name, type, **options)
@@ -242,16 +251,24 @@ module ActiveRecord
         end
       end
 
-      def remove_column(table_name, column_name, type = nil, **options) #:nodoc:
+      def remove_column(table_name, column_name, type = nil, **options) # :nodoc:
         alter_table(table_name) do |definition|
           definition.remove_column column_name
-          definition.foreign_keys.delete_if do |_, fk_options|
-            fk_options[:column] == column_name.to_s
+          definition.foreign_keys.delete_if { |fk| fk.column == column_name.to_s }
+        end
+      end
+
+      def remove_columns(table_name, *column_names, type: nil, **options) # :nodoc:
+        alter_table(table_name) do |definition|
+          column_names.each do |column_name|
+            definition.remove_column column_name
           end
+          column_names = column_names.map(&:to_s)
+          definition.foreign_keys.delete_if { |fk| column_names.include?(fk.column) }
         end
       end
 
-      def change_column_default(table_name, column_name, default_or_changes) #:nodoc:
+      def change_column_default(table_name, column_name, default_or_changes) # :nodoc:
         default = extract_new_default_value(default_or_changes)
 
         alter_table(table_name) do |definition|
@@ -259,7 +276,7 @@ module ActiveRecord
         end
       end
 
-      def change_column_null(table_name, column_name, null, default = nil) #:nodoc:
+      def change_column_null(table_name, column_name, null, default = nil) # :nodoc:
         unless null || default.nil?
           exec_query("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
         end
@@ -268,7 +285,7 @@ module ActiveRecord
         end
       end
 
-      def change_column(table_name, column_name, type, **options) #:nodoc:
+      def change_column(table_name, column_name, type, **options) # :nodoc:
         alter_table(table_name) do |definition|
           definition[column_name].instance_eval do
             self.type = aliased_types(type.to_s, type)
@@ -277,7 +294,7 @@ module ActiveRecord
         end
       end
 
-      def rename_column(table_name, column_name, new_column_name) #:nodoc:
+      def rename_column(table_name, column_name, new_column_name) # :nodoc:
         column = column_for(table_name, column_name)
         alter_table(table_name, rename: { column.name => new_column_name.to_s })
         rename_column_indexes(table_name, column.name, new_column_name)
@@ -308,8 +325,12 @@ module ActiveRecord
           sql << " ON CONFLICT #{insert.conflict_target} DO NOTHING"
         elsif insert.update_duplicates?
           sql << " ON CONFLICT #{insert.conflict_target} DO UPDATE SET "
-          sql << insert.touch_model_timestamps_unless { |column| "#{column} IS excluded.#{column}" }
-          sql << insert.updatable_columns.map { |column| "#{column}=excluded.#{column}" }.join(",")
+          if insert.raw_update_sql?
+            sql << insert.raw_update_sql
+          else
+            sql << insert.touch_model_timestamps_unless { |column| "#{column} IS excluded.#{column}" }
+            sql << insert.updatable_columns.map { |column| "#{column}=excluded.#{column}" }.join(",")
+          end
         end
 
         sql
@@ -329,18 +350,38 @@ module ActiveRecord
         end
       end
 
+      class SQLite3Integer < Type::Integer # :nodoc:
+        private
+          def _limit
+            # INTEGER storage class can be stored 8 bytes value.
+            # See https://www.sqlite.org/datatype3.html#storage_classes_and_datatypes
+            limit || 8
+          end
+      end
+
+      ActiveRecord::Type.register(:integer, SQLite3Integer, adapter: :sqlite3)
+
+      class << self
+        private
+          def initialize_type_map(m)
+            super
+            register_class_with_limit m, %r(int)i, SQLite3Integer
+          end
+      end
+
+      TYPE_MAP = Type::TypeMap.new.tap { |m| initialize_type_map(m) }
+
       private
+        def type_map
+          TYPE_MAP
+        end
+
         # See https://www.sqlite.org/limits.html,
         # the default value is 999 when not configured.
         def bind_params_length
           999
         end
 
-        def initialize_type_map(m = type_map)
-          super
-          register_class_with_limit m, %r(int)i, SQLite3Integer
-        end
-
         def table_structure(table_name)
           structure = exec_query("PRAGMA table_info(#{quote_table_name(table_name)})", "SCHEMA")
           raise(ActiveRecord::StatementInvalid, "Could not find table '#{table_name}'") if structure.empty?
@@ -446,6 +487,7 @@ module ActiveRecord
               options = { name: name.gsub(/(^|_)(#{from})_/, "\\1#{to}_"), internal: true }
               options[:unique] = true if index.unique
               options[:where] = index.where if index.where
+              options[:order] = index.orders if index.orders
               add_index(to, columns, **options)
             end
           end
@@ -482,7 +524,7 @@ module ActiveRecord
           end
         end
 
-        COLLATE_REGEX = /.*\"(\w+)\".*collate\s+\"(\w+)\".*/i.freeze
+        COLLATE_REGEX = /.*"(\w+)".*collate\s+"(\w+)".*/i.freeze
 
         def table_structure_with_collation(table_name, basic_structure)
           collation_hash = {}
@@ -544,17 +586,6 @@ module ActiveRecord
 
           execute("PRAGMA foreign_keys = ON", "SCHEMA")
         end
-
-        class SQLite3Integer < Type::Integer # :nodoc:
-          private
-            def _limit
-              # INTEGER storage class can be stored 8 bytes value.
-              # See https://www.sqlite.org/datatype3.html#storage_classes_and_datatypes
-              limit || 8
-            end
-        end
-
-        ActiveRecord::Type.register(:integer, SQLite3Integer, adapter: :sqlite3)
     end
     ActiveSupport.run_load_hooks(:active_record_sqlite3adapter, SQLite3Adapter)
   end

data/lib/active_record/connection_adapters.rb

@@ -27,20 +27,21 @@ module ActiveRecord
       autoload :ReferenceDefinition
     end
 
-    autoload_at "active_record/connection_adapters/abstract/connection_pool" do
-      autoload :ConnectionHandler
-    end
-
     autoload_under "abstract" do
       autoload :SchemaStatements
       autoload :DatabaseStatements
       autoload :DatabaseLimits
       autoload :Quoting
-      autoload :ConnectionPool
+      autoload :ConnectionHandler
       autoload :QueryCache
       autoload :Savepoints
     end
 
+    autoload_at "active_record/connection_adapters/abstract/connection_pool" do
+      autoload :ConnectionPool
+      autoload :NullPool
+    end
+
     autoload_at "active_record/connection_adapters/abstract/transaction" do
       autoload :TransactionManager
       autoload :NullTransaction

data/lib/active_record/connection_handling.rb

@@ -134,10 +134,8 @@ module ActiveRecord
     #   ActiveRecord::Base.connected_to(role: :reading, shard: :shard_one_replica) do
     #     Dog.first # finds first Dog record stored on the shard one replica
     #   end
-    #
-    # The database kwarg is deprecated and will be removed in 6.2.0 without replacement.
-    def connected_to(database: nil, role: nil, shard: nil, prevent_writes: false, &blk)
-      if legacy_connection_handling
+    def connected_to(role: nil, shard: nil, prevent_writes: false, &blk)
+      if ActiveRecord.legacy_connection_handling
         if self != Base
           raise NotImplementedError, "`connected_to` can only be called on ActiveRecord::Base with legacy connection handling."
         end
@@ -151,31 +149,11 @@ module ActiveRecord
         end
       end
 
-      if database && (role || shard)
-        raise ArgumentError, "`connected_to` cannot accept a `database` argument with any other arguments."
-      elsif database
-        ActiveSupport::Deprecation.warn("The database key in `connected_to` is deprecated. It will be removed in Rails 6.2.0 without replacement.")
-
-        if database.is_a?(Hash)
-          role, database = database.first
-          role = role.to_sym
-        end
-
-        db_config, owner_name = resolve_config_for_connection(database)
-        handler = lookup_connection_handler(role)
-
-        handler.establish_connection(db_config, owner_name: owner_name, role: role)
-
-        with_handler(role, &blk)
-      elsif role || shard
-        unless role
-          raise ArgumentError, "`connected_to` cannot accept a `shard` argument without a `role`."
-        end
-
-        with_role_and_shard(role, shard, prevent_writes, &blk)
-      else
+      unless role || shard
         raise ArgumentError, "must provide a `shard` and/or `role`."
       end
+
+      with_role_and_shard(role, shard, prevent_writes, &blk)
     end
 
     # Connects a role and/or shard to the provided connection names. Optionally +prevent_writes+
@@ -194,7 +172,7 @@ module ActiveRecord
     def connected_to_many(*classes, role:, shard: nil, prevent_writes: false)
       classes = classes.flatten
 
-      if legacy_connection_handling
+      if ActiveRecord.legacy_connection_handling
         raise NotImplementedError, "connected_to_many is not available with legacy connection handling"
       end
 
@@ -202,9 +180,9 @@ module ActiveRecord
         raise NotImplementedError, "connected_to_many can only be called on ActiveRecord::Base."
       end
 
-      prevent_writes = true if role == reading_role
+      prevent_writes = true if role == ActiveRecord.reading_role
 
-      connected_to_stack << { role: role, shard: shard, prevent_writes: prevent_writes, klasses: classes }
+      append_to_connected_to_stack(role: role, shard: shard, prevent_writes: prevent_writes, klasses: classes)
       yield
     ensure
       connected_to_stack.pop
@@ -218,13 +196,32 @@ module ActiveRecord
     # It is not recommended to use this method in a request since it
     # does not yield to a block like +connected_to+.
     def connecting_to(role: default_role, shard: default_shard, prevent_writes: false)
-      if legacy_connection_handling
+      if ActiveRecord.legacy_connection_handling
         raise NotImplementedError, "`connecting_to` is not available with `legacy_connection_handling`."
       end
 
-      prevent_writes = true if role == reading_role
+      prevent_writes = true if role == ActiveRecord.reading_role
 
-      self.connected_to_stack << { role: role, shard: shard, prevent_writes: prevent_writes, klasses: [self] }
+      append_to_connected_to_stack(role: role, shard: shard, prevent_writes: prevent_writes, klasses: [self])
+    end
+
+    # Prohibit swapping shards while inside of the passed block.
+    #
+    # In some cases you may want to be able to swap shards but not allow a
+    # nested call to connected_to or connected_to_many to swap again. This
+    # is useful in cases you're using sharding to provide per-request
+    # database isolation.
+    def prohibit_shard_swapping(enabled = true)
+      prev_value = ActiveSupport::IsolatedExecutionState[:active_record_prohibit_shard_swapping]
+      ActiveSupport::IsolatedExecutionState[:active_record_prohibit_shard_swapping] = enabled
+      yield
+    ensure
+      ActiveSupport::IsolatedExecutionState[:active_record_prohibit_shard_swapping] = prev_value
+    end
+
+    # Determine whether or not shard swapping is currently prohibited
+    def shard_swapping_prohibited?
+      ActiveSupport::IsolatedExecutionState[:active_record_prohibit_shard_swapping]
     end
 
     # Prevent writing to the database regardless of role.
@@ -239,7 +236,7 @@ module ActiveRecord
     # See +READ_QUERY+ for the queries that are blocked by this
     # method.
     def while_preventing_writes(enabled = true, &block)
-      if legacy_connection_handling
+      if ActiveRecord.legacy_connection_handling
         connection_handler.while_preventing_writes(enabled, &block)
       else
         connected_to(role: current_role, prevent_writes: enabled, &block)
@@ -257,8 +254,8 @@ module ActiveRecord
     end
 
     def lookup_connection_handler(handler_key) # :nodoc:
-      if ActiveRecord::Base.legacy_connection_handling
-        handler_key ||= ActiveRecord::Base.writing_role
+      if ActiveRecord.legacy_connection_handling
+        handler_key ||= ActiveRecord.writing_role
         connection_handlers[handler_key] ||= ActiveRecord::ConnectionAdapters::ConnectionHandler.new
       else
         ActiveRecord::Base.connection_handler
@@ -267,7 +264,7 @@ module ActiveRecord
 
     # Clears the query cache for all connections associated with the current thread.
     def clear_query_caches_for_current_thread
-      if ActiveRecord::Base.legacy_connection_handling
+      if ActiveRecord.legacy_connection_handling
         ActiveRecord::Base.connection_handlers.each_value do |handler|
           clear_on_handler(handler)
         end
@@ -294,19 +291,8 @@ module ActiveRecord
     end
 
     def primary_class? # :nodoc:
-      self == Base || defined?(ApplicationRecord) && self == ApplicationRecord
-    end
-
-    # Returns the configuration of the associated connection as a hash:
-    #
-    #  ActiveRecord::Base.connection_config
-    #  # => {pool: 5, timeout: 5000, database: "db/development.sqlite3", adapter: "sqlite3"}
-    #
-    # Please use only for reading.
-    def connection_config
-      connection_pool.db_config.configuration_hash
+      self == Base || application_record_class?
     end
-    deprecate connection_config: "Use connection_db_config instead"
 
     # Returns the db_config object from the associated connection:
     #
@@ -374,17 +360,17 @@ module ActiveRecord
       end
 
       def with_role_and_shard(role, shard, prevent_writes)
-        prevent_writes = true if role == reading_role
+        prevent_writes = true if role == ActiveRecord.reading_role
 
-        if ActiveRecord::Base.legacy_connection_handling
+        if ActiveRecord.legacy_connection_handling
           with_handler(role.to_sym) do
             connection_handler.while_preventing_writes(prevent_writes) do
-              self.connected_to_stack << { shard: shard, klasses: [self] }
+              append_to_connected_to_stack(shard: shard, klasses: [self])
               yield
             end
           end
         else
-          self.connected_to_stack << { role: role, shard: shard, prevent_writes: prevent_writes, klasses: [self] }
+          append_to_connected_to_stack(role: role, shard: shard, prevent_writes: prevent_writes, klasses: [self])
           return_value = yield
           return_value.load if return_value.is_a? ActiveRecord::Relation
           return_value
@@ -393,6 +379,14 @@ module ActiveRecord
         self.connected_to_stack.pop
       end
 
+      def append_to_connected_to_stack(entry)
+        if shard_swapping_prohibited? && entry[:shard].present?
+          raise ArgumentError, "cannot swap `shard` while shard swapping is prohibited."
+        end
+
+        connected_to_stack << entry
+      end
+
       def swap_connection_handler(handler, &blk) # :nodoc:
         old_handler, ActiveRecord::Base.connection_handler = ActiveRecord::Base.connection_handler, handler
         return_value = yield