daff 1.2.6 → 1.3.1

data/lib/lib/coopy/simple_table.rb

@@ -8,6 +8,7 @@ module Coopy
       @data = {}
       @w = w
       @h = h
+      @meta = nil
     end
     
     # protected - in ruby this doesn't play well with static/inline methods
@@ -15,11 +16,12 @@ module Coopy
     attr_accessor :data
     attr_accessor :w
     attr_accessor :h
+    attr_accessor :meta
     
     public
     
     def get_table 
-      return self
+      self
     end
     
     def height() get_height end
@@ -28,15 +30,15 @@ module Coopy
     def width=(__v) @width = __v end
     
     def get_width 
-      return @w
+      @w
     end
     
     def get_height 
-      return @h
+      @h
     end
     
     def get_cell(x,y)
-      return @data[x + y * @w]
+      @data[x + y * @w]
     end
     
     def set_cell(x,y,c)
@@ -48,21 +50,21 @@ module Coopy
     end
     
     def to_s 
-      return ::Coopy::SimpleTable.table_to_string(self)
+      ::Coopy::SimpleTable.table_to_string(self)
     end
     
     def get_cell_view 
-      return ::Coopy::SimpleView.new
+      ::Coopy::SimpleView.new
     end
     
     def is_resizable 
-      return true
+      true
     end
     
     def resize(w,h)
       @w = w
       @h = h
-      return true
+      true
     end
     
     def clear 
@@ -98,7 +100,7 @@ module Coopy
       end
       @h = hfate
       @data = data2
-      return true
+      true
     end
     
     def insert_or_delete_columns(fate,wfate)
@@ -130,7 +132,7 @@ module Coopy
       end
       @w = wfate
       @data = data2
-      return true
+      true
     end
     
     def trim_blank 
@@ -201,11 +203,11 @@ module Coopy
       end
       @w = nw
       @data = data2
-      return true
+      true
     end
     
     def get_data 
-      return nil
+      nil
     end
     
     def clone 
@@ -227,37 +229,89 @@ module Coopy
           end
         end
       end
-      return result
+      result.meta = @meta.clone_meta(result) if @meta != nil
+      result
+    end
+    
+    def set_meta(meta)
+      @meta = meta
+    end
+    
+    def get_meta 
+      @meta
     end
     
     def SimpleTable.table_to_string(tab)
-      x = ""
+      meta = tab.get_meta
+      if meta != nil 
+        stream = meta.get_row_stream
+        if stream != nil 
+          x = ""
+          cols = stream.fetch_columns
+          begin
+            _g1 = 0
+            _g = cols.length
+            while(_g1 < _g) 
+              i = _g1
+              _g1+=1
+              x += "," if i > 0
+              x += cols[i]
+            end
+          end
+          x += "\n"
+          row = stream.fetch_row
+          while(row != nil) 
+            begin
+              _g11 = 0
+              _g2 = cols.length
+              while(_g11 < _g2) 
+                i1 = _g11
+                _g11+=1
+                x += "," if i1 > 0
+                begin
+                  s = row[cols[i1]]
+                  x += s.to_s
+                end
+              end
+            end
+            x += "\n"
+            row = stream.fetch_row
+          end
+          return x
+        end
+      end
+      x1 = ""
       begin
-        _g1 = 0
-        _g = tab.get_height
-        while(_g1 < _g) 
-          i = _g1
-          _g1+=1
+        _g12 = 0
+        _g3 = tab.get_height
+        while(_g12 < _g3) 
+          i2 = _g12
+          _g12+=1
           begin
-            _g3 = 0
-            _g2 = tab.get_width
-            while(_g3 < _g2) 
-              j = _g3
-              _g3+=1
-              x += " " if j > 0
+            _g31 = 0
+            _g21 = tab.get_width
+            while(_g31 < _g21) 
+              j = _g31
+              _g31+=1
+              x1 += "," if j > 0
               begin
-                s = tab.get_cell(j,i)
-                x += s.to_s
+                s1 = tab.get_cell(j,i2)
+                x1 += s1.to_s
               end
             end
           end
-          x += "\n"
+          x1 += "\n"
         end
       end
-      return x
+      x1
     end
     
     def SimpleTable.table_is_similar(tab1,tab2)
