activerecord-sharding 0.1.0

data/lib/active_record/sharding/sequencer_repository.rb

@@ -0,0 +1,22 @@
+module ActiveRecord
+  module Sharding
+    class SequencerRepository < AbstractRepository
+      attr_reader :base_class
+
+      def initialize(sequencer_config, base_class)
+        @base_class = base_class
+        @sequencer = { sequencer_config.name => generate_model_for_shard(sequencer_config.connection_name) }
+      end
+
+      def fetch(connection_name)
+        @sequencer.fetch connection_name
+      end
+
+      private
+
+      def generate_class_name(connection_name)
+        "SequencerFor#{connection_name.to_s.tr('-', '_').classify}"
+      end
+    end
+  end
+end

data/lib/active_record/sharding/shard_repository.rb

@@ -0,0 +1,31 @@
+module ActiveRecord
+  module Sharding
+    class ShardRepository < AbstractRepository
+      attr_reader :base_class
+
+      def initialize(cluster_config, base_class)
+        @base_class = base_class
+
+        shards = cluster_config.connections.map do |connection_name|
+          [connection_name, generate_model_for_shard(connection_name)]
+        end
+
+        @shards = Hash[shards]
+      end
+
+      def fetch(connection_name)
+        @shards.fetch connection_name
+      end
+
+      def all
+        @shards.values
+      end
+
+      private
+
+      def generate_class_name(connection_name)
+        "ShardFor#{connection_name.to_s.tr('-', '_').classify}"
+      end
+    end
+  end
+end

data/lib/active_record/sharding/version.rb

@@ -0,0 +1,5 @@
+module ActiveRecord
+  module Sharding
+    VERSION = "0.1.0"
+  end
+end

data/lib/activerecord-sharding.rb

@@ -0,0 +1,30 @@
+require "active_record"
+
+require "active_record/sharding/version"
+require "active_record/sharding/errors"
+require "active_record/sharding/config"
+require "active_record/sharding/cluster_config"
+require "active_record/sharding/modulo_router"
+require "active_record/sharding/abstract_repository"
+require "active_record/sharding/shard_repository"
+require "active_record/sharding/database_tasks"
+require "active_record/sharding/model"
+require "active_record/sharding/sequencer"
+require "active_record/sharding/sequencer_repository"
+require "active_record/sharding/sequencer_config"
+
+module ActiveRecord
+  module Sharding
+    class << self
+      def config
+        @config ||= Config.new
+      end
+
+      def configure(&block)
+        config.instance_eval(&block)
+      end
+    end
+  end
+end
+
+require "active_record/sharding/railtie" if defined? Rails

data/lib/tasks/activerecord-sharding.rake

