active_record_shards 3.17.0 → 4.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: cb66e1dcadbbd2c1c6f619cb1504ad0b55cfba8c4e36c76015d74781f7e29b5b
-  data.tar.gz: 0f63d2ffbdae6ded142d886af712a10c6b2f0fc59cdc8ab6de9c59d078663d7c
+SHA1:
+  metadata.gz: 88819bbec3c2e39bc44c5f6172aa5bf9a3a7e097
+  data.tar.gz: bc407bce7e0f3ae6bc7bcf9041ac49cd6c8077a8
 SHA512:
-  metadata.gz: 8cc61cd8b0c9b18a41c3b7ab1cd21d16a32d03b51e372855792bec89fe40bd45a4900b2ccfb9fdbafcdc841a98301e9ced9c91d1ba44100d12660723ee655682
-  data.tar.gz: 48e7fdb5d1501834e9008efd22ec617af5a429aab37bece0f435547f49b5bec539950bbf08c5412b336a201f4d756c62f45be580d063b250ce8e10ee89aaf423
+  metadata.gz: e5f4fb85b1321bdb55edf8118ea944fb7fd1188a56350c87ebf2a560e5ad63e145da065eb9859532bc4bdb545b89ac22d8d65ec2810028fa995e84c88030ab6f
+  data.tar.gz: b8bc4ac010819230082d490c2e2850b80ce5ea5018d1f5323536894e58005d17cfb018b6757a339444864d71e76484c22d9517ca197211bf90db1229306e6777

data/README.md

