daff 1.3.2 → 1.3.6

data/lib/lib/coopy/meta.rb

@@ -11,6 +11,9 @@ module Coopy
     def useForColumnChanges() puts "Abstract Meta.useForColumnChanges called" end
     def useForRowChanges() puts "Abstract Meta.useForRowChanges called" end
     def getRowStream() puts "Abstract Meta.getRowStream called" end
+    def isNested() puts "Abstract Meta.isNested called" end
+    def isSql() puts "Abstract Meta.isSql called" end
+    def getName() puts "Abstract Meta.getName called" end
   haxe_me ["coopy", "Meta"]
   end
 

data/lib/lib/coopy/simple_meta.rb

@@ -0,0 +1,314 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class SimpleMeta 
+    
+    def initialize(t,has_properties = true,may_be_nested = false)
+      @t = t
+      self.row_change
+      self.col_change
+      @has_properties = has_properties
+      @may_be_nested = may_be_nested
+      @metadata = nil
+      @keys = nil
+      @row_active = false
+      @row_change_cache = nil
+    end
+    
+    protected
+    
+    attr_accessor :t
+    attr_accessor :name2row
+    attr_accessor :name2col
+    attr_accessor :has_properties
+    attr_accessor :metadata
+    attr_accessor :keys
+    attr_accessor :row_active
+    attr_accessor :row_change_cache
+    attr_accessor :may_be_nested
+    
+    public
+    
+    def store_row_changes(changes)
+      @row_change_cache = changes
+      @row_active = true
+    end
+    
+    protected
+    
+    def row_change 
+      @name2row = nil
+    end
+    
+    def col_change 
+      @name2col = nil
+    end
+    
+    def col(key)
+      return -1 if @t.get_height < 1
+      if @name2col == nil 
+        @name2col = {}
+        w = @t.get_width
+        begin
+          _g = 0
+          while(_g < w) 
+            c = _g
+            _g+=1
+            begin
+              key1 = @t.get_cell(c,0)
+              @name2col[key1] = c
+            end
+          end
+        end
+      end
+      return -1 if !@name2col.include?(key)
+      @name2col[key]
+    end
+    
+    def row(key)
+      return -1 if @t.get_width < 1
+      if @name2row == nil 
+        @name2row = {}
+        h = @t.get_height
+        begin
+          _g = 1
+          while(_g < h) 
+            r = _g
+            _g+=1
+            begin
+              key1 = @t.get_cell(0,r)
+              @name2row[key1] = r
+            end
+          end
+        end
+      end
+      return -1 if !@name2row.include?(key)
+      @name2row[key]
+    end
+    
+    public
+    
+    def alter_columns(columns)
+      target = {}
+      wfate = 0
+      if @has_properties 
+        target["@"] = wfate
+        wfate+=1
+      end
+      begin
+        _g1 = 0
+        _g = columns.length
+        while(_g1 < _g) 
+          i = _g1
+          _g1+=1
+          col = columns[i]
+          target[col.prev_name] = wfate if col.prev_name != nil
+          wfate+=1 if col.name != nil
+        end
+      end
+      fate = Array.new
+      begin
+        _g11 = 0
+        _g2 = @t.get_width
+        while(_g11 < _g2) 
+          i1 = _g11
+          _g11+=1
+          targeti = -1
+          name = @t.get_cell(i1,0)
+          targeti = target[name] if target.include?(name)
+          fate.push(targeti)
+        end
+      end
+      @t.insert_or_delete_columns(fate,wfate)
+      start = nil
+      if @has_properties 
+        start = 1
+      else 
+        start = 0
+      end
+      at = start
+      begin
+        _g12 = 0
+        _g3 = columns.length
+        while(_g12 < _g3) 
+          i2 = _g12
+          _g12+=1
+          col1 = columns[i2]
+          if col1.name != nil 
+            @t.set_cell(at,0,col1.name) if col1.name != col1.prev_name
+          end
+          at+=1 if col1.name != nil
+        end
+      end
+      return true if !@has_properties
+      self.col_change
+      at = start
+      begin
+        _g13 = 0
+        _g4 = columns.length
+        while(_g13 < _g4) 
+          i3 = _g13
+          _g13+=1
+          col2 = columns[i3]
+          if col2.name != nil 
+            _g21 = 0
+            _g31 = col2.props
+            while(_g21 < _g31.length) 
+              prop = _g31[_g21]
+              _g21+=1
+              self.set_cell(col2.name,prop.name,prop.val)
+            end
+          end
+          at+=1 if col2.name != nil
+        end
+      end
+      true
+    end
+    
+    protected
+    
+    def set_cell(c,r,val)
+      ri = self.row(r)
+      return false if ri == -1
+      ci = self.col(c)
+      return false if ci == -1
+      @t.set_cell(ci,ri,val)
+      true
+    end
+    
+    public
+    
+    def add_meta_data(column,property,val)
+      if @metadata == nil 
+        @metadata = {}
+        @keys = {}
+      end
+      if !@metadata.include?(column) 
+        value = {}
+        @metadata[column] = value
+      end
+      props = @metadata[column]
+      begin
+        value1 = val
+        begin
+          value2 = value1
+          props[property] = value2
+        end
+      end
+      @keys[property] = true
+    end
+    
+    def as_table 
+      return @t if @has_properties && @metadata == nil
+      return nil if @metadata == nil
+      w = @t.get_width
+      props = Array.new
+      _it = ::Rb::RubyIterator.new(@keys.keys)
+      while(_it.has_next) do
+        k = _it._next
+        props.push(k)
+      end
+      props.sort!{|a,b| Reflect.compare(a,b)}
+      mt = ::Coopy::SimpleTable.new(w + 1,props.length + 1)
+      mt.set_cell(0,0,"@")
+      begin
+        _g = 0
+        while(_g < w) 
+          x = _g
+          _g+=1
+          name = @t.get_cell(x,0)
+          mt.set_cell(1 + x,0,name)
+          next if !@metadata.include?(name)
+          vals = @metadata[name]
+          begin
+            _g2 = 0
+            _g1 = props.length
+            while(_g2 < _g1) 
+              i = _g2
+              _g2+=1
+              mt.set_cell(1 + x,i + 1,vals[props[i]]) if vals.include?(props[i])
+            end
+          end
+        end
+      end
+      begin
+        _g11 = 0
+        _g3 = props.length
+        while(_g11 < _g3) 
+          y = _g11
+          _g11+=1
+          mt.set_cell(0,y + 1,props[y])
+        end
+      end
+      mt
+    end
+    
+    def clone_meta(table = nil)
+      result = ::Coopy::SimpleMeta.new(table)
+      if @metadata != nil 
+        result.keys = {}
+        _it = ::Rb::RubyIterator.new(@keys.keys)
+        while(_it.has_next) do
+          k = _it._next
+          result.keys[k] = true
+        end
+        result.metadata = {}
+        _it2 = ::Rb::RubyIterator.new(@metadata.keys)
+        while(_it2.has_next) do
+          k1 = _it2._next
+          next if !@metadata.include?(k1)
+          vals = @metadata[k1]
+          nvals = {}
+          _it3 = ::Rb::RubyIterator.new(vals.keys)
+          while(_it3.has_next) do
+            p = _it3._next
+            value = vals[p]
+            begin
+              value1 = value
+              nvals[p] = value1
+            end
+          end
+          result.metadata[k1] = nvals
+        end
+      end
+      result
+    end
+    
+    def use_for_column_changes 
+      true
+    end
+    
+    def use_for_row_changes 
+      @row_active
+    end
+    
+    def change_row(rc)
+      @row_change_cache.push(rc)
+      false
+    end
+    
+    def apply_flags(flags)
+      false
+    end
+    
+    def get_row_stream 
+      ::Coopy::TableStream.new(@t)
+    end
+    
+    def is_nested 
+      @may_be_nested
+    end
+    
+    def is_sql 
+      false
+    end
+    
+    def get_name 
+      nil
+    end
+    
+  haxe_me ["coopy", "SimpleMeta"]
+  end
+
+end