+      if tab1.get_height == -1 || tab2.get_height == -1 
+        txt1 = ::Coopy::SimpleTable.table_to_string(tab1)
+        txt2 = ::Coopy::SimpleTable.table_to_string(tab2)
+        return txt1 == txt2
+      end
       return false if tab1.get_width != tab2.get_width
       return false if tab1.get_height != tab2.get_height
       v = tab1.get_cell_view
@@ -278,7 +332,7 @@ module Coopy
           end
         end
       end
-      return true
+      true
     end
     
   haxe_me ["coopy", "SimpleTable"]

data/lib/lib/coopy/simple_view.rb

@@ -8,23 +8,23 @@ module Coopy
     end
     
     def to_s(d)
-      return nil if d == nil
-      return "" + _hx_str(d.to_s)
+      return "" if d == nil
+      "" + _hx_str(d.to_s)
     end
     
     def equals(d1,d2)
       return true if d1 == nil && d2 == nil
       return true if d1 == nil && "" + _hx_str(d2.to_s) == ""
       return true if "" + _hx_str(d1.to_s) == "" && d2 == nil
-      return "" + _hx_str(d1.to_s) == "" + _hx_str(d2.to_s)
+      "" + _hx_str(d1.to_s) == "" + _hx_str(d2.to_s)
     end
     
     def to_datum(x)
-      return x
+      x
     end
     
     def make_hash 
-      return {}
+      {}
     end
     
     def hash_set(h,str,d)
@@ -40,16 +40,16 @@ module Coopy
     
     def hash_exists(h,str)
       hh = h
-      return hh.include?(str)
+      hh.include?(str)
     end
     
     def hash_get(h,str)
       hh = h
-      return hh[str]
+      hh[str]
     end
     
     def is_hash(h)
-      return h.respond_to? :keys
+      h.respond_to? :keys
     end
     
   haxe_me ["coopy", "SimpleView"]

data/lib/lib/coopy/sparse_sheet.rb

@@ -33,7 +33,7 @@ module Coopy
       return @zero if cursor == nil
       val = cursor[x]
       return @zero if val == nil
-      return val
+      val
     end
     
     def set(x,y,val)

data/lib/lib/coopy/sql_column.rb

@@ -5,28 +5,40 @@ module Coopy
   class SqlColumn 
     
     def initialize
+      @name = ""
+      @primary = false
+      @type_value = nil
+      @type_family = nil
     end
     
     attr_accessor :name
     attr_accessor :primary
+    attr_accessor :type_value
+    attr_accessor :type_family
+    
+    def set_name(name)
+      @name = name
+    end
+    
+    def set_primary_key(primary)
+      @primary = primary
+    end
+    
+    def set_type(value,family)
+      @type_value = value
+      @type_family = family
+    end
     
     def get_name 
-      return @name
+      @name
     end
     
     def is_primary_key 
-      return @primary
+      @primary
     end
     
     def to_s 
-      return _hx_str((((@primary) ? "*" : ""))) + _hx_str(@name)
-    end
-    
-    def SqlColumn.by_name_and_primary_key(name,primary)
-      result = ::Coopy::SqlColumn.new
-      result.name = name
-      result.primary = primary
-      return result
+      _hx_str((((@primary) ? "*" : ""))) + _hx_str(@name)
     end
     
   haxe_me ["coopy", "SqlColumn"]

data/lib/lib/coopy/sql_compare.rb

@@ -4,22 +4,44 @@
 module Coopy
   class SqlCompare 
     
-    def initialize(db,local,remote)
+    def initialize(db,local,remote,alt,align = nil)
       @db = db
       @local = local
       @remote = remote
+      @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
+        end
+      end
+      @alt_peered = false
+      if @alt != 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)
+            @alt_peered = true
+          end
+        end
+      end
     end
     
     attr_accessor :db
-    attr_accessor :parent
     attr_accessor :local
     attr_accessor :remote
+    attr_accessor :alt
     
     protected
     
     attr_accessor :at0
     attr_accessor :at1
+    attr_accessor :at2
     attr_accessor :align
+    attr_accessor :peered
+    attr_accessor :alt_peered
+    attr_accessor :needed
     
     def equal_array(a1,a2)
       return false if a1.length != a2.length
@@ -32,7 +54,7 @@ module Coopy
           return false if a1[i] != a2[i]
         end
       end
-      return true
+      true
     end
     
     public