@@ -0,0 +1,88 @@
+namespace :active_record do
+  namespace :sharding do
+    desc "Show all defined clusters and their detail"
+    task info: %i(environment) do
+      ActiveRecord::Sharding::DatabaseTasks.info
+    end
+
+    desc "Setup all databases in all clusters"
+    task setup: %i(create_all load_schema_all) do
+    end
+
+    desc "Create all databases in all clusters"
+    task :create_all => :environment do
+      ActiveRecord::Sharding::DatabaseTasks.invoke_task_for_all_clusters("create")
+    end
+
+    desc "Drop all databases in all clusters"
+    task :drop_all => :environment do
+      ActiveRecord::Sharding::DatabaseTasks.invoke_task_for_all_clusters("drop")
+    end
+
+    desc "Load schema to all databases in all clusters"
+    task :load_schema_all => :environment do
+      ActiveRecord::Sharding::DatabaseTasks.invoke_task_for_all_clusters("load_schema")
+    end
+
+    desc "Create all databases in specific cluster"
+    task :create, %i(cluster_name) => %i(environment) do |_, args|
+      ActiveRecord::Sharding::DatabaseTasks.create_all_databases(args)
+    end
+
+    desc "Drop all databases in specific cluster"
+    task :drop, %i(cluster_name) => %i(environment) do |_, args|
+      ActiveRecord::Sharding::DatabaseTasks.drop_all_databases(args)
+    end
+
+    desc "Load schema to all databases in specific cluster"
+    task :load_schema, %i(cluster_name) => %i(environment) do |_, args|
+      ActiveRecord::Sharding::DatabaseTasks.load_schema_all_databases(args)
+    end
+
+    namespace :sequencer do
+      desc "Create database in specific sequencer"
+      task :create, %i(sequencer_name) => %i(environment) do |_, args|
+        ActiveRecord::Sharding::DatabaseTasks.create_sequencer_database(args)
+      end
+
+      desc "Drop database in specific sequencer"
+      task :drop, %i(sequencer_name) => %i(environment) do |_, args|
+        ActiveRecord::Sharding::DatabaseTasks.drop_sequencer_database(args)
+      end
+
+      desc "Create sequencer table in specific sequencer database"
+      task :create_table, %i(sequencer_name) => %i(environment) do |_, args|
+        ActiveRecord::Sharding::DatabaseTasks.create_table_sequencer_database(args)
+      end
+
+      desc "Insert initial record in specific sequencer database"
+      task :insert_initial_record, %i(sequencer_name) => %i(environment) do |_, args|
+        ActiveRecord::Sharding::DatabaseTasks.insert_initial_record_sequencer_database(args)
+      end
+
+      desc "Setup all databases in sequencers"
+      task setup: %i(create_all create_table_all insert_initial_record_all) do
+      end
+
+      desc "Create all databases in all sequencers"
+      task :create_all => :environment do
+        ActiveRecord::Sharding::DatabaseTasks.invoke_task_for_all_sequencers("create")
+      end
+
+      desc "Create table in all sequencers databases"
+      task :create_table_all => :environment do
+        ActiveRecord::Sharding::DatabaseTasks.invoke_task_for_all_sequencers("create_table")
+      end
+
+      desc "Insert inital record in all sequencers tables"
+      task :insert_initial_record_all => :environment do
+        ActiveRecord::Sharding::DatabaseTasks.invoke_task_for_all_sequencers("insert_initial_record")
+      end
+
+      desc "Drop all databases in all sequencers"
+      task :drop_all => :environment do
+        ActiveRecord::Sharding::DatabaseTasks.invoke_task_for_all_sequencers("drop")
+      end
+    end
+  end
+end

data/spec/active_record/sharding/abstract_repository_spec.rb

@@ -0,0 +1,15 @@
+describe ActiveRecord::Sharding::AbstractRepository do
+  describe "#generate_class_name" do
+    let!(:repository) do
+      Class.new(ActiveRecord::Sharding::AbstractRepository) do
+        def initialize
+          generate_class_name "test"
+        end
+      end
+    end
+
+    it "raise NotImplementedError" do
+      expect { repository.new }.to raise_error NotImplementedError
+    end
+  end
+end

data/spec/active_record/sharding/cluster_config_spec.rb

@@ -0,0 +1,41 @@
+describe ActiveRecord::Sharding::ClusterConfig do
+  let(:config) { described_class.new(:user) }
+
+  it "returns cluster config name" do
+    expect(config.name).to eq :user
+  end
+
+  describe '#register_connection' do
+    let(:db_connection_001) { :production_user_001 }
+    let(:db_connection_002) { :production_user_002 }
+    let(:db_connection_003) { :production_user_003 }
+
+    before do
+      config.register_connection :db_connection_001
+      config.register_connection :db_connection_002
+      config.register_connection :db_connection_003
+    end
+
+    describe '#registerd_connection_count' do
+      it "returns registerd total connection count" do
+        expect(config.registerd_connection_count).to eq 3
+      end
+    end
+
+    describe '#fetch' do
+      it "returns database connection name by modulo number" do
+        expect(config.fetch 0).to eq :db_connection_001
+        expect(config.fetch 1).to eq :db_connection_002
+        expect(config.fetch 2).to eq :db_connection_003
+      end
+    end
+  end
+
+  describe '#validate_config!' do
+    context "Nothing register connection" do
+      it "returns raise" do
+        expect { config.validate_config! }.to raise_error "Nothing registerd connections."
+      end
+    end
+  end
+end

data/spec/active_record/sharding/errors_spec.rb