data/lib/lib/coopy/simple_table.rb

@@ -233,6 +233,10 @@ module Coopy
       result
     end
     
+    def create 
+      ::Coopy::SimpleTable.new(self.get_width,self.get_height)
+    end
+    
     def set_meta(meta)
       @meta = meta
     end

data/lib/lib/coopy/simple_view.rb

@@ -52,6 +52,18 @@ module Coopy
       h.respond_to? :keys
     end
     
+    def is_table(t)
+      Std._is(t,::Coopy::Table)
+    end
+    
+    def get_table(t)
+      t
+    end
+    
+    def wrap_table(t)
+      t
+    end
+    
   haxe_me ["coopy", "SimpleView"]
   end
 

data/lib/lib/coopy/sql_compare.rb

@@ -11,14 +11,16 @@ module Coopy
       @alt = alt
       @align = align
       @peered = false
-      if @remote.get_database.get_name_for_attachment != nil 
-        if @remote.get_database.get_name_for_attachment != @local.get_database.get_name_for_attachment 
-          local.get_database.get_helper.attach(db,"__peer__",@remote.get_database.get_name_for_attachment)
-          @peered = true
+      @alt_peered = false
+      if local != nil && remote != nil 
+        if @remote.get_database.get_name_for_attachment != nil 
+          if @remote.get_database.get_name_for_attachment != @local.get_database.get_name_for_attachment 
+            local.get_database.get_helper.attach(db,"__peer__",@remote.get_database.get_name_for_attachment)
+            @peered = true
+          end
         end
       end
