daff 1.2.6 → 1.3.1

data/lib/lib/coopy/sql_database.rb

@@ -13,6 +13,8 @@ module Coopy
     def end() puts "Abstract SqlDatabase.end called" end
     def width() puts "Abstract SqlDatabase.width called" end
     def rowid() puts "Abstract SqlDatabase.rowid called" end
+    def getHelper() puts "Abstract SqlDatabase.getHelper called" end
+    def getNameForAttachment() puts "Abstract SqlDatabase.getNameForAttachment called" end
   haxe_me ["coopy", "SqlDatabase"]
   end
 

data/lib/lib/coopy/sql_helper.rb

@@ -6,6 +6,11 @@ module Coopy
     def getTableNames(db) puts "Abstract SqlHelper.getTableNames called" end
     def countRows(db,name) puts "Abstract SqlHelper.countRows called" end
     def getRowIDs(db,name) puts "Abstract SqlHelper.getRowIDs called" end
+    def insert(db,name,vals) puts "Abstract SqlHelper.insert called" end
+    def delete(db,name,conds) puts "Abstract SqlHelper.delete called" end
+    def update(db,name,conds,vals) puts "Abstract SqlHelper.update called" end
+    def attach(db,tag,resource_name) puts "Abstract SqlHelper.attach called" end
+    def alterColumns(db,name,columns) puts "Abstract SqlHelper.alterColumns called" end
   haxe_me ["coopy", "SqlHelper"]
   end
 

data/lib/lib/coopy/sql_table.rb

@@ -8,6 +8,7 @@ module Coopy
       @db = db
       @name = name
       @helper = helper
+      @helper = db.get_helper if helper == nil
       @cache = {}
       @h = -1
       @id2rid = nil
@@ -57,7 +58,7 @@ module Coopy
           result.push(col.get_name)
         end
       end
-      return result
+      result
     end
     
     def get_all_but_primary_key 
@@ -73,28 +74,30 @@ module Coopy
           result.push(col.get_name)
         end
       end
-      return result
+      result
     end
     
     def get_column_names 
       self.get_columns
-      return @column_names
+      @column_names
     end
     
     def get_quoted_table_name 
       return @quoted_table_name if @quoted_table_name != nil
       @quoted_table_name = @db.get_quoted_table_name(@name)
-      return @quoted_table_name
+      @quoted_table_name
     end
     
     def get_quoted_column_name(name)
-      return @db.get_quoted_column_name(name)
+      @db.get_quoted_column_name(name)
     end
     
     def get_cell(x,y)
       if @h >= 0 
         y = y - 1
         y = @id2rid[y] if y >= 0
+      elsif y == 0 
+        y = -1
       end
       if y < 0 
         self.get_columns
@@ -129,7 +132,7 @@ module Coopy
       end
       begin
         this1 = @cache[y]
-        return this1.get(x)
+        this1.get(x)
       end
     end
     
@@ -158,30 +161,30 @@ module Coopy
     end
     
     def get_cell_view 
-      return ::Coopy::SimpleView.new
+      ::Coopy::SimpleView.new
     end
     
     def is_resizable 
-      return false
+      false
     end
     
     def resize(w,h)
-      return false
+      false
     end
     
     def clear 
     end
     
     def insert_or_delete_rows(fate,hfate)
-      return false
+      false
     end
     
     def insert_or_delete_columns(fate,wfate)
-      return false
+      false
     end
     
     def trim_blank 
-      return false
+      false
     end
     
     def height() get_height end
@@ -191,23 +194,123 @@ module Coopy
     
     def get_width 
       self.get_columns
-      return @columns.length
+      @columns.length
     end
     
     def get_height 
       return @h if @h >= 0
-      return -1 if @helper == nil
-      @id2rid = @helper.get_row_ids(@db,@name)
-      @h = @id2rid.length + 1
-      return @h
+      -1
     end
     
     def get_data 
-      return nil
+      nil
     end
     
     def clone 
