active_record_shards 3.15.1 → 3.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65d92b02ab6446ce1f4faeaf82a4ec5a0b064474c232db1210887c07aa046584
-  data.tar.gz: 95846224823c39b0abb7afe59b2ee0b52507147391a549581428330274cf60fb
+  metadata.gz: 1f573041b49f55115d94db028525da537bbbadffc4526d8a4f220f3d4ab1d4fd
+  data.tar.gz: f29528996589d7cef3f14671df47d10a8d4cf4a3b0ad81b022aaddf7b229178d
 SHA512:
-  metadata.gz: d20e7ac275197777749f69c2c31c09b5e1ae26f47c212107afd464d74977b36f348fa6e7a92566139240089c4b9b559b790ab4be0d34d975a59ab3e2e40ee933
-  data.tar.gz: '09f0100020a3539e297d480f8ced91577bdbdc4cbe4f563df735cac3a8a03bcd2540c41a3ecddde09756649ffdeac03ca16b7ec96c7869d8264b53452b706517'
+  metadata.gz: 782a638a2d4ce88a06ac0f6d93d277de20831d918ee1014fec1b2a01f95631b5857fb2df1d83b15ced1e52b1749283ec497c43ccfc0d85ffd6e3bd271d4d9f28
+  data.tar.gz: f28464784b171c3dd8a888574f1bb362e645f3949dcf3b07a70a9c195e73ae00a1c5a7319c107666f4060e37c04c3daacd8415187124dbda891aae5cb19a7ecf

data/README.md

@@ -2,10 +2,10 @@
 
 # ActiveRecord Shards
 
-ActiveRecord Shards is an extension for ActiveRecord that provides support for sharded database and slaves. Basically it is just a nice way to
+ActiveRecord Shards is an extension for ActiveRecord that provides support for sharded database and replicas. Basically it is just a nice way to
 switch between database connections. We've made the implementation very small, and have tried not to reinvent any wheels already present in ActiveRecord.
 