-      @alt_peered = false
-      if @alt != nil 
+      if @alt != nil && local != nil 
         if @alt.get_database.get_name_for_attachment != nil 
           if @alt.get_database.get_name_for_attachment != @local.get_database.get_name_for_attachment 
             local.get_database.get_helper.attach(db,"__alt__",@alt.get_database.get_name_for_attachment)
@@ -38,6 +40,7 @@ module Coopy
     attr_accessor :at0
     attr_accessor :at1
     attr_accessor :at2
+    attr_accessor :diff_ct
     attr_accessor :align
     attr_accessor :peered
     attr_accessor :alt_peered
@@ -60,25 +63,42 @@ module Coopy
     public
     
     def validate_schema 
-      all_cols1 = @local.get_column_names
-      all_cols2 = @remote.get_column_names
+      all_cols1 = []
+      key_cols1 = []
+      access_error = false
+      pk_missing = false
+      if @local != nil 
+        all_cols1 = @local.get_column_names
+        key_cols1 = @local.get_primary_key
+        access_error = true if all_cols1.length == 0
+        pk_missing = true if key_cols1.length == 0
+      end
+      all_cols2 = []
+      key_cols2 = []
+      if @remote != nil 
+        all_cols2 = @remote.get_column_names
+        key_cols2 = @remote.get_primary_key
+        access_error = true if all_cols2.length == 0
+        pk_missing = true if key_cols2.length == 0
+      end
       all_cols3 = all_cols2
-      key_cols1 = @local.get_primary_key
-      key_cols2 = @remote.get_primary_key
       key_cols3 = key_cols2
       if @alt != nil 
         all_cols3 = @alt.get_column_names
         key_cols3 = @alt.get_primary_key
+        access_error = true if all_cols3.length == 0
+        pk_missing = true if key_cols3.length == 0
       end
-      raise hx_raise("Error accessing SQL table") if all_cols1.length == 0 || all_cols2.length == 0 || all_cols3.length == 0
-      if !(self.equal_array(key_cols1,key_cols2) && self.equal_array(key_cols1,key_cols3)) 
-        puts "sql diff not possible when primary key changes"
-        return false
+      raise hx_raise("Error accessing SQL table") if access_error
+      raise hx_raise("sql diff not possible when primary key not available") if pk_missing
+      pk_change = false
+      if @local != nil && @remote != nil 
+        pk_change = true if !self.equal_array(key_cols1,key_cols2)
       end
-      if key_cols1.length == 0 
-        puts "sql diff not possible when primary key not available"
-        return false
+      if @local != nil && @alt != nil 
+        pk_change = true if !self.equal_array(key_cols1,key_cols3)
       end
+      raise hx_raise("sql diff not possible when primary key changes") if pk_change
       true
     end
     
@@ -90,6 +110,7 @@ module Coopy
     end
     
     def link 