@@ -0,0 +1,9 @@
+describe ActiveRecord::Sharding::Error do
+  it "is defined class" do
+    expect(described_class).to be_a Class
+  end
+
+  it "kind of StandardError" do
+    expect(described_class.new).to be_kind_of StandardError
+  end
+end

data/spec/active_record/sharding/model_spec.rb

@@ -0,0 +1,90 @@
+describe ActiveRecord::Sharding::Model do
+  let!(:model) do
+    Class.new(ActiveRecord::Base) do
+      def self.name
+        "User"
+      end
+
+      def self.sequence_id
+        @sequence_id ||= 0
+      end
+
+      class << self
+        attr_writer :sequence_id
+      end
+
+      def self.next_sequence_id
+        self.sequence_id += 1
+      end
+
+      include ActiveRecord::Sharding::Model
+      use_sharding :user, :modulo
+      define_sharding_key :id
+
+      before_put do |attrs|
+        attrs[:id] = next_sequence_id unless attrs[:id]
+      end
+
+      define_parent_methods do
+        def find_from_all_by_name(name)
+          all_shards.map { |m| m.find_by(name: name) }.compact.first
+        end
+      end
+    end
+  end
+
+  let(:alice) { model.put! name: "Alice" }
+
+  describe ".put!" do
+    it "example" do
+      expect(alice.persisted?).to be true
+      expect(alice.name).to eq "Alice"
+      expect(alice.class.name).to match(/User::ShardFor/)
+    end
+
+    context 'next call #put!' do
+      let(:bob) { model.put! name: "Bob" }
+      let(:alice_connect_db) { alice.class.connection.pool.spec.config[:database] }
+      let(:bob_connect_db) { bob.class.connection.pool.spec.config[:database] }
+
+      it "different connection database" do
+        expect(alice_connect_db).not_to eq bob_connect_db
+      end
+    end
+
+    context "Not included sharding key in args" do
+      before do
+        allow(User).to receive(:sharding_key).and_return(:dammy_sharding_key)
+      end
+
+      it "raise ActiveRecord::Sharding::MissingShardingKeyAttribute" do
+        expect do
+          User.put! name: "foobar"
+        end.to raise_error ActiveRecord::Sharding::MissingShardingKeyAttribute
+      end
+    end
+  end
+
+  describe ".shard_for" do
+    before { alice }
+
+    it "example" do
+      user_record = model.shard_for(alice.id).find_by name: "Alice"
+      expect(user_record).not_to be nil
+      expect(user_record.name).to eq "Alice"
+    end
+  end
+
+  describe ".define_parent_methods" do
+    before do
+      model.put! name: "foo"
+      model.put! name: "bar"
+    end
+
+    it "enables to define class methods to parent class" do
+      record = model.find_from_all_by_name("foo")
+      expect(record).not_to be_nil
+      expect(record.name).to eq("foo")
+    end
+  end
+end

data/spec/active_record/sharding/modulo_router_spec.rb

@@ -0,0 +1,22 @@
+describe ActiveRecord::Sharding::ModuloRouter do
+  let(:cluster_config) do
+    cluster_config = ActiveRecord::Sharding::ClusterConfig.new :user
+    cluster_config.register_connection :db_connection_001
+    cluster_config.register_connection :db_connection_002
+    cluster_config.register_connection :db_connection_003
+    cluster_config
+  end
+
+  let(:router) { described_class.new cluster_config }
+
+  describe '#route' do
+    it "returns database connection name by id % cluster nodes" do
+      expect(router.route(1)).to eq :db_connection_002
+      expect(router.route(2)).to eq :db_connection_003
+      expect(router.route(3)).to eq :db_connection_001
+      expect(router.route(4)).to eq :db_connection_002
+      expect(router.route(5)).to eq :db_connection_003
+      expect(router.route(6)).to eq :db_connection_001
+    end
+  end
+end

data/spec/active_record/sharding/sequencer_spec.rb