@@ -40,24 +62,38 @@ module Coopy
     def validate_schema 
       all_cols1 = @local.get_column_names
       all_cols2 = @remote.get_column_names
-      return false if !self.equal_array(all_cols1,all_cols2)
+      all_cols3 = all_cols2
       key_cols1 = @local.get_primary_key
       key_cols2 = @remote.get_primary_key
-      return false if !self.equal_array(key_cols1,key_cols2)
-      return false if key_cols1.length == 0
-      return true
+      key_cols3 = key_cols2
+      if @alt != nil 
+        all_cols3 = @alt.get_column_names
+        key_cols3 = @alt.get_primary_key
+      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
+      end
+      if key_cols1.length == 0 
+        puts "sql diff not possible when primary key not available"
+        return false
+      end
+      true
     end
     
     protected
     
     def denull(x)
       return -1 if x == nil
-      return x
+      x
     end
     
     def link 
-      i0 = self.denull(@db.get(0))
-      i1 = self.denull(@db.get(1))
+      mode = @db.get(0)
+      i0 = self.denull(@db.get(1))
+      i1 = self.denull(@db.get(2))
+      i2 = self.denull(@db.get(3))
       if i0 == -3 
         i0 = @at0
         @at0+=1
@@ -66,33 +102,54 @@ module Coopy
         i1 = @at1
         @at1+=1
       end
-      factor = nil
-      if i0 >= 0 && i1 >= 0 
-        factor = 2
-      else 
-        factor = 1
+      if i2 == -3 
+        i2 = @at2
+        @at2+=1
       end
-      offset = factor - 1
+      offset = 4
       if i0 >= 0 
-        _g1 = 0
-        _g = @local.get_width
-        while(_g1 < _g) 
-          x = _g1
-          _g1+=1
-          @local.set_cell_cache(x,i0,@db.get(2 + factor * x))
+        begin
+          _g1 = 0
+          _g = @local.get_width
+          while(_g1 < _g) 
+            x = _g1
+            _g1+=1
+            @local.set_cell_cache(x,i0,@db.get(x + offset))
+          end
         end
+        offset += @local.get_width
       end
       if i1 >= 0 
-        _g11 = 0
-        _g2 = @remote.get_width
-        while(_g11 < _g2) 
-          x1 = _g11
-          _g11+=1
-          @remote.set_cell_cache(x1,i1,@db.get(2 + factor * x1 + offset))
+        begin
+          _g11 = 0
+          _g2 = @remote.get_width
+          while(_g11 < _g2) 
+            x1 = _g11
+            _g11+=1
+            @remote.set_cell_cache(x1,i1,@db.get(x1 + offset))
+          end
+        end
+        offset += @remote.get_width
+      end
+      if i2 >= 0 
+        _g12 = 0
+        _g3 = @alt.get_width
+        while(_g12 < _g3) 
+          x2 = _g12
+          _g12+=1
+          @alt.set_cell_cache(x2,i2,@db.get(x2 + offset))
+        end
+      end
+      if mode == 0 || mode == 2 
+        @align.link(i0,i1)
+        @align.add_to_order(i0,i1)
+      end
+      if @alt != nil 
+        if mode == 1 || mode == 2 
+          @align.reference.link(i0,i2)
+          @align.reference.add_to_order(i0,i2)
         end
       end
-      @align.link(i0,i1)
-      @align.add_to_order(i0,i1)
     end
     
     def link_query(query,order)
@@ -104,139 +161,394 @@ module Coopy
       end
     end
     
+    def where(txt)
+      return " WHERE 1 = 0" if txt == ""
+      " WHERE " + _hx_str(txt)
+    end
+    
     public
     
+    def scan_columns(all_cols1,all_cols2,key_cols,present1,present2,align)
+      align.meta = ::Coopy::Alignment.new
+      begin
+        _g1 = 0
+        _g = all_cols1.length
+        while(_g1 < _g) 
+          i = _g1
+          _g1+=1
+          key = all_cols1[i]
+          if present2.include?(key) 
+            align.meta.link(i,present2[key])
+          else 
+            align.meta.link(i,-1)
+          end
+        end
+      end
+      begin
+        _g11 = 0
+        _g2 = all_cols2.length
+        while(_g11 < _g2) 
+          i1 = _g11
+          _g11+=1
+          key1 = all_cols2[i1]
+          align.meta.link(-1,i1) if !present1.include?(key1)
+        end
+      end
+      align.meta.range(all_cols1.length,all_cols2.length)
+      begin
+        _g3 = 0
+        while(_g3 < key_cols.length) 
+          key2 = key_cols[_g3]
+          _g3+=1
+          unit = ::Coopy::Unit.new(present1[key2],present2[key2])
+          align.add_index_columns(unit)
+        end
+      end
+    end
+    
     def apply 
       return nil if @db == nil
       return nil if !self.validate_schema
       rowid_name = @db.rowid