+      @diff_ct+=1
       mode = @db.get(0)
       i0 = self.denull(@db.get(1))
       i1 = self.denull(@db.get(2))
@@ -208,18 +229,32 @@ module Coopy
     
     def apply 
       return nil if @db == nil
+      @align = ::Coopy::Alignment.new if @align == nil
       return nil if !self.validate_schema
       rowid_name = @db.rowid
-      @align = ::Coopy::Alignment.new if @align == nil
-      key_cols = @local.get_primary_key
-      data_cols = @local.get_all_but_primary_key
-      all_cols = @local.get_column_names
-      all_cols1 = @local.get_column_names
-      all_cols2 = @remote.get_column_names
-      all_cols3 = all_cols2
-      all_cols3 = @alt.get_column_names if @alt != nil
-      data_cols1 = @local.get_all_but_primary_key
-      data_cols2 = @remote.get_all_but_primary_key
+      key_cols = []
+      data_cols = []
+      all_cols = []
+      all_cols1 = []
+      all_cols2 = []
+      all_cols3 = []
+      common = @local
+      if @local != nil 
+        key_cols = @local.get_primary_key
+        data_cols = @local.get_all_but_primary_key
+        all_cols = @local.get_column_names
+        all_cols1 = @local.get_column_names
+      end
+      if @remote != nil 
+        all_cols2 = @remote.get_column_names
+        common = @remote if common == nil
+      end
+      if @alt != nil 
+        all_cols3 = @alt.get_column_names
+        common = @alt if common == nil
+      else 
+        all_cols3 = all_cols2
+      end
       all_common_cols = Array.new
       data_common_cols = Array.new
       present1 = {}
@@ -305,9 +340,11 @@ module Coopy
         self.scan_columns(all_cols1,all_cols3,key_cols,present1,present3,@align.reference)
         @align.reference.tables(@local,@alt)
       end
-      sql_table1 = @local.get_quoted_table_name
-      sql_table2 = @remote.get_quoted_table_name
+      sql_table1 = ""
+      sql_table2 = ""
       sql_table3 = ""
+      sql_table1 = @local.get_quoted_table_name if @local != nil
+      sql_table2 = @remote.get_quoted_table_name if @remote != nil
       sql_table3 = @alt.get_quoted_table_name if @alt != nil
       if @peered 
         sql_table1 = "main." + _hx_str(sql_table1)
@@ -322,7 +359,7 @@ module Coopy
           i6 = _g16
           _g16+=1
           sql_key_cols += "," if i6 > 0
-          sql_key_cols += @local.get_quoted_column_name(key_cols[i6])
+          sql_key_cols += common.get_quoted_column_name(key_cols[i6])
         end
       end
       sql_all_cols = ""
@@ -333,7 +370,7 @@ module Coopy
           i7 = _g17
           _g17+=1
           sql_all_cols += "," if i7 > 0
-          sql_all_cols += @local.get_quoted_column_name(all_common_cols[i7])
+          sql_all_cols += common.get_quoted_column_name(all_common_cols[i7])
         end
       end
       sql_all_cols1 = ""
@@ -355,7 +392,7 @@ module Coopy
           i9 = _g19
           _g19+=1
           sql_all_cols2 += "," if i9 > 0
-          sql_all_cols2 += @local.get_quoted_column_name(all_cols2[i9])
+          sql_all_cols2 += @remote.get_quoted_column_name(all_cols2[i9])
         end
       end
       sql_all_cols3 = ""
@@ -366,7 +403,7 @@ module Coopy
           i10 = _g110
           _g110+=1
           sql_all_cols3 += "," if i10 > 0
-          sql_all_cols3 += @local.get_quoted_column_name(all_cols3[i10])
+          sql_all_cols3 += @alt.get_quoted_column_name(all_cols3[i10])
         end
       end
       sql_key_match2 = ""
@@ -377,7 +414,7 @@ module Coopy
           i11 = _g111
           _g111+=1
           sql_key_match2 += " AND " if i11 > 0
