active_record_shards 3.22.0 → 4.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 23d9e5008110efdba7c5d366557f94ec83bbba4c655157ae6b071494fc745097
-  data.tar.gz: 30bd423589d89b1d268fade3127321c7a42f157571c2bf07e31137e4b96e8316
+SHA1:
+  metadata.gz: 88819bbec3c2e39bc44c5f6172aa5bf9a3a7e097
+  data.tar.gz: bc407bce7e0f3ae6bc7bcf9041ac49cd6c8077a8
 SHA512:
-  metadata.gz: 9454ca6c66e3a1c4073d18b81a550c1fa9f29243198f98645d711c01db8d09dec1cbbcb6228fe0e5f1f3971fc26b040624de97c2d6f7c3d97dd7011f6a622cff
-  data.tar.gz: 0ad014733e6f2728303618a0845b626ff181b6768fc41bcc87ec9b31a52e919ec3c6874b755e69073b9c933af2a0a0c42b3e00a6ec8a4fe135f94a0a71b2f0aa
+  metadata.gz: e5f4fb85b1321bdb55edf8118ea944fb7fd1188a56350c87ebf2a560e5ad63e145da065eb9859532bc4bdb545b89ac22d8d65ec2810028fa995e84c88030ab6f
+  data.tar.gz: b8bc4ac010819230082d490c2e2850b80ce5ea5018d1f5323536894e58005d17cfb018b6757a339444864d71e76484c22d9517ca197211bf90db1229306e6777

data/README.md

