rubyrep 1.0.4 → 1.0.5

data/History.txt

@@ -1,6 +1,11 @@
+== 1.0.5 2009-07-03
+
+* Bug fix: rubyrep replication runs should survive update or delete attempts rejected by the database.
+* Bug fix: support for multiple PostgreSQL schemas holding tables of the same name.
+
 == 1.0.4 2009-06-20
 
- * Bug fix: added missing file (log_helper.rb) to gem manifest
+* Bug fix: added missing file (log_helper.rb) to gem manifest
 
 == 1.0.3 2009-06-20
 

data/Manifest.txt

@@ -91,6 +91,7 @@ spec/initializer_spec.rb
 spec/log_helper_spec.rb
 spec/logged_change_spec.rb
 spec/postgresql_replication_spec.rb
+spec/postgresql_schema_support_spec.rb
 spec/postgresql_support_spec.rb
 spec/progress_bar_spec.rb
 spec/proxied_table_scan_spec.rb

data/lib/rubyrep/connection_extenders/jdbc_extender.rb

@@ -61,41 +61,11 @@ module RR
     # * Hack to get schema support for Postgres under JRuby on par with the
     #   standard ruby version.
     module JdbcPostgreSQLExtender
+      require 'jdbc_adapter/jdbc_postgre'
+      require "#{File.dirname(__FILE__)}/postgresql_extender"
 
-      # Returns the list of a table's column names, data types, and default values.
-      #
-      # The underlying query is roughly:
-      #  SELECT column.name, column.type, default.value
-      #    FROM column LEFT JOIN default
-      #      ON column.table_id = default.table_id
-      #     AND column.num = default.column_num
-      #   WHERE column.table_id = get_table_id('table_name')
-      #     AND column.num > 0
-      #     AND NOT column.is_dropped
-      #   ORDER BY column.num
-      #
-      # If the table name is not prefixed with a schema, the database will
-      # take the first match from the schema search path.
-      #
-      # Query implementation notes:
-      #  - format_type includes the column size constraint, e.g. varchar(50)
-      #  - ::regclass is a function that gives the id for a table name
-      def column_definitions(table_name) #:nodoc:
-        rows = select_all(<<-end_sql)
-          SELECT a.attname as name, format_type(a.atttypid, a.atttypmod) as type, d.adsrc as default, a.attnotnull as notnull
-            FROM pg_attribute a LEFT JOIN pg_attrdef d
-              ON a.attrelid = d.adrelid AND a.attnum = d.adnum
-           WHERE a.attrelid = (SELECT oid FROM pg_class WHERE relname = '#{table_name}')
-             AND a.attnum > 0 AND NOT a.attisdropped
-           ORDER BY a.attnum
-        end_sql
-          
-        rows.map do |row|
-          [row['name'], row['type'], row['default'], row['notnull']]
-        end
-      end
+      include PostgreSQLExtender
 
-      require 'jdbc_adapter/jdbc_postgre'
       class JdbcPostgreSQLColumn < ActiveRecord::ConnectionAdapters::Column
         include ::JdbcSpec::PostgreSQL::Column
       end
@@ -113,21 +83,6 @@ module RR
         execute "SET search_path TO #{config[:schema_search_path]}" if config[:schema_search_path]
       end
 