-          n = @local.get_quoted_column_name(key_cols[i11])
+          n = common.get_quoted_column_name(key_cols[i11])
           sql_key_match2 += _hx_str(sql_table1) + "." + _hx_str(n) + " IS " + _hx_str(sql_table2) + "." + _hx_str(n)
         end
       end
@@ -389,7 +426,7 @@ module Coopy
           i12 = _g112
           _g112+=1
           sql_key_match3 += " AND " if i12 > 0
-          n1 = @local.get_quoted_column_name(key_cols[i12])
+          n1 = common.get_quoted_column_name(key_cols[i12])
           sql_key_match3 += _hx_str(sql_table1) + "." + _hx_str(n1) + " IS " + _hx_str(sql_table3) + "." + _hx_str(n1)
         end
       end
@@ -401,7 +438,7 @@ module Coopy
           i13 = _g113
           _g113+=1
           sql_data_mismatch += " OR " if i13 > 0
-          n2 = @local.get_quoted_column_name(data_common_cols[i13])
+          n2 = common.get_quoted_column_name(data_common_cols[i13])
           sql_data_mismatch += _hx_str(sql_table1) + "." + _hx_str(n2) + " IS NOT " + _hx_str(sql_table2) + "." + _hx_str(n2)
         end
       end
@@ -414,7 +451,7 @@ module Coopy
           key5 = all_cols2[i14]
           if !present1.include?(key5) 
             sql_data_mismatch += " OR " if sql_data_mismatch != ""
-            n3 = @remote.get_quoted_column_name(key5)
+            n3 = common.get_quoted_column_name(key5)
             sql_data_mismatch += _hx_str(sql_table2) + "." + _hx_str(n3) + " IS NOT NULL"
           end
         end
@@ -427,7 +464,7 @@ module Coopy
             i15 = _g115
             _g115+=1
             sql_data_mismatch += " OR " if sql_data_mismatch.length > 0
-            n4 = @local.get_quoted_column_name(data_common_cols[i15])
+            n4 = common.get_quoted_column_name(data_common_cols[i15])
             sql_data_mismatch += _hx_str(sql_table1) + "." + _hx_str(n4) + " IS NOT " + _hx_str(sql_table3) + "." + _hx_str(n4)
           end
         end
@@ -440,7 +477,7 @@ module Coopy
             key6 = all_cols3[i16]
             if !present1.include?(key6) 
               sql_data_mismatch += " OR " if sql_data_mismatch != ""
-              n5 = @alt.get_quoted_column_name(key6)
+              n5 = common.get_quoted_column_name(key6)
               sql_data_mismatch += _hx_str(sql_table3) + "." + _hx_str(n5) + " IS NOT NULL"
             end
           end
@@ -456,7 +493,7 @@ module Coopy
           _g117+=1
           sql_dbl_cols += "," if sql_dbl_cols != ""
           buf = "__coopy_" + _hx_str(i17)
-          n6 = @local.get_quoted_column_name(all_cols1[i17])
+          n6 = common.get_quoted_column_name(all_cols1[i17])
           sql_dbl_cols += _hx_str(sql_table1) + "." + _hx_str(n6) + " AS " + _hx_str(buf)
           dbl_cols.push(buf)
         end
@@ -469,7 +506,7 @@ module Coopy
           _g118+=1
           sql_dbl_cols += "," if sql_dbl_cols != ""
           buf1 = "__coopy_" + _hx_str(i18) + "b"
-          n7 = @local.get_quoted_column_name(all_cols2[i18])
+          n7 = common.get_quoted_column_name(all_cols2[i18])
           sql_dbl_cols += _hx_str(sql_table2) + "." + _hx_str(n7) + " AS " + _hx_str(buf1)
           dbl_cols.push(buf1)
         end
@@ -482,7 +519,7 @@ module Coopy
           _g119+=1
           sql_dbl_cols += "," if sql_dbl_cols != ""
           buf2 = "__coopy_" + _hx_str(i19) + "c"
-          n8 = @local.get_quoted_column_name(all_cols3[i19])
+          n8 = common.get_quoted_column_name(all_cols3[i19])
           sql_dbl_cols += _hx_str(sql_table3) + "." + _hx_str(n8) + " AS " + _hx_str(buf2)
           dbl_cols.push(buf2)
         end