@@ -1,20 +1,11 @@
-[![CircleCI build status](https://circleci.com/gh/zendesk/active_record_shards/tree/master.svg?style=svg)](https://circleci.com/gh/zendesk/active_record_shards/tree/master)
+[![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 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
 
@@ -26,133 +17,77 @@ and make sure to require 'active\_record\_shards' in some way.
 
 Add the slave and shard configuration to config/database.yml:
 
-```yaml
-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
+    production:
+      adapter: mysql
+      encoding: utf8
+      database: my_app_main
+      pool: 5
+      host: db1
+      username: root
+      password:
       slave:
-        host: db_shard2_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:
-
-```ruby
-class Account < ActiveRecord::Base
-  not_sharded
+All the models that live on the sharded database must inherit from ActiveRecordShards::ShardedModel:
 
-  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
+    class AccountMiddleware
+      def initialize(app)
+        @app = app
+      end
 
-  def call(env)
-    account = lookup_account(env)
+      def call(env)
+        account = lookup_account(env)
 
-    if account
-      ActiveRecord::Base.on_shard(account.shard_id) do
-        @app.call(env)
+        if account
+          ActiveRecord::Base.on_shard(account.shard_id) do
+            @app.call(env)
+          end
+        else
+          @app.call(env)
+        end
       end
-    else
-      @app.call(env)
-    end
-  end
 
-  def lookup_account(env)
-    # ...
-  end
-end
-```
+      def lookup_account(env)
+        ...
+      end
+    end
 
 You can switch to the slave databases at any point by wrapping your code in an on\_slave block:
 
-```ruby
-ActiveRecord::Base.on_slave do
-  Account.find_by_big_expensive_query
-end
-```
+    ActiveRecord::Base.on_slave 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:
 
-```ruby
-Account.on_slave.find_by_big_expensive_query
-```
+    Account.on_slave.find_by_big_expensive_query
 
 ## Debugging
 

data/lib/active_record_shards.rb

@@ -1,15 +1,13 @@
 # frozen_string_literal: true
-
 require 'active_record'
 require 'active_record/base'
 require 'active_record_shards/configuration_parser'
 require 'active_record_shards/model'
+require 'active_record_shards/sharded_model'
 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/schema_dumper_extension'
 
 module ActiveRecordShards
   def self.rails_env
@@ -26,14 +24,4 @@ ActiveRecord::Base.extend(ActiveRecordShards::ConnectionSwitcher)
 ActiveRecord::Base.extend(ActiveRecordShards::DefaultSlavePatches)
 ActiveRecord::Relation.include(ActiveRecordShards::DefaultSlavePatches::ActiveRelationPatches)
 ActiveRecord::Associations::CollectionProxy.include(ActiveRecordShards::AssociationCollectionConnectionSelection)
-ActiveRecord::Associations::Builder::HasAndBelongsToMany.include(ActiveRecordShards::DefaultSlavePatches::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', '6.0'
-  :ok
-else
-  raise "ActiveRecordShards is not compatible with #{ActiveRecord::VERSION::STRING}"
-end
+ActiveRecord::Associations::Builder::HasAndBelongsToMany.include(ActiveRecordShards::DefaultSlavePatches::HasAndBelongsToManyBuilderExtension)

data/lib/active_record_shards/association_collection_connection_selection.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-
 module ActiveRecordShards
   module AssociationCollectionConnectionSelection
     def on_slave_if(condition)
@@ -32,7 +31,7 @@ module ActiveRecordShards
         @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

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')

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.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.keys.inspect})"
-      end
-
-      name
-    end
-
     private
 
     def ensure_shard_connection

data/lib/active_record_shards/connection_switcher.rb

@@ -1,33 +1,18 @@
 # frozen_string_literal: true
-
 require 'active_record_shards/shard_support'
 
 module ActiveRecordShards
   module ConnectionSwitcher
-    SHARD_NAMES_CONFIG_KEY = 'shard_names'
+    SHARD_NAMES_CONFIG_KEY = 'shard_names'.freeze
 
     def self.extended(base)
-      if ActiveRecord::VERSION::MAJOR >= 5
-        base.singleton_class.send(:alias_method, :load_schema_without_default_shard!, :load_schema!)
-        base.singleton_class.send(:alias_method, :load_schema!, :load_schema_with_default_shard!)
-      else
-        base.singleton_class.send(:alias_method, :columns_without_default_shard, :columns)
-        base.singleton_class.send(:alias_method, :columns, :columns_with_default_shard)
-      end
+      base.singleton_class.send(:alias_method, :load_schema_without_default_shard!, :load_schema!)
+      base.singleton_class.send(:alias_method, :load_schema!, :load_schema_with_default_shard!)
 
       base.singleton_class.send(:alias_method, :table_exists_without_default_shard?, :table_exists?)
       base.singleton_class.send(:alias_method, :table_exists?, :table_exists_with_default_shard?)
     end
 
-    def default_shard=(new_default_shard)
-      ActiveRecordShards::ShardSelection.default_shard = new_default_shard
-      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?
@@ -36,9 +21,9 @@ module ActiveRecordShards
       switch_connection(old_options)
     end
 
-    def on_first_shard(&block)
+    def on_first_shard
       shard_name = shard_names.first
-      on_shard(shard_name, &block)
+      on_shard(shard_name) { yield }
     end
 
     def shards
@@ -100,11 +85,6 @@ module ActiveRecordShards
       on_master_or_slave(:master, &block)
     end
 
-    # 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
-
     def on_cx_switch_block(which, force: false, construct_ro_scope: nil, &block)
       @disallow_slave ||= 0
       @disallow_slave += 1 if which == :master
@@ -126,6 +106,16 @@ module ActiveRecordShards
       switch_connection(old_options) if old_options
     end
 
+    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.inspect})"
+      end
+
+      name
+    end
+
     def supports_sharding?
       shard_names.any?
     end
@@ -135,7 +125,7 @@ module ActiveRecordShards
     end
 
     def current_shard_selection
-      Thread.current[:shard_selection] ||= ShardSelection.new
+      Thread.current[:shard_selection] ||= ShardSelection.new(shard_names.first)
     end
 
     def current_shard_id
@@ -144,31 +134,35 @@ module ActiveRecordShards
 
     def shard_names
       unless config = 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})"
+        raise "Did not find #{shard_env} in configurations, did you forget to add it to your database config? (configurations: #{configurations.inspect})"
+      end
+      unless config[SHARD_NAMES_CONFIG_KEY]
+        raise "No shards configured for #{shard_env}"
       end
-      unless config.fetch(SHARD_NAMES_CONFIG_KEY, []).all? { |shard_name| shard_name.is_a?(Integer) }
+      unless config[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] || []
+      config[SHARD_NAMES_CONFIG_KEY]
     end
 
     private
 
     def switch_connection(options)
       if options.any?
-        if options.key?(:slave)
-          current_shard_selection.on_slave = options[:slave]
-        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})"
+          unless config = configurations[shard_env]
+            raise "Did not find #{shard_env} in configurations, did you forget to add it to your database config? (configurations: #{configurations.inspect})"
+          end
+          unless config['shard_names'].include?(options[:shard])
+            raise "Did not find shard #{options[:shard]} in configurations"
           end
-
           current_shard_selection.shard = options[:shard]
         end
 
+        if options.key?(:slave)
+          current_shard_selection.on_slave = options[:slave]
+        end
+
         ensure_shard_connection
       end
     end
@@ -177,22 +171,16 @@ module ActiveRecordShards
       ActiveRecordShards.rails_env
     end
 
-    def with_default_shard(&block)
+    def with_default_shard
       if is_sharded? && current_shard_id.nil? && table_name != ActiveRecord::SchemaMigration.table_name
-        on_first_shard(&block)
+        on_first_shard { yield }
       else
         yield
       end
     end
 
-    if ActiveRecord::VERSION::MAJOR >= 5
-      def load_schema_with_default_shard!
-        with_default_shard { load_schema_without_default_shard! }
-      end
-    else
-      def columns_with_default_shard
-        with_default_shard { columns_without_default_shard }
-      end
+    def load_schema_with_default_shard!
+      with_default_shard { load_schema_without_default_shard! }
     end
 
     def table_exists_with_default_shard?
@@ -205,7 +193,7 @@ module ActiveRecordShards
         @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
         @target.on_master_or_slave(@which) { @target.send(method, *args, &block) }
       end
     end
@@ -213,11 +201,9 @@ module ActiveRecordShards
 end
 
 case "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"
-when '4.2'
-  require 'active_record_shards/connection_switcher-4-2'
 when '5.0'
   require 'active_record_shards/connection_switcher-5-0'
-when '5.1', '5.2', '6.0'
+when '5.1'
   require 'active_record_shards/connection_switcher-5-1'
 else
   raise "ActiveRecordShards is not compatible with #{ActiveRecord::VERSION::STRING}"