-      @align = ::Coopy::Alignment.new
+      @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
-      @align.meta = ::Coopy::Alignment.new
+      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
+      all_common_cols = Array.new
+      data_common_cols = Array.new
+      present1 = {}
+      present2 = {}
+      present3 = {}
+      present_primary = {}
+      has_column_add = false
       begin
         _g1 = 0
-        _g = all_cols.length
+        _g = key_cols.length
         while(_g1 < _g) 
           i = _g1
           _g1+=1
-          @align.meta.link(i,i)
+          present_primary[key_cols[i]] = i
         end
       end
-      @align.meta.range(all_cols.length,all_cols.length)
-      @align.tables(@local,@remote)
-      @align.range(999,999)
-      sql_table1 = @local.get_quoted_table_name
-      sql_table2 = @remote.get_quoted_table_name
-      sql_key_cols = ""
       begin
         _g11 = 0
-        _g2 = key_cols.length
+        _g2 = all_cols1.length
         while(_g11 < _g2) 
           i1 = _g11
           _g11+=1
-          sql_key_cols += "," if i1 > 0
-          sql_key_cols += @local.get_quoted_column_name(key_cols[i1])
+          key = all_cols1[i1]
+          present1[key] = i1
         end
       end
-      sql_all_cols = ""
       begin
         _g12 = 0
-        _g3 = all_cols.length
+        _g3 = all_cols2.length
         while(_g12 < _g3) 
           i2 = _g12
           _g12+=1
-          sql_all_cols += "," if i2 > 0
-          sql_all_cols += @local.get_quoted_column_name(all_cols[i2])
+          key1 = all_cols2[i2]
+          has_column_add = true if !present1.include?(key1)
+          present2[key1] = i2
         end
       end
-      sql_key_match = ""
       begin
         _g13 = 0
-        _g4 = key_cols.length
+        _g4 = all_cols3.length
         while(_g13 < _g4) 
           i3 = _g13
           _g13+=1
-          sql_key_match += " AND " if i3 > 0
-          n = @local.get_quoted_column_name(key_cols[i3])
-          sql_key_match += _hx_str(sql_table1) + "." + _hx_str(n) + " IS " + _hx_str(sql_table2) + "." + _hx_str(n)
+          key2 = all_cols3[i3]
+          has_column_add = true if !present1.include?(key2)
+          present3[key2] = i3
+          if present1.include?(key2) 
+            if present2.include?(key2) 
+              all_common_cols.push(key2)
+              data_common_cols.push(key2) if !present_primary.include?(key2)
+            end
+          end
         end
       end
-      sql_data_mismatch = ""
+      @align.meta = ::Coopy::Alignment.new
       begin
         _g14 = 0
-        _g5 = data_cols.length
+        _g5 = all_cols1.length
         while(_g14 < _g5) 
           i4 = _g14
           _g14+=1
-          sql_data_mismatch += " OR " if i4 > 0
-          n1 = @local.get_quoted_column_name(data_cols[i4])
-          sql_data_mismatch += _hx_str(sql_table1) + "." + _hx_str(n1) + " IS NOT " + _hx_str(sql_table2) + "." + _hx_str(n1)
+          key3 = all_cols1[i4]
+          if present2.include?(key3) 
+            @align.meta.link(i4,present2[key3])
+          else 
+            @align.meta.link(i4,-1)
+          end
         end
       end
-      sql_dbl_cols = ""
-      dbl_cols = []
       begin
         _g15 = 0
-        _g6 = all_cols.length
+        _g6 = all_cols2.length
         while(_g15 < _g6) 
           i5 = _g15
           _g15+=1
