dynashard 0.3.1 → 0.4.0

data/README.md

@@ -39,39 +39,34 @@ models may shard using different contexts.
         end
     end
 
-Associated models may be configured to use different shards determined by the
-association's owner.
+Sharded models are returned as objects of a shard-specific subclass.
 
-    class Company < ActiveRecord::Base
-      shard :associated, :using => :shard
-  
-      has_many :customers
-  
-      def shard
-        # logic to find the company's shard
-      end
-    end
-  
-    class Customer < ActiveRecord::Base
-      belongs_to :company
-      shard :by => :company
-    end
-  
-    > c = Company.find(:first)
-    => #<Company id:1>
+    > new_widget = Dynashard.with_context(:user => 'shard1') {Widget.new(:name => 'New widget')}
+    => <#Dynashard::Shard0::Widget id: nil, name: "New widget">
 
-  Company is loaded using the default ActiveRecord connection.
+    > created_widget = Dynashard.with_context(:user => 'shard2') {Widget.create(:name => 'Created widget')}
+    => <#Dynashard::Shard1::Widget id: 1, name: "Created widget">
 
-    > c.customers
-    => [#<Dynashard::Shard0::Customer id: 1>, #<Dynashard::Shard0::Customer id: 2>]
+    > found_widget = Dynashard.with_context(:user => 'shard3') {Widget.find(:first)}
+    => <#Dynashard::Shard2::Widget id: 4, name: "Found widget">
 
-  Customers are loaded using the connection for the Company's shard.  Associated models
-  are returned as shard-specific subclasses of the association class.
+    > found_widgets = Dynashard.with_context(:user => 'shard3') {Widget.find(:all)}
+    => [<#Dynashard::Shard2::Widget id: 4, name: "Found widget">, <#Dynashard::Shard2::Widget id: 5, name: "Other found widget">]
 
-    > c.customers.create(:name => 'Always right')
-    => #<Dynashard::Shard0::Customer id: 3>
+  New objects are saved on the shard with the context that was active
+  when the object was initialized.
+
+    > new_widget.save
+    => <#Dynashard::Shard0::Widget id: 1, name: "New widget">  # saved on 'shard1'
+
+  Created and found objects are updated on the shard with the context
+  that was active when they were created or found.
 
-  New associations are saved on the Company's shard.
+    > created_widget.update_attribute(:name, 'New name')
+    => true  # updated on 'shard2'
+
+    > found_widget.update_attributes(:name => 'Updated name')
+    => true  # updated on 'shard3'
 
 Shard context values may be a valid argument to establish_connection()
 such as a string reference to a configuration from config/database.yml
@@ -96,13 +91,13 @@ establish_connection().
       <<: *defaults
 
     > @widgets = Dynashard.with_context(:user => 'shard1') { Widget.find(:all) }
-    => [#<Widget id:1>, #<Widget id:2>]
+    => [#<Dynashard::Shard0::Widget id:1>, #<Dynashard::Shard0::Widget id:2>]
 
   Load widgets from a shard using a hash of connection params
 
     > conn = {:adapter => 'sqlite3', :database => 'db/shard3.sqlite3'}
     > @widgets = Dynashard.with_context(:user => conn) { Widget.find(:all) }
-    => [#<Widget id:1>, #<Widget id:2>]
+    => [#<Dynashard::Shard2::Widget id:1>, #<Dynashard::Shard2::Widget id:2>]
 
   Create a widget using a method to determine the shard
 
@@ -120,7 +115,7 @@ establish_connection().
     > new_widget = Dynashard.with_context(:user => widget_shard) do
         Widget.create(:name => 'The newest of the widgets')
       end
-    => <#Widget id:3>
+    => <#Dynashard::Shard4::Widget id:3>
 
   Use a Rails initializer for one-time configuration of shard context
 
@@ -132,20 +127,59 @@ establish_connection().
     end
 
     > new_widget = Widget.create(:name => 'Put this on the smallest shard')
-    => <#Widget id:4>
+    => <#Dynashard::Shard5::Widget id:4>
 
   Use with_context to override an earlier context setting
 
     > Dynashard.shard_context[:user] = 'shard1'
     > new_widget = Widget.create(:name => 'Put this on shard1')
-    => <#Widget id:5>
+    => <#Dynashard::Shard0::Widget id:5>
     > new_widget = Dynashard.with_context(:user => 'shard2') do
         Widget.create(:name => 'Put this on shard2')
       do
-    > <#Widget id:6>
+    > <#Dynashard::Shard1::Widget id:6>
+
+Associated models may be configured to use different shards determined by the
+association's owner.
+
+    class Company < ActiveRecord::Base
+      shard :associated, :using => :shard
+
+      has_many :customers
+
+      def shard
+        # logic to find the company's shard
+      end
+    end
+
+    class Customer < ActiveRecord::Base
+      belongs_to :company
+      shard :by => :company
+    end
+
+  Load a Company using the default ActiveRecord connection.
+
+    > c = Company.find(:first)
+    => #<Company id:1>
+
+  Load Customers using the connection for the Company's shard.
+  Associated models are returns as shard-specific subclasses of the
+  association class.
+
+    > c.customers
+    => [#<Dynashard::Shard0::Customer id: 1>, #<Dynashard::Shard0::Customer id: 2>]
+
+  Save new associations on the Company's shard.
+
+    > c.customers.create(:name => 'Always right')
+    => #<Dynashard::Shard0::Customer id: 3>
 
 ## TODO: add gotcha section, eg:
 
+ - many-to-many associations can only be used across shards in one
+   direction, where the association target and the join table exist
+   on the same database connection (else joins don't work.)
  - uniqueness validations should be scoped by whatever is sharding
  - ways to shoot yourself in the foot with non-sharding association
    owners of sharded models
+ - investigate proxy extend for association proxy

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.4.0

data/dynashard.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dynashard}
-  s.version = "0.3.1"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Nick Hengeveld"]
-  s.date = %q{2011-02-01}
+  s.date = %q{2011-02-14}
   s.description = %q{Dynashard allows you to shard your ActiveRecord models.  Models can be configured to shard based on context that can be defined dynamically.}
   s.email = %q{nickh@verticalresponse.com}
   s.extra_rdoc_files = [

data/lib/dynashard/associations.rb

@@ -4,15 +4,30 @@ module Dynashard
       base.alias_method_chain :initialize, :dynashard
     end
 
-    # Initialize an association proxy.  If the proxy owner class is configured to
-    # shard its associations and the reflection klass is sharded, use a custom
-    # reflection with a sharded class.
+    # Initialize an association proxy.  If the proxy target needs to be sharded,
+    # swap in a reflection with a sharded "klass" to ensure that the shard
+    # connection is always used to manage records in the target model.
     def initialize_with_dynashard(owner, reflection)
-      if owner.class.shards_associated? && reflection.klass.sharding_enabled?
+      if needs_sharded_reflection?(owner, reflection)
         reflection = Dynashard.reflection_for(owner, reflection)
+        if reflection.through_reflection != false && reflection.through_reflection.klass.sharding_enabled?
+          reflection.instance_variable_set('@through_reflection', Dynashard.reflection_for(owner, reflection.through_reflection))
+        end
       end
       initialize_without_dynashard(owner, reflection)
     end
+
+    private
+
+      # The reflection needs to use a sharded model class in these situations:
+      # - the proxy owner shards associations, and the proxy target has sharding enabled
+      # - the proxy owner is a dynashard-generated model class,
+      #   the reflection class is configured to shard,
+      #   the proxy owner superclass and reflection klass use the same shard context
+      def needs_sharded_reflection?(owner, reflection)
+        (owner.class.shards_associated? && reflection.klass.sharding_enabled?) ||
+        (owner.class.dynashard_model? && reflection.klass.sharding_enabled? && owner.class.superclass.dynashard_context == reflection.klass.dynashard_context)
+      end
   end
 end
 

data/lib/dynashard/connection_handler.rb

@@ -31,7 +31,7 @@ module Dynashard
         retrieve_connection_pool_without_dynashard(klass.dynashard_klass)
       elsif klass.sharding_enabled?
         spec = Dynashard.shard_context[klass.dynashard_context]
-        raise "Missing #{klass.dynashard_context} shard context" if spec.nil?
+        raise "Missing #{klass.dynashard_context} shard context for #{klass.name}" if spec.nil?
         spec = spec.call if spec.respond_to?(:call)
         shard_klass = Dynashard.class_for(spec)
         retrieve_connection_pool_without_dynashard(shard_klass)

data/lib/dynashard/model.rb

@@ -3,18 +3,11 @@ module Dynashard
     def self.extended(base)
       base.extend(ClassMethods)
 
-      # Change ActiveRecord::Base.arel_engine to create an engine for sharded models
-      # rather than using the ActiveRecord::Base class.
-      base.module_eval do
-        def self.arel_engine
-          if sharding_enabled?
-            Arel::Sql::Engine.new(self)
-          elsif self == ActiveRecord::Base
-            Arel::Table.engine
-          else
-            connection_handler.connection_pools[name] ? Arel::Sql::Engine.new(self) : superclass.arel_engine
-          end
-        end
+      class << base
+        alias_method_chain :new,         :dynashard
+        alias_method_chain :instantiate, :dynashard
+        alias_method_chain :create,      :dynashard
+        alias_method_chain :arel_engine, :dynashard
       end
     end
 
@@ -85,6 +78,52 @@ module Dynashard
       def dynashard_association_using
         @dynashard_association_using
       end
+
+      # For sharded models, return a Arel::Sql::Engine for the shard class rather
+      # than ActiveRecord::Base.
+      def arel_engine_with_dynashard
+        if sharding_enabled?
+          Arel::Sql::Engine.new(self)
+        else
+          arel_engine_without_dynashard
+        end
+      end
+
+      # For sharded models, return new model objects with the sharded subclass
+      #
+      #   > Dynashard.with_context(:owner => 'shard1'){ShardedModel.new(attrs)}
+      #   => <#Dynashard::Shard0::ShardedModel id:nil>
+      def new_with_dynashard(*args)
+        if sharding_enabled?
+          dynashard_sharded_subclass.send(:new_without_dynashard, *args)
+        else
+          new_without_dynashard(*args)
+        end
+      end
+
+      # For sharded models, return instantiated model objects with the sharded subclass
+      #
+      #   > Dynashard.with_context(:owner => 'shard1'){ShardedModel.find(:first)}
+      #   => <#Dynashard::Shard0::ShardedModel id:1>
+      def instantiate_with_dynashard(record)
+        if sharding_enabled?
+          dynashard_sharded_subclass.send(:instantiate_without_dynashard, record)
+        else
+          instantiate_without_dynashard(record)
+        end
+      end
+
+      # For sharded models, return created model objects with the sharded subclass
+      #
+      #   > Dynashard.with_context(:owner => 'shard1'){ShardedModel.create(attrs)}
+      #   => <#Dynashard::Shard0::ShardedModel id:2>
+      def create_with_dynashard(attributes = nil, &block)
+        if sharding_enabled?
+          dynashard_sharded_subclass.send(:create_without_dynashard, attributes, &block)
+        else
+          create_without_dynashard(attributes, &block)
+        end
+      end
     end
   end
 end

data/lib/dynashard.rb

@@ -112,7 +112,11 @@ module Dynashard
   # Return a reflection with a sharded class
   def self.reflection_for(owner, reflection)
     reflection_copy = reflection.dup
-    shard_klass = Dynashard.class_for(owner.send(owner.class.dynashard_association_using))
+    shard_klass = if owner.class.respond_to?(:dynashard_klass)
+      owner.class.dynashard_klass
+    else
+      Dynashard.class_for(owner.send(owner.class.dynashard_association_using))
+    end
     klass = sharded_model_class(shard_klass, reflection.klass)
     reflection_copy.instance_variable_set('@klass', klass)
     reflection_copy.instance_variable_set('@class_name', klass.name)
@@ -139,6 +143,10 @@ module Dynashard
           def self.connection
             dynashard_klass.connection
           end
+
+          def self.dynashard_context
+            superclass.dynashard_context
+          end
         end
 EOE
       klass = class_name.constantize

data/spec/associations_spec.rb

@@ -1,5 +1,15 @@
 require 'spec_helper'
 
+class SqlCounter
+  def initialize(connection, counter_sql)
+    @connection, @counter_sql = connection, counter_sql
+  end
+
+  def count
+    @connection.execute(@counter_sql).first[0]
+  end
+end
+
 describe 'Dynashard::ProxyExtensions' do
   before(:each) do
     Dynashard.enable
@@ -9,6 +19,7 @@ describe 'Dynashard::ProxyExtensions' do
     before(:each) do
       @owner = Factory(:sharding_owner)
       @shard = @owner.shard_dsn
+      @shard_klass = Dynashard.class_for(@shard)
     end
 
     context 'and a sharding proxy target' do
@@ -102,42 +113,115 @@ describe 'Dynashard::ProxyExtensions' do
 
       context 'using a :has_many_through reflection' do
         before(:each) do
-          # Ensure that all sharded model connections happen on the owner shard
-          Dynashard.shard_context[:owner] = @shard
+          @sharded_has_many_through_klass = Dynashard.sharded_model_class(@shard_klass, ShardedHasManyThrough)
+          @sharded_join_klass = Dynashard.sharded_model_class(@shard_klass, ShardedJoin)
+          @shard_klass.connection.execute("INSERT INTO sharded_has_many_throughs (name) VALUES ('#{Factory.next :name}')")
+          one_of_many_id = @shard_klass.connection.execute("SELECT last_insert_rowid()").first[0]
+          @shard_klass.connection.execute("INSERT INTO sharded_joins (sharding_owner_id, sharded_has_many_through_id) VALUES (#{@owner.id}, #{one_of_many_id})")
+          join_id = @shard_klass.connection.execute("SELECT last_insert_rowid()").first[0]
+          @one_of_many = @sharded_has_many_through_klass.find(one_of_many_id)
+        end
 
-          @one_of_many = Factory(:sharded_has_many_through, :name => "Owned by #{@owner.name}")
-          join = Factory(:sharded_join, :sharding_owner => @owner, :sharded_has_many_through => @one_of_many)
+        it 'reads from the shard' do
+          @owner.sharded_has_many_throughs.should include(@one_of_many)
         end
 
-        after(:each) do
-          Dynashard.shard_context.clear
+        it 'destroys the model from the shard' do
+          lambda {@one_of_many.destroy}.should change(@sharded_has_many_through_klass, :count).by(-1)
         end
 
-        # TODO: figure out what to do about the classes being different
-        it 'reads from the shard' do
-          @owner.sharded_has_many_throughs.detect{|m| m.attributes == @one_of_many.attributes}.should_not be_nil
+        # This class does not have :dependent => :destroy on the join
+        it 'leaves the join on the shard' do
+          lambda {@one_of_many.destroy}.should_not change(@sharded_join_klass, :count)
         end
 
-        it 'destroys from the shard' do
+        it 'creates_other on the shard' do
           lambda do
-            one_of_many = @owner.sharded_has_many_throughs.detect{|m| m.attributes == @one_of_many.attributes}
-            one_of_many.destroy
-          end.should change(ShardedHasManyThrough, :count).by(-1)
+            @owner.sharded_has_many_throughs.create(:name => Factory.next(:name))
+          end.should change(@sharded_has_many_through_klass, :count).by(1)
         end
 
-        it 'creates_other on the shard' do
-          new_owner = Factory(:sharding_owner, :shard => @owner.shard)
+        it 'creates joins on the shard' do
           lambda do
-            new_owner.sharded_has_many_throughs.create(:name => "Owned by #{new_owner.name}")
-          end.should change(ShardedHasManyThrough, :count).by(1)
+            @owner.sharded_has_many_throughs.create(:name => Factory.next(:name))
+          end.should change(@sharded_join_klass, :count).by(1)
         end
 
         it 'saves built associations on the shard' do
-          new_owner = Factory(:sharding_owner, :shard => @owner.shard)
-          new_one_of_many = new_owner.sharded_has_many_throughs.build(:name => "Owned by #{new_owner.name}")
+          new_one_of_many = @owner.sharded_has_many_throughs.build(:name => Factory.next(:name))
+          lambda {@owner.save}.should change(@sharded_has_many_through_klass, :count).by(1)
+        end
+
+        it 'saves built association joins on the shard' do
+          new_one_of_many = @owner.sharded_has_many_throughs.build(:name => Factory.next(:name))
+          lambda {@owner.save}.should change(@sharded_join_klass, :count).by(1)
+        end
+
+        context 'with dependent => destroy' do
+          before(:each) do
+            @sharded_dependent_has_many_through_klass = Dynashard.sharded_model_class(@shard_klass, ShardedDependentHasManyThrough)
+            @sharded_dependent_join_klass = Dynashard.sharded_model_class(@shard_klass, ShardedDependentJoin)
+            @shard_klass.connection.execute("INSERT INTO sharded_dependent_has_many_throughs (name) VALUES ('#{Factory.next :name}')")
+            one_of_many_id = @shard_klass.connection.execute("SELECT last_insert_rowid()").first[0]
+            @shard_klass.connection.execute("INSERT INTO sharded_dependent_joins (sharding_owner_id, sharded_dependent_has_many_through_id) VALUES (#{@owner.id}, #{one_of_many_id})")
+            join_id = @shard_klass.connection.execute("SELECT last_insert_rowid()").first[0]
+            @dependent_one_of_many = @sharded_dependent_has_many_through_klass.find(one_of_many_id)
+          end
+
+          it 'destroys the join on the shard' do
+            lambda {@dependent_one_of_many.destroy}.should change(@sharded_dependent_join_klass, :count).by(-1)
+          end
+        end
+      end
+
+      context 'using a :has_and_belongs_to_many reflection' do
+        before(:each) do
+          @sharded_habtm_klass = Dynashard.sharded_model_class(@shard_klass, ShardedHabtm)
+          @shard_klass.connection.execute("INSERT INTO sharded_habtms (name) VALUES ('#{Factory.next :name}')")
+          habtm_id = @shard_klass.connection.execute("SELECT last_insert_rowid()").first[0]
+          @shard_klass.connection.execute("INSERT INTO sharded_habtms_sharding_owners (sharding_owner_id, sharded_habtm_id) VALUES (#{@owner.id}, #{habtm_id})")
+          @habtm = @sharded_habtm_klass.find(habtm_id)
+          @join_counter = SqlCounter.new(@shard_klass.connection, 'SELECT COUNT(*) FROM sharded_habtms_sharding_owners')
+        end
+
+        it 'reads from the shard' do
+          @owner.sharded_habtms.should include(@habtm)
+        end
+
+        it 'destroys the model from the shard' do
+          lambda {@habtm.destroy}.should change(@sharded_habtm_klass, :count).by(-1)
+        end
+
+        # Rails seems to always use the ActiveRecord::Base connection
+        # for habtm join tables
+        xit 'destroys the join on the shard' do
+          lambda {@habtm.destroy}.should change(@join_counter, :count).by(-1)
+        end
+
+        it 'creates_other on the shard' do
           lambda do
-            new_one_of_many.save
-          end.should change(ShardedHasManyThrough, :count).by(1)
+            @owner.sharded_habtms.create(:name => Factory.next(:name))
+          end.should change(@sharded_habtm_klass, :count).by(1)
+        end
+
+        # Rails seems to always use the ActiveRecord::Base connection
+        # for habtm join tables
+        xit 'creates joins on the shard' do
+          lambda do
+            @owner.sharded_habtms.create(:name => Factory.next(:name))
+          end.should change(@join_counter, :count).by(1)
+        end
+
+        it 'saves built associations on the shard' do
+          new_habtm = @owner.sharded_habtms.build(:name => Factory.next(:name))
+          lambda {@owner.save}.should change(@sharded_habtm_klass, :count).by(1)
+        end
+
+        # Rails seems to always use the ActiveRecord::Base connection
+        # for habtm join tables
+        xit 'saves built association joins on the shard' do
+          new_habtm = @owner.sharded_habtms.build(:name => Factory.next(:name))
+          lambda {@owner.save}.should change(@join_counter, :count).by(1)
         end
       end
     end

data/spec/db/schema.rb

@@ -15,23 +15,27 @@ ActiveRecord::Schema.define(:version => 1) do
   create_table "non_sharding_owners", :force => true do |t|
     t.string "name"
   end
+  add_index :non_sharding_owners, :name, :unique => true
 
   create_table "sharding_owners", :force => true do |t|
     t.string  "name"
     t.integer "shard_id"
   end
+  add_index :sharding_owners, :name, :unique => true
 
   create_table "non_sharded_has_ones", :force => true do |t|
     t.integer "sharding_owner_id"
     t.integer "non_sharding_owner_id"
     t.string  "name"
   end
+  add_index :non_sharded_has_ones, :name, :unique => true
 
   create_table "non_sharded_has_manies", :force => true do |t|
     t.integer "sharding_owner_id"
     t.integer "non_sharding_owner_id"
     t.string  "name"
   end
+  add_index :non_sharded_has_manies, :name, :unique => true
 
   create_table "non_sharded_joins", :force => true do |t|
     t.integer "sharding_owner_id"
@@ -42,18 +46,21 @@ ActiveRecord::Schema.define(:version => 1) do
   create_table "non_sharded_has_many_throughs", :force => true do |t|
     t.string  "name"
   end
+  add_index :non_sharded_has_many_throughs, :name, :unique => true
 
   create_table "sharded_has_ones", :force => true do |t|
     t.integer "sharding_owner_id"
     t.integer "non_sharding_owner_id"
     t.string  "name"
   end
+  add_index :sharded_has_ones, :name, :unique => true
 
   create_table "sharded_has_manies", :force => true do |t|
     t.integer "sharding_owner_id"
     t.integer "non_sharding_owner_id"
     t.string  "name"
   end
+  add_index :sharded_has_manies, :name, :unique => true
 
   create_table "sharded_joins", :force => true do |t|
     t.integer "sharding_owner_id"
@@ -64,4 +71,24 @@ ActiveRecord::Schema.define(:version => 1) do
   create_table "sharded_has_many_throughs", :force => true do |t|
     t.string  "name"
   end
+  add_index :sharded_has_many_throughs, :name, :unique => true
+
+  create_table "sharded_dependent_joins", :force => true do |t|
+    t.integer "sharding_owner_id"
+    t.integer "non_sharding_owner_id"
+    t.integer "sharded_dependent_has_many_through_id"
+  end
+
+  create_table "sharded_dependent_has_many_throughs", :force => true do |t|
+    t.string  "name"
+  end
+  add_index :sharded_dependent_has_many_throughs, :name, :unique => true
+
+  # create_table "sharded_habtms_sharding_owners", :id => false  # doesn't seem to create a schema without an ID...
+  connection.execute('CREATE TABLE "sharded_habtms_sharding_owners" ("sharded_habtm_id" integer, "sharding_owner_id" integer)')
+
+  create_table "sharded_habtms", :force => true do |t|
+    t.string "name"
+  end
+  add_index :sharded_habtms, :name, :unique => true
 end

data/spec/model_spec.rb

@@ -88,15 +88,53 @@ describe 'ActiveRecord Models' do
     end
 
     context 'and the shard context defined' do
-      it 'uses the sharded connection' do
-        test_shard = 'shard1'
-        Dynashard.with_context(:owner => test_shard) do
-          shard_class  = Dynashard.class_for(test_shard)
-          shard_config = shard_class.connection.instance_variable_get('@config')
-          ar_config    = ActiveRecord::Base.connection.instance_variable_get('@config')
-          model_config = ShardedHasOne.connection.instance_variable_get('@config')
-          model_config.should_not == ar_config
-          model_config.should     == shard_config
+      context 'when managing sharded models' do
+        before(:each) do
+          @shard1_klass = Dynashard.class_for('shard1')
+          @shard2_klass = Dynashard.class_for('shard2')
+          @shard1_subclass = Dynashard.sharded_model_class(@shard1_klass, ShardedHasOne)
+          @shard2_subclass = Dynashard.sharded_model_class(@shard2_klass, ShardedHasOne)
+        end
+
+        it 'uses the sharded connection for the model class' do
+          test_shard = 'shard1'
+          Dynashard.with_context(:owner => test_shard) do
+            shard_class  = Dynashard.class_for(test_shard)
+            shard_config = shard_class.connection.instance_variable_get('@config')
+            ar_config    = ActiveRecord::Base.connection.instance_variable_get('@config')
+            model_config = ShardedHasOne.connection.instance_variable_get('@config')
+            model_config.should_not == ar_config
+            model_config.should     == shard_config
+          end
+        end
+
+        it 'associates new models with the correct shard' do
+          new1 = Dynashard.with_context(:owner => 'shard1') {ShardedHasOne.new(:name => Factory.next(:name))}
+          new2 = Dynashard.with_context(:owner => 'shard2') {ShardedHasOne.new(:name => Factory.next(:name))}
+          new1.should be_a(@shard1_subclass)
+          new2.should be_a(@shard2_subclass)
+          new1.connection.should == @shard1_klass.connection
+          new2.connection.should == @shard2_klass.connection
+        end
+
+        it 'associates created models with the correct shard' do
+          created1 = Dynashard.with_context(:owner => 'shard1') {ShardedHasOne.create(:name => Factory.next(:name))}
+          created2 = Dynashard.with_context(:owner => 'shard2') {ShardedHasOne.create(:name => Factory.next(:name))}
+          created1.should be_a(@shard1_subclass)
+          created2.should be_a(@shard2_subclass)
+          created1.connection.should == @shard1_klass.connection
+          created2.connection.should == @shard2_klass.connection
+        end
+
+        it 'associates loaded models with the correct shard' do
+          model1 = Dynashard.with_context(:owner => 'shard1') {Factory(:sharded_has_one)}
+          model2 = Dynashard.with_context(:owner => 'shard2') {Factory(:sharded_has_one)}
+          found1 = Dynashard.with_context(:owner => 'shard1') {ShardedHasOne.find(model1.id)}
+          found2 = Dynashard.with_context(:owner => 'shard2') {ShardedHasOne.find(model2.id)}
+          found1.should be_a(@shard1_subclass)
+          found2.should be_a(@shard2_subclass)
+          found1.connection.should == @shard1_klass.connection
+          found2.connection.should == @shard2_klass.connection
         end
       end
     end

data/spec/spec_helper.rb

@@ -19,27 +19,31 @@ ActiveRecord::Base.configurations = YAML::load(ERB.new(IO.read(plugin_test_dir +
 ActiveRecord::Base.establish_connection("test")
 ActiveRecord::Migration.verbose = false
 
-test_database = ActiveRecord::Base.configurations['test']['database']
-File.unlink(test_database) if File.exists?(test_database)
-load(File.join(plugin_test_dir, "db", "schema.rb"))
-
-# create shards and databases that they point to
-base_config = ActiveRecord::Base.configurations['test']
-%w{shard1 shard2 shard3}.each do |shard|
-  database = "#{plugin_test_dir}/db/#{shard}.sqlite3"
-  File.unlink(database) if File.exists?(database)
-  shard_config = base_config.merge('database' => database)
-  ActiveRecord::Base.configurations['test'] = shard_config
-  ActiveRecord::Base.establish_connection("test")
+unless __FILE__ == "(irb)"
+  test_database = ActiveRecord::Base.configurations['test']['database']
+  File.unlink(test_database) if File.exists?(test_database)
   load(File.join(plugin_test_dir, "db", "schema.rb"))
+
+  # create shards and databases that they point to
+  base_config = ActiveRecord::Base.configurations['test']
+  %w{shard1 shard2 shard3}.each do |shard|
+    database = "#{plugin_test_dir}/db/#{shard}.sqlite3"
+    File.unlink(database) if File.exists?(database)
+    shard_config = base_config.merge('database' => database)
+    ActiveRecord::Base.configurations['test'] = shard_config
+    ActiveRecord::Base.establish_connection("test")
+    load(File.join(plugin_test_dir, "db", "schema.rb"))
+  end
+  ActiveRecord::Base.configurations['test'] = base_config
+  ActiveRecord::Base.establish_connection("test")
 end
-ActiveRecord::Base.configurations['test'] = base_config
-ActiveRecord::Base.establish_connection("test")
 
 require 'support/models'
 
-%w{shard1 shard2 shard3}.each do |shard|
-  Shard.create(:adapter => 'sqlite3', :database => "#{plugin_test_dir}/db/#{shard}.sqlite3")
+unless __FILE__ == "(irb)"
+  %w{shard1 shard2 shard3}.each do |shard|
+    Shard.create(:adapter => 'sqlite3', :database => "#{plugin_test_dir}/db/#{shard}.sqlite3")
+  end
 end
 
 # This has to happen after the models have been defined and the shards have been created

data/spec/support/factories.rb

@@ -1,6 +1,6 @@
 # Sequence for generating unique names
 Factory.sequence :name do |n|
-  "Test Owner #{n}"
+  "Test Name #{n}"
 end
 
 Factory.define(:sharding_owner) do |owner|
@@ -30,3 +30,7 @@ end
 Factory.define(:sharded_has_many_through) do |one_of_many|
   one_of_many.name {Factory.next :name}
 end
+
+Factory.define(:sharded_habtm) do |habtm|
+  habtm.name {Factory.next :name}
+end

data/spec/support/models.rb

@@ -39,6 +39,8 @@ class ShardingOwner < ActiveRecord::Base
   has_many :sharded_has_manys
   has_many :sharded_joins
   has_many :sharded_has_many_throughs, :through => :sharded_joins
+  has_many :sharded_dependent_has_many_throughs, :through => :sharded_dependent_joins
+  has_and_belongs_to_many :sharded_habtms
 end
 
 # Non-sharded has_one association class
@@ -97,3 +99,25 @@ class ShardedHasManyThrough < ActiveRecord::Base
 
   has_many :sharded_joins
 end
+
+# Join table for has_many :through with dependent => destroy
+class ShardedDependentJoin < ActiveRecord::Base
+  shard :by => :owner
+
+  belongs_to :sharding_owner
+  belongs_to :sharded_dependent_has_many_through
+end
+
+# Sharded has_many :through association class with dependent => destroy
+class ShardedDependentHasManyThrough < ActiveRecord::Base
+  shard :by => :owner
+
+  has_many :sharded_dependent_joins, :dependent => :destroy
+end
+
+# Sharded habtm association class
+class ShardedHabtm < ActiveRecord::Base
+  shard :by => :owner
+
+  has_and_belongs_to_many :sharding_owners
+end

data/spec/validation_spec.rb

@@ -79,9 +79,8 @@ describe 'Dynashard::ValidationExtensions' do
       context 'with a conflicting record on the shard' do
         it 'returns invalid' do
           conflicting_record = Dynashard.with_context(:owner => @owner.shard_dsn){Factory(:sharded_has_one)}
-          new_record = ShardedHasOne.new(:name => conflicting_record.name)
           Dynashard.with_context(:owner => @owner.shard_dsn) do
-            new_record.should_not be_valid
+            ShardedHasOne.new(:name => conflicting_record.name).should_not be_valid
           end
         end
       end
@@ -90,9 +89,8 @@ describe 'Dynashard::ValidationExtensions' do
         it 'returns valid' do
           other_shard = Shard.find(:all).detect{|shard| shard != @owner.shard}
           non_conflicting_record = Dynashard.with_context(:owner => other_shard.dsn){Factory(:sharded_has_one)}
-          new_record = ShardedHasOne.new(:name => non_conflicting_record.name)
           Dynashard.with_context(:owner => @owner.shard_dsn) do
-            new_record.should be_valid
+            ShardedHasOne.new(:name => non_conflicting_record.name).should be_valid
           end
         end
       end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dynashard
 version: !ruby/object:Gem::Version 
+  hash: 15
   prerelease: false
   segments: 
   - 0
-  - 3
-  - 1
-  version: 0.3.1
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Nick Hengeveld
@@ -14,93 +15,99 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-01 00:00:00 -08:00
+date: 2011-02-14 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
+  type: :runtime
+  prerelease: false
   name: activerecord
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 7
         segments: 
         - 3
         - 0
         version: "3.0"
-  type: :runtime
-  prerelease: false
-  version_requirements: *id001
+  requirement: *id001
 - !ruby/object:Gem::Dependency 
+  type: :development
+  prerelease: false
   name: shoulda
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         version: "0"
+  requirement: *id002
+- !ruby/object:Gem::Dependency 
   type: :development
   prerelease: false
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
   name: bundler
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 23
         segments: 
         - 1
         - 0
         - 0
         version: 1.0.0
+  requirement: *id003
+- !ruby/object:Gem::Dependency 
   type: :development
   prerelease: false
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
   name: jeweler
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 7
         segments: 
         - 1
         - 5
         - 2
         version: 1.5.2
+  requirement: *id004
+- !ruby/object:Gem::Dependency 
   type: :development
   prerelease: false
-  version_requirements: *id004
-- !ruby/object:Gem::Dependency 
   name: rcov
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         version: "0"
-  type: :development
-  prerelease: false
-  version_requirements: *id005
+  requirement: *id005
 - !ruby/object:Gem::Dependency 
+  type: :runtime
+  prerelease: false
   name: activerecord
-  requirement: &id006 !ruby/object:Gem::Requirement 
+  version_requirements: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 7
         segments: 
         - 3
         - 0
         version: "3.0"
-  type: :runtime
-  prerelease: false
-  version_requirements: *id006
+  requirement: *id006
 description: Dynashard allows you to shard your ActiveRecord models.  Models can be configured to shard based on context that can be defined dynamically.
 email: nickh@verticalresponse.com
 executables: []
@@ -148,7 +155,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 1766305880459043419
+      hash: 3
       segments: 
       - 0
       version: "0"
@@ -157,6 +164,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"