@@ -495,7 +532,7 @@ module Coopy
           i20 = _g120
           _g120+=1
           sql_order += "," if i20 > 0
-          n9 = @local.get_quoted_column_name(key_cols[i20])
+          n9 = common.get_quoted_column_name(key_cols[i20])
           sql_order += n9
         end
       end
@@ -505,49 +542,60 @@ module Coopy
       rowid3 = "-3"
       if rowid_name != nil 
         rowid = rowid_name
-        rowid1 = _hx_str(sql_table1) + "." + _hx_str(rowid_name)
-        rowid2 = _hx_str(sql_table2) + "." + _hx_str(rowid_name)
-        rowid3 = _hx_str(sql_table3) + "." + _hx_str(rowid_name)
+        rowid1 = _hx_str(sql_table1) + "." + _hx_str(rowid_name) if @local != nil
+        rowid2 = _hx_str(sql_table2) + "." + _hx_str(rowid_name) if @remote != nil
+        rowid3 = _hx_str(sql_table3) + "." + _hx_str(rowid_name) if @alt != nil
       end
       @at0 = 1
       @at1 = 1
       @at2 = 1
-      sql_inserts = "SELECT DISTINCT 0 AS __coopy_code, NULL, " + _hx_str(rowid) + " AS rowid, NULL, " + _hx_str(sql_all_cols2) + " FROM " + _hx_str(sql_table2) + " WHERE NOT EXISTS (SELECT 1 FROM " + _hx_str(sql_table1) + _hx_str(self.where(sql_key_match2)) + ")"
-      sql_inserts_order = ["__coopy_code","NULL","rowid","NULL"].concat(all_cols2)
-      self.link_query(sql_inserts,sql_inserts_order)
+      @diff_ct = 0
+      if @remote != nil 
+        sql_inserts = "SELECT DISTINCT 0 AS __coopy_code, NULL, " + _hx_str(rowid) + " AS rowid, NULL, " + _hx_str(sql_all_cols2) + " FROM " + _hx_str(sql_table2)
+        sql_inserts += " WHERE NOT EXISTS (SELECT 1 FROM " + _hx_str(sql_table1) + _hx_str(self.where(sql_key_match2)) + ")" if @local != nil
+        sql_inserts_order = ["__coopy_code","NULL","rowid","NULL"].concat(all_cols2)
+        self.link_query(sql_inserts,sql_inserts_order)
+      end
       if @alt != nil 
-        sql_inserts1 = "SELECT DISTINCT 1 AS __coopy_code, NULL, NULL, " + _hx_str(rowid) + " AS rowid, " + _hx_str(sql_all_cols3) + " FROM " + _hx_str(sql_table3) + " WHERE NOT EXISTS (SELECT 1 FROM " + _hx_str(sql_table1) + _hx_str(self.where(sql_key_match3)) + ")"
+        sql_inserts1 = "SELECT DISTINCT 1 AS __coopy_code, NULL, NULL, " + _hx_str(rowid) + " AS rowid, " + _hx_str(sql_all_cols3) + " FROM " + _hx_str(sql_table3)
+        sql_inserts1 += " WHERE NOT EXISTS (SELECT 1 FROM " + _hx_str(sql_table1) + _hx_str(self.where(sql_key_match3)) + ")" if @local != nil
         sql_inserts_order1 = ["__coopy_code","NULL","NULL","rowid"].concat(all_cols3)
         self.link_query(sql_inserts1,sql_inserts_order1)
       end