-      return nil
+      nil
+    end
+    
+    def get_meta 
+      self
+    end
+    
+    def alter_columns(columns)
+      result = @helper.alter_columns(@db,@name,columns)
+      @columns = nil
+      result
+    end
+    
+    def change_row(rc)
+      if @helper == nil 
+        puts "No sql helper"
+        return false
+      end
+      if rc.action == "+++" 
+        return @helper.insert(@db,@name,rc.val)
+      elsif rc.action == "---" 
+        return @helper._delete(@db,@name,rc.cond)
+      elsif rc.action == "->" 
+        return @helper.update(@db,@name,rc.cond,rc.val)
+      end
+      false
+    end
+    
+    def as_table 
+      pct = 3
+      self.get_columns
+      w = @column_names.length
+      mt = ::Coopy::SimpleTable.new(w + 1,pct)
+      mt.set_cell(0,0,"@")
+      mt.set_cell(0,1,"type")
+      mt.set_cell(0,2,"pkey")
+      begin
+        _g = 0
+        while(_g < w) 
+          x = _g
+          _g+=1
+          i = x + 1
+          mt.set_cell(i,0,@column_names[x])
+          mt.set_cell(i,1,@columns[x].type_value)
+          mt.set_cell(i,2,((@columns[x].primary) ? 1 : 0))
+        end
+      end
+      mt
+    end
+    
+    def use_for_column_changes 
+      true
+    end
+    
+    def use_for_row_changes 
+      true
+    end
+    
+    def clone_meta(table = nil)
+      nil
+    end
+    
+    def apply_flags(flags)
+      false
+    end
+    
+    def get_database 
+      @db
+    end
+    
+    def get_row_stream 
+      self.get_columns
+      @db._begin("SELECT * FROM " + _hx_str(self.get_quoted_table_name) + " ORDER BY ?",[@db.rowid],@column_names)
+      self
+    end
+    
+    def fetch_row 
+      if @db.read 
+        row = {}
+        begin
+          _g1 = 0
+          _g = @column_names.length
+          while(_g1 < _g) 
+            i = _g1
+            _g1+=1
+            begin
+              v = @db.get(i)
+              begin
+                value = v
+                row[@column_names[i]] = value
+              end
+              v
+            end
+          end
+        end
+        return row
+      end
+      @db._end
+      nil
+    end
+    
+    def fetch_columns 
+      self.get_columns
+      @column_names
     end
     
   haxe_me ["coopy", "SqlTable"]

data/lib/lib/coopy/sql_table_name.rb

@@ -14,7 +14,7 @@ module Coopy
     
     def to_s 
       return @name if @prefix == ""
-      return _hx_str(@prefix) + "." + _hx_str(@name)
+      _hx_str(@prefix) + "." + _hx_str(@name)
     end
     
   haxe_me ["coopy", "SqlTableName"]

data/lib/lib/coopy/sqlite_helper.rb

@@ -15,7 +15,7 @@ module Coopy
         names.push(db.get(0))
       end
       db._end
-      return names
+      names
     end
     
     def count_rows(db,name)
@@ -26,7 +26,7 @@ module Coopy
         ct = db.get(0)
       end
       db._end
-      return ct
+      ct
     end
     
     def get_row_ids(db,name)
@@ -38,7 +38,254 @@ module Coopy
         result.push(c)
       end
       db._end