@@ -1,20 +1,11 @@
-[![Build Status](https://github.com/zendesk/active_record_shards/workflows/CI/badge.svg)](https://github.com/zendesk/active_record_shards/actions?query=workflow%3ACI)
+[![Build Status](https://secure.travis-ci.org/zendesk/active_record_shards.png)](http://travis-ci.org/zendesk/active_record_shards)
 
 # ActiveRecord Shards
 
-ActiveRecord Shards is an extension for ActiveRecord that provides support for sharded database and replicas. Basically it is just a nice way to
+ActiveRecord Shards is an extension for ActiveRecord that provides support for sharded database and slaves. 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, 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)
-- [Migrations](#migrations)
-  - [Example](#example)
-    - [Shared Model](#create-a-table-for-the-shared-not-sharded-model)
-    - [Sharded Model](#create-a-table-for-the-sharded-model)
-- [Usage](#usage)
-- [Debugging](#debugging)
+ActiveRecord Shards has been used and tested on Rails 5.0 and has in some form or another been used in production on a large Rails app for several years.
 
 ## Installation
 
@@ -24,143 +15,83 @@ and make sure to require 'active\_record\_shards' in some way.
 
 ## Configuration
 
-Add the replica and shard configuration to config/database.yml:
-
-```yaml
-production:
-  adapter: mysql
-  encoding: utf8
-  database: my_app_main
-  pool: 5
-  host: db1
-  username: root
-  password:
-  replica:
-    host: db1_replica
-  shards:
-    1:
-      host: db_shard1
-      database: my_app_shard
-      replica:
-        host: db_shard1_replica
-    2:
-      host: db_shard2
-      database: my_app_shard
-      replica:
-        host: db_shard2_replica
-```
+Add the slave and shard configuration to config/database.yml:
+
+    production:
+      adapter: mysql
+      encoding: utf8
+      database: my_app_main
+      pool: 5
+      host: db1
+      username: root
+      password:
+      slave:
+        host: db1_slave
+      shards:
+        1:
+          host: db_shard1
+          database: my_app_shard
+          slave:
+            host: db_shard1_slave
+        2:
+          host: db_shard2
+          database: my_app_shard
+          slave:
+            host: db_shard2_slave
 
 basically connections inherit configuration from the parent configuration file.
 
-## Migrations
-
-ActiveRecord Shards also patches migrations to support running migrations on a shared (not sharded) or a sharded database.
-Each migration class has to specify a shard spec indicating where to run the migration.
-
-Valid shard specs:
-
-* `:none` - Run this migration on the shared database, not any shards
-* `:all` - Run this migration on all of the shards, not the shared database
-
-#### Example
-
-###### Create a table for the shared (not sharded) model
-
-```ruby
-class CreateAccounts < ActiveRecord::Migration
-  shard :none
-
-  def change
-    create_table :accounts do |t|
-      # This is NOT necessary for the gem to work, we just use it in the examples below demonstrating one way to switch shards
-      t.integer :shard_id, null: false
-
-      t.string :name
-    end
-  end
-end
-```
-
-###### Create a table for the sharded model
-
-```ruby
-class CreateProjects < ActiveRecord::Migration
-  shard :all
-
-  def change
-    create_table :projects do |t|
-      t.references :account
-      t.string :name
-    end
-  end
-end
-```
-
 ## Usage
 
 Normally you have some models that live on a shared database, and you might need to query this data in order to know what shard to switch to.
-All the models that live on the shared database must be marked as not\_sharded:
+All the models that live on the sharded database must inherit from ActiveRecordShards::ShardedModel:
 
-```ruby
-class Account < ActiveRecord::Base
-  not_sharded
-
-  has_many :projects
-end
+    class Account < ActiveRecord::Base
+      has_many :projects
+    end
 
-class Project < ActiveRecord::Base
-  belongs_to :account
-end
-```
+    class Project < ActiveRecordShards::ShardedModel
+      belongs_to :account
+    end
 
 So in this setup the accounts live on the shared database, but the projects are sharded. If accounts have a shard\_id column, you could lookup the account
 in a rack middleware and switch to the right shard:
 
-```ruby
-class AccountMiddleware
-  def initialize(app)
-    @app = app
-  end
-
-  def call(env)
-    account = lookup_account(env)
-
-    if account
-      ActiveRecord::Base.on_shard(account.shard_id) do
-        @app.call(env)
+    class AccountMiddleware
+      def initialize(app)
+        @app = app
       end
-    else
-      @app.call(env)
-    end
-  end
 
-  def lookup_account(env)
-    # ...
-  end
-end
-```
+      def call(env)
+        account = lookup_account(env)
 
-You can switch to the replica databases at any point by wrapping your code in an on\_replica block:
+        if account
+          ActiveRecord::Base.on_shard(account.shard_id) do
+            @app.call(env)
+          end
+        else
+          @app.call(env)
+        end
+      end
 
-```ruby
-ActiveRecord::Base.on_replica do
-  Account.find_by_big_expensive_query
-end
-```
+      def lookup_account(env)
+        ...
+      end
+    end
 
-This will perform the query on the replica, and mark the returned instances as read-only. There is also a shortcut for this:
+You can switch to the slave databases at any point by wrapping your code in an on\_slave block:
 
-```ruby
-Account.on_replica.find_by_big_expensive_query
-```
+    ActiveRecord::Base.on_slave do
+      Account.find_by_big_expensive_query
+    end
 
-If you do not want instances returned from replicas to be marked as read-only, this can be disabled globally:
+This will perform the query on the slave, and mark the returned instances as read only. There is also a shortcut for this:
 
-`ActiveRecordShards.disable_replica_readonly_records = true`
+    Account.on_slave.find_by_big_expensive_query
 
 ## Debugging
 
-Show if a query went to primary or replica in the logs:
+Show if a query went to master or slave in the logs:
 
 ```Ruby
 require 'active_record_shards/sql_comments'

data/lib/active_record_shards/association_collection_connection_selection.rb

@@ -1,49 +1,40 @@
 # frozen_string_literal: true
-
 module ActiveRecordShards
   module AssociationCollectionConnectionSelection
-    def on_replica_if(condition)
-      condition ? on_replica : self
+    def on_slave_if(condition)
+      condition ? on_slave : self
     end
-    alias_method :on_slave_if, :on_replica_if
 
-    def on_replica_unless(condition)
-      on_replica_if(!condition)
+    def on_slave_unless(condition)
+      on_slave_if(!condition)
     end
-    alias_method :on_slave_unless, :on_replica_unless
 
-    def on_primary_if(condition)
-      condition ? on_primary : self
+    def on_master_if(condition)
+      condition ? on_master : self
     end
-    alias_method :on_master_if, :on_primary_if
 
-    def on_primary_unless(condition)
-      on_primary_if(!condition)
+    def on_master_unless(condition)
+      on_master_if(!condition)
     end
-    alias_method :on_master_unless, :on_primary_unless
 
-    def on_replica
-      PrimaryReplicaProxy.new(self, :replica)
+    def on_slave
+      MasterSlaveProxy.new(self, :slave)
     end
-    alias_method :on_slave, :on_replica
 
-    def on_primary
-      PrimaryReplicaProxy.new(self, :primary)
+    def on_master
+      MasterSlaveProxy.new(self, :master)
     end
-    alias_method :on_master, :on_primary
 
-    class PrimaryReplicaProxy
+    class MasterSlaveProxy
       def initialize(association_collection, which)
         @association_collection = association_collection
         @which = which
       end
 
-      def method_missing(method, *args, &block) # rubocop:disable Style/MethodMissingSuper, Style/MissingRespondToMissing
+      def method_missing(method, *args, &block) # rubocop:disable Style/MethodMissing
         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,5 +1,4 @@
 # frozen_string_literal: true
-
 require 'active_support/core_ext'
 
 module ActiveRecordShards
@@ -7,7 +6,7 @@ module ActiveRecordShards
     module_function
 
     def explode(conf)
-      conf = conf.to_h.deep_dup
+      conf = conf.deep_dup
 
       conf.to_a.each do |env_name, env_config|
         next unless shards = env_config.delete('shards')
@@ -24,31 +23,10 @@ module ActiveRecordShards
       end
 
       conf.to_a.each do |env_name, env_config|
-        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
+        if slave_conf = env_config.delete('slave')
+          expand_child!(env_config, slave_conf)
+          conf["#{env_name}_slave"] = slave_conf
         end
-        # rubocop:enable Style/Next
-      end
-
-      conf
-    end
-
-    def replace_slave_keys(conf)
-      conf.to_a.each do |env_name, env_config|
-        next unless env_name.end_with?("_slave")
-
-        replica_key = env_name.sub(/_slave$/, "_replica")
-        next if conf.key?(replica_key)
-
-        conf[replica_key] = env_config.deep_dup
       end
 
       conf
@@ -56,16 +34,14 @@ module ActiveRecordShards
 
     def expand_child!(parent, child)
       parent.each do |key, value|
-        unless ['slave', 'replica', 'shards'].include?(key) || value.is_a?(Hash)
+        unless ['slave', 'shards'].include?(key) || value.is_a?(Hash)
           child[key] ||= value
         end
       end
     end
 
     def configurations_with_shard_explosion=(conf)
-      exploded_configuration = explode(conf)
-      configuration_with_slave_keys_replaced = replace_slave_keys(exploded_configuration)
-      self.configurations_without_shard_explosion = configuration_with_slave_keys_replaced
+      self.configurations_without_shard_explosion = explode(conf)
     end
 
     def self.extended(base)

data/lib/active_record_shards/connection_switcher-5-0.rb

@@ -1,15 +1,5 @@
 module ActiveRecordShards
   module ConnectionSwitcher
-    def connection_specification_name
-      name = current_shard_selection.resolve_connection_name(sharded: is_sharded?, configurations: configurations)
-
-      unless configurations[name] || name == "primary"
-        raise ActiveRecord::AdapterNotSpecified, "No database defined by #{name} in your database config. (configurations: #{configurations.to_h.keys.inspect})"
-      end
-
-      name
-    end
-
     private
 
     def ensure_shard_connection

data/lib/active_record_shards/connection_switcher-5-1.rb

@@ -1,15 +1,5 @@
 module ActiveRecordShards
   module ConnectionSwitcher
-    def connection_specification_name
-      name = current_shard_selection.resolve_connection_name(sharded: is_sharded?, configurations: configurations)
-
-      unless configurations[name] || name == "primary"
-        raise ActiveRecord::AdapterNotSpecified, "No database defined by #{name} in your database config. (configurations: #{configurations.to_h.keys.inspect})"
-      end
-
-      name
-    end
-
     private
 
     def ensure_shard_connection