-          sql_dbl_cols += "," if i5 > 0
-          n2 = @local.get_quoted_column_name(all_cols[i5])
-          buf = "__coopy_" + _hx_str(i5)
-          sql_dbl_cols += _hx_str(sql_table1) + "." + _hx_str(n2) + " AS " + _hx_str(buf)
-          dbl_cols.push(buf)
-          sql_dbl_cols += ","
-          sql_dbl_cols += _hx_str(sql_table2) + "." + _hx_str(n2) + " AS " + _hx_str(buf) + "b"
-          dbl_cols.push(_hx_str(buf) + "b")
+          key4 = all_cols2[i5]
+          @align.meta.link(-1,i5) if !present1.include?(key4)
         end
       end
-      sql_order = ""
+      self.scan_columns(all_cols1,all_cols2,key_cols,present1,present2,@align)
+      @align.tables(@local,@remote)
+      if @alt != nil 
+        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_table3 = ""
+      sql_table3 = @alt.get_quoted_table_name if @alt != nil
+      if @peered 
+        sql_table1 = "main." + _hx_str(sql_table1)
+        sql_table2 = "__peer__." + _hx_str(sql_table2)
+      end
+      sql_table2 = "__alt__." + _hx_str(sql_table3) if @alt_peered
+      sql_key_cols = ""
       begin
         _g16 = 0
         _g7 = key_cols.length
         while(_g16 < _g7) 
           i6 = _g16
           _g16+=1
-          sql_order += "," if i6 > 0
-          n3 = @local.get_quoted_column_name(key_cols[i6])
-          sql_order += n3
+          sql_key_cols += "," if i6 > 0
+          sql_key_cols += @local.get_quoted_column_name(key_cols[i6])
         end
       end
-      sql_dbl_order = ""
+      sql_all_cols = ""
       begin
         _g17 = 0
-        _g8 = key_cols.length
+        _g8 = all_common_cols.length
         while(_g17 < _g8) 
           i7 = _g17
           _g17+=1