-      sql_updates = "SELECT DISTINCT 2 AS __coopy_code, " + _hx_str(rowid1) + " AS __coopy_rowid0, " + _hx_str(rowid2) + " AS __coopy_rowid1, "
-      if @alt != nil 
-        sql_updates += _hx_str(rowid3) + " AS __coopy_rowid2,"
-      else 
-        sql_updates += " NULL,"
-      end
-      sql_updates += _hx_str(sql_dbl_cols) + " FROM " + _hx_str(sql_table1)
-      sql_updates += " INNER JOIN " + _hx_str(sql_table2) + " ON " + _hx_str(sql_key_match2) if sql_table1 != sql_table2
-      sql_updates += " INNER JOIN " + _hx_str(sql_table3) + " ON " + _hx_str(sql_key_match3) if @alt != nil && sql_table1 != sql_table3
-      sql_updates += self.where(sql_data_mismatch)
-      sql_updates_order = ["__coopy_code","__coopy_rowid0","__coopy_rowid1","__coopy_rowid2"].concat(dbl_cols)
-      self.link_query(sql_updates,sql_updates_order)
+      if @local != nil && @remote != nil 
+        sql_updates = "SELECT DISTINCT 2 AS __coopy_code, " + _hx_str(rowid1) + " AS __coopy_rowid0, " + _hx_str(rowid2) + " AS __coopy_rowid1, "
+        if @alt != nil 
+          sql_updates += _hx_str(rowid3) + " AS __coopy_rowid2,"
+        else 
+          sql_updates += " NULL,"
+        end
+        sql_updates += _hx_str(sql_dbl_cols) + " FROM " + _hx_str(sql_table1)
+        sql_updates += " INNER JOIN " + _hx_str(sql_table2) + " ON " + _hx_str(sql_key_match2) if sql_table1 != sql_table2
+        sql_updates += " INNER JOIN " + _hx_str(sql_table3) + " ON " + _hx_str(sql_key_match3) if @alt != nil && sql_table1 != sql_table3
+        sql_updates += self.where(sql_data_mismatch)
+        sql_updates_order = ["__coopy_code","__coopy_rowid0","__coopy_rowid1","__coopy_rowid2"].concat(dbl_cols)
+        self.link_query(sql_updates,sql_updates_order)
+      end
       if @alt == nil 
-        sql_deletes = "SELECT DISTINCT 0 AS __coopy_code, " + _hx_str(rowid) + " AS rowid, NULL, NULL, " + _hx_str(sql_all_cols1) + " FROM " + _hx_str(sql_table1) + " WHERE NOT EXISTS (SELECT 1 FROM " + _hx_str(sql_table2) + _hx_str(self.where(sql_key_match2)) + ")"
-        sql_deletes_order = ["__coopy_code","rowid","NULL","NULL"].concat(all_cols1)
-        self.link_query(sql_deletes,sql_deletes_order)
+        if @local != nil 
+          sql_deletes = "SELECT DISTINCT 0 AS __coopy_code, " + _hx_str(rowid) + " AS rowid, NULL, NULL, " + _hx_str(sql_all_cols1) + " FROM " + _hx_str(sql_table1)
+          sql_deletes += " WHERE NOT EXISTS (SELECT 1 FROM " + _hx_str(sql_table2) + _hx_str(self.where(sql_key_match2)) + ")" if @remote != nil
+          sql_deletes_order = ["__coopy_code","rowid","NULL","NULL"].concat(all_cols1)
+          self.link_query(sql_deletes,sql_deletes_order)
+        end
       end
       if @alt != nil 
         sql_deletes1 = "SELECT 2 AS __coopy_code, " + _hx_str(rowid1) + " AS __coopy_rowid0, " + _hx_str(rowid2) + " AS __coopy_rowid1, "
         sql_deletes1 += _hx_str(rowid3) + " AS __coopy_rowid2, "
         sql_deletes1 += sql_dbl_cols
         sql_deletes1 += " FROM " + _hx_str(sql_table1)
-        sql_deletes1 += " LEFT OUTER JOIN " + _hx_str(sql_table2) + " ON " + _hx_str(sql_key_match2)
+        sql_deletes1 += " LEFT OUTER JOIN " + _hx_str(sql_table2) + " ON " + _hx_str(sql_key_match2) if @remote != nil
         sql_deletes1 += " LEFT OUTER JOIN " + _hx_str(sql_table3) + " ON " + _hx_str(sql_key_match3)
         sql_deletes1 += " WHERE __coopy_rowid1 IS NULL OR __coopy_rowid2 IS NULL"
         sql_deletes_order1 = ["__coopy_code","__coopy_rowid0","__coopy_rowid1","__coopy_rowid2"].concat(dbl_cols)
         self.link_query(sql_deletes1,sql_deletes_order1)
       end
+      @align.mark_identical if @diff_ct == 0
       @align
     end