-      # Returns the active schema search path.
-      def schema_search_path
-        @schema_search_path ||= select_one('SHOW search_path')['search_path']
-      end
-
-      # Returns the list of all tables in the schema search path or a specified schema.
-      def tables(name = nil)
-        schemas = schema_search_path.split(/,/).map { |p| quote(p) }.join(',')
-        select_all(<<-SQL, name).map { |row| row['tablename'] }
-          SELECT tablename
-            FROM pg_tables
-           WHERE schemaname IN (#{schemas})
-        SQL
-      end
-
       # Converts the given Time object into the correctly formatted string
       # representation.
       # 

data/lib/rubyrep/connection_extenders/postgresql_extender.rb

@@ -84,92 +84,128 @@ module RR
     # Provides various PostgreSQL specific functionality required by Rubyrep.
     module PostgreSQLExtender
       RR::ConnectionExtenders.register :postgresql => self
+      
+      # Returns an array of schemas in the current search path.
+      def schemas
+        unless @schemas
+          search_path = select_one("show search_path")['search_path']
+          @schemas = search_path.split(/,/).map { |p| quote(p.strip) }.join(',')
+        end
+        @schemas
+      end
+
+      # *** Monkey patch***
+      # Returns the list of all tables in the schema search path or a specified schema.
+      # This overwrites the according ActiveRecord::PostgreSQLAdapter method
+      # to make sure that also search paths with spaces work
+      # (E. g. 'public, rr' instead of only 'public,rr')
+      def tables(name = nil)
+        select_all(<<-SQL, name).map { |row| row['tablename'] }
+          SELECT tablename
+            FROM pg_tables
+           WHERE schemaname IN (#{schemas})
+        SQL
+      end
 
       # Returns an ordered list of primary key column names of the given table
       def primary_key_names(table)
         row = self.select_one(<<-end_sql)
           SELECT relname
           FROM pg_class
-          WHERE relname = '#{table}'
+          WHERE relname = '#{table}' and relnamespace IN
+            (SELECT oid FROM pg_namespace WHERE nspname in (#{schemas}))
         end_sql
-        if row.nil?
-        raise "table '#{table}' does not exist"
-      end
+        raise "table '#{table}' does not exist" if row.nil?
         
-      row = self.select_one(<<-end_sql)
+        row = self.select_one(<<-end_sql)
           SELECT cons.conkey 
           FROM pg_class           rel
           JOIN pg_constraint      cons ON (rel.oid = cons.conrelid)
-          WHERE cons.contype = 'p' AND rel.relname = '#{table}'          
-      end_sql
-      if row.nil?
-      return []
-    end
-    column_parray = row['conkey']
+          WHERE cons.contype = 'p' AND rel.relname = '#{table}' AND rel.relnamespace IN
+            (SELECT oid FROM pg_namespace WHERE nspname in (#{schemas}))
+        end_sql
+        return [] if row.nil?
+        column_parray = row['conkey']
         
-    # Change a Postgres Array of attribute numbers
-    # (returned in String form, e. g.: "{1,2}") into an array of Integers
-    column_ids = column_parray.sub(/^\{(.*)\}$/,'\1').split(',').map {|a| a.to_i}
+        # Change a Postgres Array of attribute numbers
+        # (returned in String form, e. g.: "{1,2}") into an array of Integers
+        column_ids = column_parray.sub(/^\{(.*)\}$/,'\1').split(',').map {|a| a.to_i}
 
-    columns = {}
-    rows = self.select_all(<<-end_sql)
+        columns = {}
+        rows = self.select_all(<<-end_sql)
           SELECT attnum, attname
           FROM pg_class           rel
           JOIN pg_constraint      cons ON (rel.oid = cons.conrelid)
           JOIN pg_attribute       attr ON (rel.oid = attr.attrelid and attr.attnum = any (cons.conkey))
-          WHERE cons.contype = 'p' AND rel.relname = '#{table}'
-    end_sql
-    sorted_columns = []
-    if not rows.nil?
-      rows.each() {|r| columns[r['attnum'].to_i] = r['attname']}
-      sorted_columns = column_ids.map {|column_id| columns[column_id]}
-    end
-    sorted_columns
-  end
+          WHERE cons.contype = 'p' AND rel.relname = '#{table}' AND rel.relnamespace IN
+            (SELECT oid FROM pg_namespace WHERE nspname in (#{schemas}))
+        end_sql
+        sorted_columns = []
+        if not rows.nil?
+          rows.each() {|r| columns[r['attnum'].to_i] = r['attname']}
+          sorted_columns = column_ids.map {|column_id| columns[column_id]}
+        end
+        sorted_columns
+      end
 
-  # Returns for each given table, which other tables it references via
-  # foreign key constraints.
-  # * tables: an array of table names
-  # Returns: a hash with
-  # * key: name of the referencing table
-  # * value: an array of names of referenced tables
-  def referenced_tables(tables)
-    rows = self.select_all(<<-end_sql)
+      # Returns for each given table, which other tables it references via
+      # foreign key constraints.
+      # * tables: an array of table names
+      # Returns: a hash with
+      # * key: name of the referencing table
+      # * value: an array of names of referenced tables
+      def referenced_tables(tables)
+        rows = self.select_all(<<-end_sql)
           select distinct referencing.relname as referencing_table, referenced.relname as referenced_table
           from pg_class referencing
           left join pg_constraint on referencing.oid = pg_constraint.conrelid
           left join pg_class referenced on pg_constraint.confrelid = referenced.oid
           where referencing.relkind='r'
           and referencing.relname in ('#{tables.join("', '")}')
-    end_sql
-    result = {}
-    rows.each do |row|
-      unless result.include? row['referencing_table']
-        result[row['referencing_table']] = []
+          and referencing.relnamespace IN
+            (SELECT oid FROM pg_namespace WHERE nspname in (#{schemas}))
+        end_sql
+        result = {}
+        rows.each do |row|
+          unless result.include? row['referencing_table']
+            result[row['referencing_table']] = []
+          end
+          if row['referenced_table'] != nil
+            result[row['referencing_table']] << row['referenced_table']
+          end
+        end
+        result
       end
-      if row['referenced_table'] != nil
-        result[row['referencing_table']] << row['referenced_table']
+
+      # *** Monkey patch***
+      # Returns the list of a table's column names, data types, and default values.
+      # This overwrites the according ActiveRecord::PostgreSQLAdapter method
+      # to
+      # * work with tables containing a dot (".") and
+      # * only look for tables in the current schema search path.
+      def column_definitions(table_name) #:nodoc:
+        rows = self.select_all <<-end_sql
+          SELECT
+            a.attname as name,
+            format_type(a.atttypid, a.atttypmod) as type,
+            d.adsrc as source,
+            a.attnotnull as notnull
+          FROM pg_attribute a LEFT JOIN pg_attrdef d
+            ON a.attrelid = d.adrelid AND a.attnum = d.adnum
+          WHERE a.attrelid = (
+            SELECT oid FROM pg_class
+            WHERE relname = '#{table_name}' AND relnamespace IN
+              (SELECT oid FROM pg_namespace WHERE nspname in (#{schemas}))
+            LIMIT 1
+            )
+            AND a.attnum > 0 AND NOT a.attisdropped
+          ORDER BY a.attnum
+        end_sql
+    
+        rows.map {|row| [row['name'], row['type'], row['source'], row['notnull']]}
       end
-    end
-    result
-  end
 
-  # *** Monkey patch***
-  # Returns the list of a table's column names, data types, and default values.
-  # This overwrites the according ActiveRecord::PostgreSQLAdapter method
-  # to work with tables containing a dot (".").
-  def column_definitions(table_name) #:nodoc:
-    query <<-end_sql
-      SELECT a.attname, format_type(a.atttypid, a.atttypmod), d.adsrc, a.attnotnull
-        FROM pg_attribute a LEFT JOIN pg_attrdef d
-          ON a.attrelid = d.adrelid AND a.attnum = d.adnum
-       WHERE a.attrelid = (SELECT oid FROM pg_class WHERE relname = '#{table_name}')
-         AND a.attnum > 0 AND NOT a.attisdropped
-       ORDER BY a.attnum
-    end_sql
+    end
   end
-
-end
-end
 end
 

data/lib/rubyrep/replication_extenders/postgresql_replication.rb

@@ -87,8 +87,6 @@ module RR
       # * +trigger_name+: name of the trigger
       # * +table_name+: name of the table
       def replication_trigger_exists?(trigger_name, table_name)
-        search_path = select_one("show search_path")['search_path']
-        schemas = search_path.split(/,/).map { |p| quote(p) }.join(',')
         !select_all(<<-end_sql).empty?
           select 1 from information_schema.triggers
           where event_object_schema in (#{schemas})
@@ -114,7 +112,8 @@ module RR
           join pg_depend as r on t.oid = r.refobjid
           join pg_class as s on r.objid = s.oid
           and s.relkind = 'S'
-          and t.relname = '#{table_name}'
+          and t.relname = '#{table_name}' AND t.relnamespace IN
+            (SELECT oid FROM pg_namespace WHERE nspname in (#{schemas}))
         end_sql
         sequence_names.each do |sequence_name|
           row = select_one("select last_value, increment_by from \"#{sequence_name}\"")
@@ -171,7 +170,8 @@ module RR
           join pg_depend as r on t.oid = r.refobjid
           join pg_class as s on r.objid = s.oid
           and s.relkind = 'S'
-          and t.relname = '#{table_name}'
+          and t.relname = '#{table_name}' and t.relnamespace IN
+            (SELECT oid FROM pg_namespace WHERE nspname in (#{schemas}))
         end_sql
         sequence_names.each do |sequence_name|
           execute(<<-end_sql)

data/lib/rubyrep/replicators/two_way_replicator.rb

@@ -169,7 +169,7 @@ module RR
         when :update
           attempt_update source_db, diff, remaining_attempts, source_key, target_key
         when :delete
-          attempt_delete source_db, diff, target_key
+          attempt_delete source_db, diff, remaining_attempts, target_key
         end
       end
 
@@ -263,8 +263,16 @@ module RR
           diff.amend
           replicate_difference diff, remaining_attempts - 1, "source record for update vanished"
         else
-          log_replication_outcome source_db, diff
-          rep_helper.update_record target_db, target_table, values, target_key
+          begin
+            rep_helper.session.send(target_db).execute "savepoint rr_update"
+            log_replication_outcome source_db, diff
+            rep_helper.update_record target_db, target_table, values, target_key
+          rescue Exception => e
+            rep_helper.session.send(target_db).execute "rollback to savepoint rr_update"
+            diff.amend
+            replicate_difference diff, remaining_attempts - 1,
+              "update failed with #{e.message}"
+          end
         end
       end
 
@@ -273,13 +281,22 @@ module RR
       # :+right+.
       # * +source_db+: either :+left+ or :+right+ - source database of replication
       # * +diff+: the current ReplicationDifference instance
+      # * +remaining_attempts+: the number of remaining replication attempts for this difference
       # * +target_key+: a column_name => value hash identifying the source record
-      def attempt_delete(source_db, diff, target_key)
+      def attempt_delete(source_db, diff, remaining_attempts, target_key)
         change = diff.changes[source_db]
         target_db = OTHER_SIDE[source_db]
         target_table = rep_helper.corresponding_table(source_db, change.table)
-        log_replication_outcome source_db, diff
-        rep_helper.delete_record target_db, target_table, target_key
+        begin
+          rep_helper.session.send(target_db).execute "savepoint rr_delete"
+          log_replication_outcome source_db, diff
+          rep_helper.delete_record target_db, target_table, target_key
+        rescue Exception => e
+          rep_helper.session.send(target_db).execute "rollback to savepoint rr_delete"
+          diff.amend
+          replicate_difference diff, remaining_attempts - 1,
+            "delete failed with #{e.message}"
+        end
       end
 
       # Called to replicate the specified difference.
@@ -306,7 +323,7 @@ module RR
             when :update
               attempt_update source_db, diff, remaining_attempts, change.new_key, change.key
             when :delete
-              attempt_delete source_db, diff, change.key
+              attempt_delete source_db, diff, remaining_attempts, change.key
             end
           else # option must be a Proc
             option.call rep_helper, diff

data/lib/rubyrep/version.rb

@@ -2,7 +2,7 @@ module RR #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 1
     MINOR = 0
-    TINY  = 4
+    TINY  = 5
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/spec/postgresql_schema_support_spec.rb

@@ -0,0 +1,179 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+require File.dirname(__FILE__) + "/../config/test_config.rb"
+
+describe "PostgreSQL schema support" do
+  before(:each) do
+    config = deep_copy(standard_config)
+    config.left[:schema_search_path] = 'rr'
+    config.right[:schema_search_path] = 'rr'
+    Initializer.configuration = config
+  end
+
+  after(:each) do
+  end
+
+  if Initializer.configuration.left[:adapter] == 'postgresql'
+    it "tables should show the tables from the schema and no others" do
+      session = Session.new
+      session.left.tables.include?('rr_simple').should be_true
+      session.left.tables.include?('scanner_records').should be_false
+    end
+
+    it "tables should not show the tables from other schemas" do
+      session = Session.new standard_config
+      session.left.tables.include?('scanner_records').should be_true
+      session.left.tables.include?('rr_simple').should be_false
+    end
+
+    it "primary_key_names should work" do
+      session = Session.new
+      session.left.primary_key_names('rr_simple').should == ['id']
+    end
+
+    it "primary_key_names should pick the table in the target schema" do
+      session = Session.new
+      session.left.primary_key_names('rr_duplicate').should == ['id']
+    end
+
+    it "column_names should work" do
+      session = Session.new
+      session.left.column_names('rr_simple').should == ['id', 'name']
+    end
+
+    it "column_names should pick the table in the target schema" do
+      session = Session.new
+      session.left.column_names('rr_duplicate').should == ['id', 'name']
+    end
+
+    it "referenced_tables should work" do
+      session = Session.new
+      session.left.referenced_tables(['rr_referencing']).should == {
+        'rr_referencing' => ['rr_referenced']
+      }
+    end
+
+    it "table_select_query should work" do
+      session = Session.new
+      session.left.table_select_query('rr_simple').
+        should == 'select "id", "name" from "rr_simple" order by "id"'
+    end
+
+    it "TypeCasingCursor should work" do
+      session = Session.new
+      org_cursor = session.left.select_cursor(:query => "select id, name from rr_simple where id = 1")
+      cursor = TypeCastingCursor.new session.left, 'rr_simple', org_cursor
+
+      row = cursor.next_row
+
+      row.should == {
+        'id' => 1,
+        'name' => 'bla'
+      }
+    end
+
+    it "sequence_values should pick the table in the target schema" do
+      session = Session.new
+      session.left.sequence_values('rr', 'rr_duplicate').keys.should == ["rr_duplicate_id_seq"]
+    end
+
+    it "clear_sequence_setup should pick the table in the target schema" do
+      session = nil
+      begin
+        session = Session.new
+        initializer = ReplicationInitializer.new(session)
+        session.left.begin_db_transaction
+        session.right.begin_db_transaction
+        table_pair = {:left => 'rr_duplicate', :right => 'rr_duplicate'}
+        initializer.ensure_sequence_setup table_pair, 5, 2, 1
+        id1, id2 = get_example_sequence_values(session, 'rr_duplicate')
+        (id2 - id1).should == 5
+        (id1 % 5).should == 2
+
+        initializer.clear_sequence_setup :left, 'rr_duplicate'
+        id1, id2 = get_example_sequence_values(session, 'rr_duplicate')
+        (id2 - id1).should == 1
+      ensure
+        [:left, :right].each do |database|
+          initializer.clear_sequence_setup database, 'rr_duplicate' rescue nil if session
+          session.send(database).execute "delete from rr_duplicate" rescue nil if session
+          session.send(database).rollback_db_transaction rescue nil if session
+        end
+      end
+
+    end
+
+    it "sequence setup should work" do
+      session = nil
+      begin
+        session = Session.new
+        initializer = ReplicationInitializer.new(session)
+        session.left.begin_db_transaction
+        session.right.begin_db_transaction
+        table_pair = {:left => 'rr_sequence_test', :right => 'rr_sequence_test'}
+        initializer.ensure_sequence_setup table_pair, 5, 2, 1
+        id1, id2 = get_example_sequence_values(session, 'rr_sequence_test')
+        (id2 - id1).should == 5
+        (id1 % 5).should == 2
+      ensure
+        [:left, :right].each do |database|
+          initializer.clear_sequence_setup database, 'rr_sequence_test' rescue nil if session
+          session.send(database).execute "delete from rr_sequence_test" rescue nil if session
+          session.send(database).rollback_db_transaction rescue nil if session
+        end
+      end
+    end
+
+    it "clear_sequence_setup should work" do
+      session = nil
+      begin
+        session = Session.new
+        initializer = ReplicationInitializer.new(session)
+        session.left.begin_db_transaction
+        session.right.begin_db_transaction
+        table_pair = {:left => 'rr_sequence_test', :right => 'rr_sequence_test'}
+        initializer.ensure_sequence_setup table_pair, 5, 2, 2
+        initializer.clear_sequence_setup :left, 'rr_sequence_test'
+        id1, id2 = get_example_sequence_values(session, 'rr_sequence_test')
+        (id2 - id1).should == 1
+      ensure
+        [:left, :right].each do |database|
+          initializer.clear_sequence_setup database, 'rr_sequence_test' if session
+          session.send(database).execute "delete from rr_sequence_test" if session
+          session.send(database).rollback_db_transaction if session
+        end
+      end
+    end
+
+    it "create_trigger, trigger_exists? and drop_trigger should work" do
+      session = nil
+      begin
+        session = Session.new
+        initializer = ReplicationInitializer.new(session)
+        session.left.begin_db_transaction
+
+        initializer.create_trigger :left, 'rr_trigger_test'
+        initializer.trigger_exists?(:left, 'rr_trigger_test').
+          should be_true
+        initializer.drop_trigger(:left, 'rr_trigger_test')
+        initializer.trigger_exists?(:left, 'rr_trigger_test').
+          should be_false
+      ensure
+        session.left.rollback_db_transaction if session
+      end
+    end
+
+    it "should work with complex search paths" do
+      config = deep_copy(standard_config)
+      config.left[:schema_search_path] = 'public,rr'
+      config.right[:schema_search_path] = 'public,rr'
+      session = Session.new(config)
+
+      tables = session.left.tables
+      tables.include?('rr_simple').should be_true
+      tables.include?('scanner_records').should be_true
+    end
+  end
+end

data/spec/postgresql_support_spec.rb

@@ -4,7 +4,7 @@ include RR
 
 require File.dirname(__FILE__) + "/../config/test_config.rb"
 
-describe "PostgreSQL schema support" do
+describe "PostgreSQL support" do
   before(:each) do
     Initializer.configuration = standard_config
   end

data/spec/session_spec.rb

@@ -186,14 +186,15 @@ describe Session do   # here database connection caching is _not_ disabled
         'referenced_table',
         'scanner_text_key',
       ])
-    sorted_table_pairs = convert_table_array_to_table_pair_array([
-        'scanner_records',
-        'referenced_table',
-        'referencing_table',
-        'scanner_text_key',
-      ])
+    sorted_table_pairs = Session.new.sort_table_pairs(table_pairs)
+
+    # ensure result holds the original table pairs
+    p = Proc.new {|l, r| l[:left] <=> r[:left]}
+    sorted_table_pairs.sort(&p).should == table_pairs.sort(&p)
 
-    Session.new.sort_table_pairs(table_pairs).should == sorted_table_pairs
+    # make sure the referenced table comes before the referencing table
+    sorted_table_pairs.map {|table_pair| table_pair[:left]}.grep(/referenc/).
+      should == ['referenced_table', 'referencing_table']
   end
 
   it "sort_table_pairs should not sort the tables if table_ordering is not enabled in the configuration" do

data/spec/table_sorter_spec.rb

@@ -14,15 +14,14 @@ describe TableSorter do
       'scanner_text_key',
     ]
 
-    sorted_tables = [
-      'scanner_records',
-      'referenced_table',
-      'referencing_table',
-      'scanner_text_key',
-    ]
-
     sorter = TableSorter.new Session.new(standard_config), tables
-    sorter.sort.should == sorted_tables
+    sorted_tables = sorter.sort
+
+    # make sure it contains the original tables
+    sorted_tables.sort.should == tables.sort
+
+    # make sure the referenced table comes before the referencing table
+    sorted_tables.grep(/referenc/).should == ['referenced_table', 'referencing_table']
 
     # verify that we are using TSort#tsort to get that result
     sorter.should_not_receive(:tsort)

data/spec/two_way_replicator_spec.rb

@@ -496,6 +496,92 @@ describe Replicators::TwoWayReplicator do
     lambda {replicator.replicate_difference :dummy_diff, 0}.
       should raise_error(Exception, "max replication attempts exceeded")
   end
+  
+  it "replicate_difference should handle updates rejected by the database" do
+    begin
+      config = deep_copy(standard_config)
+      config.options[:committer] = :never_commit
+      config.options[:replication_conflict_handling] = :left_wins
+
+      session = Session.new(config)
+
+      session.left.insert_record 'rr_pending_changes', {
+        'change_table' => 'scanner_records',
+        'change_key' => 'id|1',
+        'change_new_key' => 'id|2',
+        'change_type' => 'U',
+        'change_time' => Time.now
+      }
+
+      rep_run = ReplicationRun.new session
+      helper = ReplicationHelper.new(rep_run)
+      replicator = Replicators::TwoWayReplicator.new(helper)
+
+      diff = ReplicationDifference.new session
+      diff.load
+
+      lambda {replicator.replicate_difference diff, 1}.should raise_error(/duplicate/i)
+
+      # Verify that the transaction has not become invalid
+      helper.log_replication_outcome diff, "bla", "blub"
+
+      row = session.left.select_one("select * from rr_logged_events")
+      row['change_table'].should == 'scanner_records'
+      row['change_key'].should == '1'
+      row['description'].should == 'bla'
+      
+    ensure
+      Committers::NeverCommitter.rollback_current_session
+      if session
+        session.left.execute "delete from rr_pending_changes"
+        session.left.execute "delete from rr_logged_events"
+      end
+    end
+  end
+
+  it "replicate_difference should handle deletes rejected by the database" do
+    begin
+      config = deep_copy(standard_config)
+      config.options[:committer] = :never_commit
+      config.options[:replication_conflict_handling] = :left_wins
+
+      session = Session.new(config)
+
+      session.left.select_all("select * from rr_logged_events").should == []
+
+      session.left.insert_record 'rr_pending_changes', {
+        'change_table' => 'referenced_table',
+        'change_key' => 'first_id|1|second_id|2',
+        'change_new_key' => nil,
+        'change_type' => 'D',
+        'change_time' => Time.now
+      }
+
+      rep_run = ReplicationRun.new session
+      helper = ReplicationHelper.new(rep_run)
+      replicator = Replicators::TwoWayReplicator.new(helper)
+
+      diff = ReplicationDifference.new session
+      diff.load
+
+      lambda {replicator.replicate_difference diff, 1}.should raise_error(/referencing_table_fkey/)
+
+      # Verify that the transaction has not become invalid
+      helper.log_replication_outcome diff, "bla", "blub"
+
+      row = session.left.select_one("select * from rr_logged_events")
+      row['change_table'].should == 'referenced_table'
+      row['change_key'].should =~ /first_id.*1.*second_id.*2/
+      row['description'].should == 'bla'
+
+    ensure
+      Committers::NeverCommitter.rollback_current_session
+      if session
+        session.left.execute "delete from rr_pending_changes"
+        session.left.execute "delete from rr_logged_events"
+      end
+    end
+  end
 
   it "replicate_difference should handle updates failing due to the source record being deleted after the original diff was loaded" do
     begin

data/tasks/database.rake

@@ -90,6 +90,10 @@ def create_postgres_schema(config)
     create_table :rr_sequence_test do |t|
       t.column :name, :string
     end
+    
+    create_table :rr_duplicate do |t|
+      t.column :name, :string
+    end
   end
 end
 
@@ -272,6 +276,33 @@ def create_sample_schema(database, config)
     create_table :right_table do |t|
       t.column :name, :string
     end if database == :right
+
+    if config.send(database)[:adapter] == 'postgresql'
+      create_table :rr_duplicate, :id => false do |t|
+        t.column :blub, :string
+      end rescue nil
+
+      ActiveRecord::Base.connection.execute(<<-end_sql) rescue nil
+        ALTER TABLE rr_duplicate ADD COLUMN key SERIAL
+      end_sql
+
+      ActiveRecord::Base.connection.execute(<<-end_sql) rescue nil
+      ALTER TABLE rr_duplicate ADD CONSTRAINT rr_duplicate_pkey
+        PRIMARY KEY (key)
+      end_sql
+
+      # duplicate that should *not* be found during PostgreSQL schema support tests
+      create_table :rr_referencing do |t|
+        t.column :first_fk, :integer
+        t.column :second_fk, :integer
+      end rescue nil
+
+      ActiveRecord::Base.connection.execute(<<-end_sql)
+      ALTER TABLE rr_referencing ADD CONSTRAINT rr_referencing_fkey
+        FOREIGN KEY (first_fk, second_fk)
+        REFERENCES referenced_table(first_id, second_id)
+      end_sql
+    end
   end
 end
 
@@ -283,6 +314,8 @@ def drop_sample_schema(config)
   ActiveRecord::Base.establish_connection config
   
   ActiveRecord::Schema.define do
+    drop_table :rr_referencing rescue nil
+    drop_table :rr_duplicate rescue nil
     drop_table STRANGE_TABLE rescue nil
     drop_table :extender_type_check rescue nil
     drop_table :extender_no_record rescue nil
@@ -380,6 +413,13 @@ def delete_all_and_create_shared_sample_data(config)
     {:first_id => 2, :second_id => 1, :name => 'ba'},
     {:first_id => 3, :second_id => 1}
   ].each { |row| create_row connection, 'extender_combined_key', row}
+
+  connection.execute("delete from referenced_table")
+  connection.execute("delete from referencing_table")
+  create_row connection, 'referenced_table', {
+    :first_id => 1, :second_id => 2, :name => 'bla'
+  }
+  create_row connection, 'referencing_table', {:first_fk => 1, :second_fk => 2}
 end
 
 # Reinitializes the sample schema with the sample data

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rubyrep
 version: !ruby/object:Gem::Version 
-  version: 1.0.4
+  version: 1.0.5
 platform: ruby
 authors: 
 - Arndt Lehmann
@@ -30,7 +30,7 @@ cert_chain:
   NwT26VZnE2nr8g==
   -----END CERTIFICATE-----
 
-date: 2009-06-20 00:00:00 +09:00
+date: 2009-07-03 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -168,6 +168,7 @@ files:
 - spec/log_helper_spec.rb
 - spec/logged_change_spec.rb
 - spec/postgresql_replication_spec.rb
+- spec/postgresql_schema_support_spec.rb
 - spec/postgresql_support_spec.rb
 - spec/progress_bar_spec.rb
 - spec/proxied_table_scan_spec.rb