-          sql_dbl_order += "," if i7 > 0
-          n4 = @local.get_quoted_column_name(key_cols[i7])
-          sql_dbl_order += _hx_str(sql_table1) + "." + _hx_str(n4)
+          sql_all_cols += "," if i7 > 0
+          sql_all_cols += @local.get_quoted_column_name(all_common_cols[i7])
+        end
+      end
+      sql_all_cols1 = ""
+      begin
+        _g18 = 0
+        _g9 = all_cols1.length
+        while(_g18 < _g9) 
+          i8 = _g18
+          _g18+=1
+          sql_all_cols1 += "," if i8 > 0
+          sql_all_cols1 += @local.get_quoted_column_name(all_cols1[i8])
+        end
+      end
+      sql_all_cols2 = ""
+      begin
+        _g19 = 0
+        _g10 = all_cols2.length
+        while(_g19 < _g10) 
+          i9 = _g19
+          _g19+=1
+          sql_all_cols2 += "," if i9 > 0
+          sql_all_cols2 += @local.get_quoted_column_name(all_cols2[i9])
+        end
+      end
+      sql_all_cols3 = ""
+      if @alt != nil 
+        _g110 = 0
+        _g20 = all_cols3.length
+        while(_g110 < _g20) 
+          i10 = _g110
+          _g110+=1
+          sql_all_cols3 += "," if i10 > 0
+          sql_all_cols3 += @local.get_quoted_column_name(all_cols3[i10])
+        end
+      end
+      sql_key_match2 = ""
+      begin
+        _g111 = 0
+        _g21 = key_cols.length
+        while(_g111 < _g21) 
+          i11 = _g111
+          _g111+=1
+          sql_key_match2 += " AND " if i11 > 0
+          n = @local.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
+      sql_key_match3 = ""
+      if @alt != nil 
+        _g112 = 0
+        _g22 = key_cols.length
+        while(_g112 < _g22) 
+          i12 = _g112
+          _g112+=1
+          sql_key_match3 += " AND " if i12 > 0
+          n1 = @local.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
+      sql_data_mismatch = ""
+      begin
+        _g113 = 0
+        _g23 = data_common_cols.length
+        while(_g113 < _g23) 
+          i13 = _g113
+          _g113+=1
+          sql_data_mismatch += " OR " if i13 > 0
+          n2 = @local.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
+      begin
+        _g114 = 0
+        _g24 = all_cols2.length
+        while(_g114 < _g24) 
+          i14 = _g114
+          _g114+=1
+          key5 = all_cols2[i14]
+          if !present1.include?(key5) 
+            sql_data_mismatch += " OR " if sql_data_mismatch != ""
+            n3 = @remote.get_quoted_column_name(key5)
+            sql_data_mismatch += _hx_str(sql_table2) + "." + _hx_str(n3) + " IS NOT NULL"
+          end
+        end
+      end
+      if @alt != nil 
+        begin
+          _g115 = 0
+          _g25 = data_common_cols.length
+          while(_g115 < _g25) 
+            i15 = _g115
+            _g115+=1
+            sql_data_mismatch += " OR " if sql_data_mismatch.length > 0
+            n4 = @local.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
+        begin
+          _g116 = 0
+          _g26 = all_cols3.length
+          while(_g116 < _g26) 
+            i16 = _g116
+            _g116+=1
+            key6 = all_cols3[i16]
+            if !present1.include?(key6) 
+              sql_data_mismatch += " OR " if sql_data_mismatch != ""
+              n5 = @alt.get_quoted_column_name(key6)
+              sql_data_mismatch += _hx_str(sql_table3) + "." + _hx_str(n5) + " IS NOT NULL"
+            end
+          end
+        end
+      end
+      sql_dbl_cols = ""
+      dbl_cols = []
+      begin
+        _g117 = 0
+        _g27 = all_cols1.length
+        while(_g117 < _g27) 
+          i17 = _g117
+          _g117+=1
+          sql_dbl_cols += "," if sql_dbl_cols != ""
+          buf = "__coopy_" + _hx_str(i17)
+          n6 = @local.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
+      end
+      begin
+        _g118 = 0
+        _g28 = all_cols2.length
+        while(_g118 < _g28) 
+          i18 = _g118
+          _g118+=1
+          sql_dbl_cols += "," if sql_dbl_cols != ""
+          buf1 = "__coopy_" + _hx_str(i18) + "b"
+          n7 = @local.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
+      end
+      if @alt != nil 
+        _g119 = 0
+        _g29 = all_cols3.length
+        while(_g119 < _g29) 
+          i19 = _g119
+          _g119+=1
+          sql_dbl_cols += "," if sql_dbl_cols != ""
+          buf2 = "__coopy_" + _hx_str(i19) + "c"
+          n8 = @local.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
+      end
+      sql_order = ""
+      begin
+        _g120 = 0
+        _g30 = key_cols.length
+        while(_g120 < _g30) 
+          i20 = _g120
+          _g120+=1
+          sql_order += "," if i20 > 0
+          n9 = @local.get_quoted_column_name(key_cols[i20])
+          sql_order += n9
         end
       end
       rowid = "-3"
       rowid1 = "-3"
       rowid2 = "-3"
+      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)
       end
-      sql_inserts = "SELECT DISTINCT NULL, " + _hx_str(rowid) + " AS rowid, " + _hx_str(sql_all_cols) + " FROM " + _hx_str(sql_table2) + " WHERE NOT EXISTS (SELECT 1 FROM " + _hx_str(sql_table1) + " WHERE " + _hx_str(sql_key_match) + ")"
-      sql_inserts_order = ["NULL","rowid"].concat(all_cols)
-      sql_updates = "SELECT DISTINCT " + _hx_str(rowid1) + " AS __coopy_rowid0, " + _hx_str(rowid2) + " AS __coopy_rowid1, " + _hx_str(sql_dbl_cols) + " FROM " + _hx_str(sql_table1) + " INNER JOIN " + _hx_str(sql_table2) + " ON " + _hx_str(sql_key_match) + " WHERE " + _hx_str(sql_data_mismatch)
-      sql_updates_order = ["__coopy_rowid0","__coopy_rowid1"].concat(dbl_cols)
-      sql_deletes = "SELECT DISTINCT " + _hx_str(rowid) + " AS rowid, NULL, " + _hx_str(sql_all_cols) + " FROM " + _hx_str(sql_table1) + " WHERE NOT EXISTS (SELECT 1 FROM " + _hx_str(sql_table2) + " WHERE " + _hx_str(sql_key_match) + ")"
-      sql_deletes_order = ["rowid","NULL"].concat(all_cols)
       @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)
+      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_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)
-      self.link_query(sql_deletes,sql_deletes_order)
-      return @align
+      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)
+      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_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
     end
     
   haxe_me ["coopy", "SqlCompare"]