-ActiveRecord Shards has been used and tested on Rails 4.2 and 5.0 and has in some form or another been used in production on a large Rails app for several years.
+ActiveRecord Shards has been used and tested on Rails 4.2, 5.x and 6.0, and has in some form or another been used in production on large Rails apps for several years.
 
 - [Installation](#installation)
 - [Configuration](#configuration)
@@ -24,7 +24,7 @@ and make sure to require 'active\_record\_shards' in some way.
 
 ## Configuration
 
-Add the slave and shard configuration to config/database.yml:
+Add the replica and shard configuration to config/database.yml:
 
 ```yaml
 production:
@@ -35,19 +35,19 @@ production:
   host: db1
   username: root
   password:
-  slave:
-    host: db1_slave
+  replica:
+    host: db1_replica
   shards:
     1:
       host: db_shard1
       database: my_app_shard
-      slave:
-        host: db_shard1_slave
+      replica:
+        host: db_shard1_replica
     2:
       host: db_shard2
       database: my_app_shard
-      slave:
-        host: db_shard2_slave
+      replica:
+        host: db_shard2_replica
 ```
 
 basically connections inherit configuration from the parent configuration file.
@@ -140,23 +140,23 @@ class AccountMiddleware
 end
 ```
 
-You can switch to the slave databases at any point by wrapping your code in an on\_slave block:
+You can switch to the replica databases at any point by wrapping your code in an on\_replica block:
 
 ```ruby
-ActiveRecord::Base.on_slave do
+ActiveRecord::Base.on_replica do
   Account.find_by_big_expensive_query
 end
 ```
 
-This will perform the query on the slave, and mark the returned instances as read only. There is also a shortcut for this:
+This will perform the query on the replica, and mark the returned instances as read only. There is also a shortcut for this:
 
 ```ruby
-Account.on_slave.find_by_big_expensive_query
+Account.on_replica.find_by_big_expensive_query
 ```
 
 ## Debugging
 
-Show if a query went to master or slave in the logs:
+Show if a query went to primary or replica in the logs:
 
 ```Ruby
 require 'active_record_shards/sql_comments'

data/lib/active_record_shards.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'active_record'
 require 'active_record/base'
 require 'active_record_shards/configuration_parser'
@@ -7,7 +8,7 @@ require 'active_record_shards/shard_selection'
 require 'active_record_shards/connection_switcher'
 require 'active_record_shards/association_collection_connection_selection'
 require 'active_record_shards/migration'
-require 'active_record_shards/default_slave_patches'
+require 'active_record_shards/default_replica_patches'
 require 'active_record_shards/schema_dumper_extension'
 
 module ActiveRecordShards
@@ -22,17 +23,61 @@ end
 ActiveRecord::Base.extend(ActiveRecordShards::ConfigurationParser)
 ActiveRecord::Base.extend(ActiveRecordShards::Model)
 ActiveRecord::Base.extend(ActiveRecordShards::ConnectionSwitcher)
-ActiveRecord::Base.extend(ActiveRecordShards::DefaultSlavePatches)
-ActiveRecord::Relation.include(ActiveRecordShards::DefaultSlavePatches::ActiveRelationPatches)
+ActiveRecord::Base.extend(ActiveRecordShards::DefaultReplicaPatches)
+ActiveRecord::Relation.include(ActiveRecordShards::DefaultReplicaPatches::ActiveRelationPatches)
 ActiveRecord::Associations::CollectionProxy.include(ActiveRecordShards::AssociationCollectionConnectionSelection)
-ActiveRecord::Associations::Builder::HasAndBelongsToMany.include(ActiveRecordShards::DefaultSlavePatches::Rails41HasAndBelongsToManyBuilderExtension)
+ActiveRecord::Associations::Builder::HasAndBelongsToMany.include(ActiveRecordShards::DefaultReplicaPatches::Rails41HasAndBelongsToManyBuilderExtension)
 ActiveRecord::SchemaDumper.prepend(ActiveRecordShards::SchemaDumperExtension)
 
 case "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"
 when '4.2'
   require 'active_record_shards/patches-4-2'
-when '5.0', '5.1', '5.2'
+when '5.0', '5.1', '5.2', '6.0'
   :ok
 else
   raise "ActiveRecordShards is not compatible with #{ActiveRecord::VERSION::STRING}"
 end
+
+require 'active_record_shards/deprecation'
+
+ActiveRecordShards::Deprecation.deprecate_methods(
+  ActiveRecordShards::AssociationCollectionConnectionSelection,
+  on_slave_if: :on_replica_if,
+  on_slave_unless: :on_replica_unless,
+  on_slave: :on_replica,
+  on_master: :on_primary,
+  on_master_if: :on_primary_if,
+  on_master_unless: :on_primary_unless
+)
+
+ActiveRecordShards::Deprecation.deprecate_methods(
+  ActiveRecordShards::ConnectionSwitcher,
+  on_slave_if: :on_replica_if,
+  on_slave_unless: :on_replica_unless,
+  on_master_or_slave: :on_primary_or_replica,
+  on_slave: :on_replica,
+  on_master: :on_primary,
+  on_master_if: :on_primary_if,
+  on_master_unless: :on_primary_unless,
+  on_slave?: :on_replica?
+)
+
+ActiveRecordShards::Deprecation.deprecate_methods(
+  ActiveRecordShards::DefaultReplicaPatches,
+  columns_with_force_slave: :columns_with_force_replica,
+  table_exists_with_force_slave?: :table_exists_with_force_replica?,
+  transaction_with_slave_off: :transaction_with_replica_off,
+  on_slave_unless_tx: :on_replica_unless_tx
+)
+
+ActiveRecordShards::Deprecation.deprecate_methods(
+  ActiveRecordShards::Model,
+  on_slave_by_default?: :on_replica_by_default?,
+  :on_slave_by_default= => :on_replica_by_default=
+)
+
+ActiveRecordShards::Deprecation.deprecate_methods(
+  ActiveRecordShards::ShardSelection,
+  on_slave?: :on_replica?,
+  :on_slave= => :on_replica=
+)

data/lib/active_record_shards/association_collection_connection_selection.rb

@@ -1,40 +1,49 @@
 # frozen_string_literal: true
+
 module ActiveRecordShards
   module AssociationCollectionConnectionSelection
-    def on_slave_if(condition)
-      condition ? on_slave : self
+    def on_replica_if(condition)
+      condition ? on_replica : self
     end
+    alias_method :on_slave_if, :on_replica_if
 
-    def on_slave_unless(condition)
-      on_slave_if(!condition)
+    def on_replica_unless(condition)
+      on_replica_if(!condition)
     end
+    alias_method :on_slave_unless, :on_replica_unless
 
-    def on_master_if(condition)
-      condition ? on_master : self
+    def on_primary_if(condition)
+      condition ? on_primary : self
     end
+    alias_method :on_master_if, :on_primary_if
 
-    def on_master_unless(condition)
-      on_master_if(!condition)
+    def on_primary_unless(condition)
+      on_primary_if(!condition)
     end
+    alias_method :on_master_unless, :on_primary_unless
 
-    def on_slave
-      MasterSlaveProxy.new(self, :slave)
+    def on_replica
+      PrimaryReplicaProxy.new(self, :replica)
     end
+    alias_method :on_slave, :on_replica
 
-    def on_master
-      MasterSlaveProxy.new(self, :master)
+    def on_primary
+      PrimaryReplicaProxy.new(self, :primary)
     end
+    alias_method :on_master, :on_primary
 
-    class MasterSlaveProxy
+    class PrimaryReplicaProxy
       def initialize(association_collection, which)
         @association_collection = association_collection
         @which = which
       end
 
-      def method_missing(method, *args, &block) # rubocop:disable Style/MethodMissing
+      def method_missing(method, *args, &block) # rubocop:disable Style/MethodMissingSuper, Style/MissingRespondToMissing
         reflection = @association_collection.proxy_association.reflection
         reflection.klass.on_cx_switch_block(@which) { @association_collection.send(method, *args, &block) }
       end
     end
+
+    MasterSlaveProxy = PrimaryReplicaProxy
   end
 end

data/lib/active_record_shards/configuration_parser.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'active_support/core_ext'
 
 module ActiveRecordShards
@@ -6,7 +7,7 @@ module ActiveRecordShards
     module_function
 
     def explode(conf)
-      conf = conf.deep_dup
+      conf = conf.to_h.deep_dup
 
       conf.to_a.each do |env_name, env_config|
         next unless shards = env_config.delete('shards')
@@ -23,10 +24,18 @@ module ActiveRecordShards
       end
 
       conf.to_a.each do |env_name, env_config|
-        if slave_conf = env_config.delete('slave')
-          expand_child!(env_config, slave_conf)
-          conf["#{env_name}_slave"] = slave_conf
+        if replica_conf = env_config.delete('replica')
+          expand_child!(env_config, replica_conf)
+          conf["#{env_name}_replica"] = replica_conf
+        end
+
+        # rubocop:disable Style/Next
+        if legacy_replica_conf = env_config.delete('slave')
+          ActiveRecordShards::Deprecation.warn('`slave` configuration keys should be replaced with `replica` keys!')
+          expand_child!(env_config, legacy_replica_conf)
+          conf["#{env_name}_replica"] = legacy_replica_conf
         end
+        # rubocop:enable Style/Next
       end
 
       conf
@@ -34,7 +43,7 @@ module ActiveRecordShards
 
     def expand_child!(parent, child)
       parent.each do |key, value|
-        unless ['slave', 'shards'].include?(key) || value.is_a?(Hash)
+        unless ['slave', 'replica', 'shards'].include?(key) || value.is_a?(Hash)
           child[key] ||= value
         end
       end

data/lib/active_record_shards/connection_handler.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 ActiveRecord::ConnectionAdapters::ConnectionHandler.class_eval do
   remove_method :retrieve_connection_pool
   def retrieve_connection_pool(klass)

data/lib/active_record_shards/connection_pool.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module ActiveRecordShards
   ConnectionPoolNameDecorator = Struct.new(:name)
 

data/lib/active_record_shards/connection_specification.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 class << ActiveRecord::Base
   remove_method :establish_connection if ActiveRecord::VERSION::MAJOR >= 5
   def establish_connection(spec = ENV["DATABASE_URL"])

data/lib/active_record_shards/{connection_switcher-4-0.rb → connection_switcher-4-2.rb}

@@ -4,8 +4,8 @@ module ActiveRecordShards
     def connection_pool_name # :nodoc:
       name = current_shard_selection.shard_name(self)
 
-      # e.g. if "production_slave" is not defined in `Configuration`, fall back to "production"
-      if configurations[name].nil? && on_slave?
+      # e.g. if "production_replica" is not defined in `Configuration`, fall back to "production"
+      if configurations[name].nil? && on_replica?
         current_shard_selection.shard_name(self, false)
       else
         name

data/lib/active_record_shards/connection_switcher.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
+
 require 'active_record_shards/shard_support'
 
 module ActiveRecordShards
   module ConnectionSwitcher
-    SHARD_NAMES_CONFIG_KEY = 'shard_names'.freeze
+    SHARD_NAMES_CONFIG_KEY = 'shard_names'
 
     def self.extended(base)
       if ActiveRecord::VERSION::MAJOR >= 5
@@ -23,6 +24,10 @@ module ActiveRecordShards
       switch_connection(shard: new_default_shard)
     end
 
+    def on_primary_db(&block)
+      on_shard(nil, &block)
+    end
+
     def on_shard(shard)
       old_options = current_shard_selection.options
       switch_connection(shard: shard) if supports_sharding?
@@ -31,9 +36,9 @@ module ActiveRecordShards
       switch_connection(old_options)
     end
 
-    def on_first_shard
+    def on_first_shard(&block)
       shard_name = shard_names.first
-      on_shard(shard_name) { yield }
+      on_shard(shard_name, &block)
     end
 
     def shards
@@ -54,70 +59,79 @@ module ActiveRecordShards
       switch_connection(old_options)
     end
 
-    def on_slave_if(condition, &block)
-      condition ? on_slave(&block) : yield
+    def on_replica_if(condition, &block)
+      condition ? on_replica(&block) : yield
     end
+    alias_method :on_slave_if, :on_replica_if
 
-    def on_slave_unless(condition, &block)
-      on_slave_if(!condition, &block)
+    def on_replica_unless(condition, &block)
+      on_replica_if(!condition, &block)
     end
+    alias_method :on_slave_unless, :on_replica_unless
 
-    def on_master_if(condition, &block)
-      condition ? on_master(&block) : yield
+    def on_primary_if(condition, &block)
+      condition ? on_primary(&block) : yield
     end
+    alias_method :on_master_if, :on_primary_if
 
-    def on_master_unless(condition, &block)
-      on_master_if(!condition, &block)
+    def on_primary_unless(condition, &block)
+      on_primary_if(!condition, &block)
     end
+    alias_method :on_master_unless, :on_primary_unless
 
-    def on_master_or_slave(which, &block)
+    def on_primary_or_replica(which, &block)
       if block_given?
         on_cx_switch_block(which, &block)
       else
-        MasterSlaveProxy.new(self, which)
+        PrimaryReplicaProxy.new(self, which)
       end
     end
+    alias_method :on_master_or_slave, :on_primary_or_replica
 
-    # Executes queries using the slave database. Fails over to master if no slave is found.
-    # if you want to execute a block of code on the slave you can go:
-    #   Account.on_slave do
+    # Executes queries using the replica database. Fails over to primary if no replica is found.
+    # if you want to execute a block of code on the replica you can go:
+    #   Account.on_replica do
     #     Account.first
     #   end
-    # the first account will be found on the slave DB
+    # the first account will be found on the replica DB
     #
     # For one-liners you can simply do
-    #   Account.on_slave.first
-    def on_slave(&block)
-      on_master_or_slave(:slave, &block)
+    #   Account.on_replica.first
+    def on_replica(&block)
+      on_primary_or_replica(:replica, &block)
     end
+    alias_method :on_slave, :on_replica
 
-    def on_master(&block)
-      on_master_or_slave(:master, &block)
+    def on_primary(&block)
+      on_primary_or_replica(:primary, &block)
     end
+    alias_method :on_master, :on_primary
 
     # just to ease the transition from replica to active_record_shards
-    alias_method :with_slave, :on_slave
-    alias_method :with_slave_if, :on_slave_if
-    alias_method :with_slave_unless, :on_slave_unless
+    alias_method :with_slave, :on_replica
+    alias_method :with_slave_if, :on_replica_if
+    alias_method :with_slave_unless, :on_replica_unless
 
     def on_cx_switch_block(which, force: false, construct_ro_scope: nil, &block)
-      @disallow_slave ||= 0
-      @disallow_slave += 1 if which == :master
+      @disallow_replica ||= 0
+      @disallow_replica += 1 if [:primary, :master].include?(which)
+
+      ActiveRecordShards::Deprecation.warn('the `:master` option should be replaced with `:primary`!') if which == :master
 
-      switch_to_slave = force || @disallow_slave.zero?
+      switch_to_replica = force || @disallow_replica.zero?
       old_options = current_shard_selection.options
 
-      switch_connection(slave: switch_to_slave)
+      switch_connection(replica: switch_to_replica)
 
       # we avoid_readonly_scope to prevent some stack overflow problems, like when
       # .columns calls .with_scope which calls .columns and onward, endlessly.
-      if self == ActiveRecord::Base || !switch_to_slave || construct_ro_scope == false
+      if self == ActiveRecord::Base || !switch_to_replica || construct_ro_scope == false
         yield
       else
         readonly.scoping(&block)
       end
     ensure
-      @disallow_slave -= 1 if which == :master
+      @disallow_replica -= 1 if [:primary, :master].include?(which)
       switch_connection(old_options) if old_options
     end
 
@@ -125,9 +139,10 @@ module ActiveRecordShards
       shard_names.any?
     end
 
-    def on_slave?
-      current_shard_selection.on_slave?
+    def on_replica?
+      current_shard_selection.on_replica?
     end
+    alias_method :on_slave?, :on_replica?
 
     def current_shard_selection
       Thread.current[:shard_selection] ||= ShardSelection.new
@@ -144,6 +159,7 @@ module ActiveRecordShards
       unless config.fetch(SHARD_NAMES_CONFIG_KEY, []).all? { |shard_name| shard_name.is_a?(Integer) }
         raise "All shard names must be integers: #{config[SHARD_NAMES_CONFIG_KEY].inspect}."
       end
+
       config[SHARD_NAMES_CONFIG_KEY] || []
     end
 
@@ -151,14 +167,15 @@ module ActiveRecordShards
 
     def switch_connection(options)
       if options.any?
-        if options.key?(:slave)
-          current_shard_selection.on_slave = options[:slave]
+        if options.key?(:replica)
+          current_shard_selection.on_replica = options[:replica]
         end
 
         if options.key?(:shard)
           unless configurations[shard_env]
             raise "Did not find #{shard_env} in configurations, did you forget to add it to your database config? (configurations: #{configurations.keys.inspect})"
           end
+
           current_shard_selection.shard = options[:shard]
         end
 
@@ -170,9 +187,9 @@ module ActiveRecordShards
       ActiveRecordShards.rails_env
     end
 
-    def with_default_shard
+    def with_default_shard(&block)
       if is_sharded? && current_shard_id.nil? && table_name != ActiveRecord::SchemaMigration.table_name
-        on_first_shard { yield }
+        on_first_shard(&block)
       else
         yield
       end
@@ -192,25 +209,27 @@ module ActiveRecordShards
       with_default_shard { table_exists_without_default_shard? }
     end
 
-    class MasterSlaveProxy
+    class PrimaryReplicaProxy
       def initialize(target, which)
         @target = target
         @which = which
       end
 
-      def method_missing(method, *args, &block) # rubocop:disable Style/MethodMissing
-        @target.on_master_or_slave(@which) { @target.send(method, *args, &block) }
+      def method_missing(method, *args, &block) # rubocop:disable Style/MethodMissingSuper, Style/MissingRespondToMissing
+        @target.on_primary_or_replica(@which) { @target.send(method, *args, &block) }
       end
     end
+
+    MasterSlaveProxy = PrimaryReplicaProxy
   end
 end
 
 case "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"
 when '4.2'
-  require 'active_record_shards/connection_switcher-4-0'
+  require 'active_record_shards/connection_switcher-4-2'
 when '5.0'
   require 'active_record_shards/connection_switcher-5-0'
-when '5.1', '5.2'
+when '5.1', '5.2', '6.0'
   require 'active_record_shards/connection_switcher-5-1'
 else
   raise "ActiveRecordShards is not compatible with #{ActiveRecord::VERSION::STRING}"