-      return result
+      result
+    end
+    
+    def update(db,name,conds,vals)
+      q = "UPDATE " + _hx_str(db.get_quoted_table_name(name)) + " SET "
+      lst = Array.new
+      _it = ::Rb::RubyIterator.new(vals.keys)
+      while(_it.has_next) do
+        k = _it._next
+        q += ", " if lst.length > 0
+        q += db.get_quoted_column_name(k)
+        q += " = ?"
+        lst.push(vals[k])
+      end
+      val_len = lst.length
+      q += " WHERE "
+      _it2 = ::Rb::RubyIterator.new(conds.keys)
+      while(_it2.has_next) do
+        k1 = _it2._next
+        q += " and " if lst.length > val_len
+        q += db.get_quoted_column_name(k1)
+        q += " = ?"
+        lst.push(conds[k1])
+      end
+      if !db._begin(q,lst,[]) 
+        puts "Problem with database update"
+        return false
+      end
+      db._end
+      true
+    end
+    
+    def _delete(db,name,conds)
+      q = "DELETE FROM " + _hx_str(db.get_quoted_table_name(name)) + " WHERE "
+      lst = Array.new
+      _it = ::Rb::RubyIterator.new(conds.keys)
+      while(_it.has_next) do
+        k = _it._next
+        q += " and " if lst.length > 0
+        q += db.get_quoted_column_name(k)
+        q += " = ?"
+        lst.push(conds[k])
+      end
+      if !db._begin(q,lst,[]) 
+        puts "Problem with database delete"
+        return false
+      end
+      db._end
+      true
+    end
+    
+    def insert(db,name,vals)
+      q = "INSERT INTO " + _hx_str(db.get_quoted_table_name(name)) + " ("
+      lst = Array.new
+      _it = ::Rb::RubyIterator.new(vals.keys)
+      while(_it.has_next) do
+        k = _it._next
+        q += "," if lst.length > 0
+        q += db.get_quoted_column_name(k)
+        lst.push(vals[k])
+      end
+      q += ") VALUES("
+      need_comma = false
+      _it2 = ::Rb::RubyIterator.new(vals.keys)
+      while(_it2.has_next) do
+        k1 = _it2._next
+        q += "," if need_comma
+        q += "?"
+        need_comma = true
+      end
+      q += ")"
+      if !db._begin(q,lst,[]) 
+        puts "Problem with database insert"
+        return false
+      end
+      db._end
+      true
+    end
+    
+    def attach(db,tag,resource_name)
+      if !db._begin("ATTACH ? AS `" + _hx_str(tag) + "`",[resource_name],[]) 
+        puts "Failed to attach " + _hx_str(resource_name) + " as " + _hx_str(tag)
+        return false
+      end
+      db._end
+      true
+    end
+    
+    protected
+    
+    def column_list_sql(x)
+      x.join(",")
+    end
+    
+    def fetch_schema(db,name)
+      tname = db.get_quoted_table_name(name)
+      query = "select sql from sqlite_master where name = '" + _hx_str(tname) + "'"
+      if !db._begin(query,nil,["sql"]) 
+        puts "Cannot find schema for table " + _hx_str(tname)
+        return nil
+      end
+      sql = ""
+      sql = db.get(0) if db.read
+      db._end
+      sql
+    end
+    
+    def split_schema(db,name,sql)
+      preamble = ""
+      parts = Array.new
+      double_quote = false
+      single_quote = false
+      token = ""
+      nesting = 0
+      begin
+        _g1 = 0
+        _g = sql.length
+        while(_g1 < _g) 
+          i = _g1
+          _g1+=1
+          ch = sql[i]
+          if double_quote || single_quote 
+            if double_quote 
+              double_quote = false if ch == "\""
+            end
+            if single_quote 
+              single_quote = false if ch == "'"
+            end
+            token += ch
+            next
+          end
+          brk = false
+          if ch == "(" 
+            nesting+=1
+            brk = true if nesting == 1
+          elsif ch == ")" 
+            nesting-=1
+            brk = true if nesting == 0
+          end
+          if ch == "," 
+            brk = true
+            if nesting == 1 
+            end
+          end
+          if brk 
+            token = token[1,token.length] if token[0] == " "
+            if preamble == "" 
+              preamble = token
+            else 
+              parts.push(token)
+            end
+            token = ""
+          else 
+            token += ch
+          end
+        end
+      end
+      cols = db.get_columns(name)
+      name2part = {}
+      name2col = {}
+      begin
+        _g11 = 0
+        _g2 = cols.length
+        while(_g11 < _g2) 
+          i1 = _g11
+          _g11+=1
+          col = cols[i1]
+          name2part[col.name] = parts[i1]
+          name2col[col.name] = cols[i1]
+        end
+      end
+      { preamble: preamble, parts: parts, name2part: name2part, columns: cols, name2column: name2col}
+    end
+    
+    def exec(db,query)
+      if !db._begin(query) 
+        puts "database problem"
+        return false
+      end
+      db._end
+      true
+    end
+    
+    public
+    
+    def alter_columns(db,name,columns)
+      not_blank = lambda {|x|
+        return false if x == nil || x == "" || x == "null"
+        true
+      }
+      sql = self.fetch_schema(db,name)
+      schema = self.split_schema(db,name,sql)
+      parts = schema[:parts]
+      nparts = Array.new
+      new_column_list = Array.new
+      ins_column_list = Array.new
+      sel_column_list = Array.new
+      meta = schema[:columns]
+      begin
+        _g1 = 0
+        _g = columns.length
+        while(_g1 < _g) 
+          i = _g1
+          _g1+=1
+          c = columns[i]
+          if c.name != nil 
+            if c.prev_name != nil 
+              sel_column_list.push(c.prev_name)
+              ins_column_list.push(c.name)
+            end
+            orig_type = ""
+            orig_primary = false
+            if schema[:name2column].include?(c.name) 
+              m = schema[:name2column][c.name]
+              orig_type = m.type_value
+              orig_primary = m.primary
+            end
+            next_type = orig_type
+            next_primary = orig_primary
+            if c.props != nil 
+              _g2 = 0
+              _g3 = c.props
+              while(_g2 < _g3.length) 
+                p = _g3[_g2]
+                _g2+=1
+                next_type = p.val if p.name == "type"
+                next_primary = "" + _hx_str(p.val.to_s) == "1" if p.name == "pkey"
+              end
+            end
+            part = "" + _hx_str(c.name)
+            part += " " + _hx_str(next_type) if not_blank.call(next_type)
+            part += " PRIMARY KEY" if next_primary
+            nparts.push(part)
+            new_column_list.push(c.name)
+          end
+        end
+      end
+      return false if !self.exec(db,"BEGIN TRANSACTION")
+      c1 = self.column_list_sql(ins_column_list)
+      tname = db.get_quoted_table_name(name)
+      return false if !self.exec(db,"CREATE TEMPORARY TABLE __coopy_backup(" + _hx_str(c1) + ")")
+      return false if !self.exec(db,"INSERT INTO __coopy_backup (" + _hx_str(c1) + ") SELECT " + _hx_str(c1) + " FROM " + _hx_str(tname))
+      return false if !self.exec(db,"DROP TABLE " + _hx_str(tname))
+      return false if !self.exec(db,_hx_str(schema[:preamble]) + "(" + _hx_str(nparts.join(", ")) + ")")
+      return false if !self.exec(db,"INSERT INTO " + _hx_str(tname) + " (" + _hx_str(c1) + ") SELECT " + _hx_str(c1) + " FROM __coopy_backup")
+      return false if !self.exec(db,"DROP TABLE __coopy_backup")
+      return false if !self.exec(db,"COMMIT")
+      true
     end
     
   haxe_me ["coopy", "SqliteHelper"]