@@ -0,0 +1,31 @@
+describe ActiveRecord::Sharding::Model do
+  let!(:model) do
+    Class.new(ActiveRecord::Base) do
+      def self.name
+        "User"
+      end
+
+      include ActiveRecord::Sharding::Sequencer
+      use_sequencer :user
+    end
+  end
+
+  describe '#current_sequence_id' do
+    it "returns current sequence id" do
+      expect(model.current_sequence_id).to be_a_kind_of Fixnum
+    end
+  end
+  describe '#next_sequence_id' do
+    let(:current_id) { model.current_sequence_id }
+    let(:next_id) { model.next_sequence_id }
+
+    it "returns next sequence id" do
+      expect(current_id + 1).to eq next_id
+      expect(next_id).to be_a_kind_of Fixnum
+    end
+
+    it "next sequence id > current sequence id" do
+      expect(current_id).to be < next_id
+    end
+  end
+end

data/spec/active_record/sharding/shard_repository_spec.rb

@@ -0,0 +1,21 @@
+describe ActiveRecord::Sharding::ShardRepository do
+  let(:cluster_config) { ActiveRecord::Sharding.config.fetch_cluster_config(:user) }
+  let(:shard_repository) { described_class.new cluster_config, User }
+
+  describe '#fetch' do
+    it "returns User class base shard object" do
+      expect(shard_repository.fetch(:test_user_001).connection).to be_a ActiveRecord::ConnectionAdapters::AbstractAdapter
+      expect(shard_repository.fetch(:test_user_001).table_name).to eq "users"
+      expect(shard_repository.fetch(:test_user_001).name).to eq "User::ShardForTestUser001"
+    end
+  end
+
+  describe '#all' do
+    it "returns all shard class objects" do
+      expect(shard_repository.all.count).to eq 3
+      expect(shard_repository.all[0]).to eq shard_repository.fetch(:test_user_001)
+      expect(shard_repository.all[1]).to eq shard_repository.fetch(:test_user_002)
+      expect(shard_repository.all[2]).to eq shard_repository.fetch(:test_user_003)
+    end
+  end
+end

data/spec/active_record_sharding_spec.rb

@@ -0,0 +1,15 @@
+describe ActiveRecord::Sharding do
+  it "has a version number" do
+    expect(ActiveRecord::Sharding::VERSION).not_to be nil
+  end
+
+  describe ".config" do
+    it "returns Config class" do
+      expect(ActiveRecord::Sharding.config).to be_a ActiveRecord::Sharding::Config
+    end
+
+    it "returns equal instance, every call" do
+      expect(ActiveRecord::Sharding.config).to eq ActiveRecord::Sharding.config
+    end
+  end
+end

data/spec/models.rb

@@ -0,0 +1,51 @@
+base = { "adapter" => "mysql2", "encoding" => "utf8", "pool" => 5, "username" => "root", "password" => "", "host" => "localhost" }
+ActiveRecord::Base.configurations = {
+  "test_user_001" => base.merge("database" => "user_001"),
+  "test_user_002" => base.merge("database" => "user_002"),
+  "test_user_003" => base.merge("database" => "user_003"),
+  "test_user_sequencer" => base.merge("database" => "user_sequencer"),
+  "test" => base.merge("database" => "default")
+}
+ActiveRecord::Base.establish_connection(:test)
+
+ActiveRecord::Sharding.configure do |config|
+  config.define_cluster(:user) do |cluster|
+    cluster.register_connection(:test_user_001)
+    cluster.register_connection(:test_user_002)
+    cluster.register_connection(:test_user_003)
+  end
+
+  config.define_sequencer(:user) do |sequencer|
+    sequencer.register_connection(:test_user_sequencer)
+    sequencer.register_table_name("user_id")
+  end
+end
+
+class User < ActiveRecord::Base
+  def items
+    return [] unless id
+    Item.shard_for(id).where(user_id: id).all
+  end
+
+  include ActiveRecord::Sharding::Model
+  use_sharding :user, :modulo
+  define_sharding_key :id
+
+  include ActiveRecord::Sharding::Sequencer
+  use_sequencer :user
+
+  before_put do |attributes|
+    attributes[:id] = next_sequence_id unless attributes[:id]
+  end
+end
+
+class Item < ActiveRecord::Base
+  def user
+    return unless user_id
+    User.shard_for(user_id).find_by user_id
+  end
+
+  include ActiveRecord::Sharding::Model
+  use_sharding :user, :modulo
+  define_sharding_key :user_id
+end