og 0.27.0 → 0.28.0

data/lib/og/store/sqlite.rb

@@ -6,6 +6,7 @@ rescue Object => ex
 end
 
 require 'fileutils'
+require 'set'
 
 require 'og/store/sql'
 
@@ -117,12 +118,46 @@ class SqliteStore < SqlStore
     @conn.changes
   end
 
+  def list_tables
+    rset = @conn.query("select name from sqlite_master where type = 'table'")
+    rset.map { |r| r[0] }
+  end
+
+  def list_fields(table)
+    rset = @conn.query("pragma table_info(#{table})")
+    columns = rset.columns
+    rows = rset.entries
+    idx = columns.index('name')
+    rows.map { |r| r[idx] }
+  end
+
 private
 
-  def create_table(klass)
+  def property_to_field(klass, p)
+    field = []
+
+    klass.index(p.symbol) if p.index
+        
+    field = field_for_property(p)
+      
+    if p.sql
+      field << " #{p.sql}"
+    else
+      field << " #{type_for_class(p.klass)}"
+      field << " UNIQUE" if p.unique  
+      field << " DEFAULT #{p.default.inspect} NOT NULL" if p.default
+      field << " #{p.extra_sql}" if p.extra_sql
+    end
+      
+    field
+  end
+
+  def create_table_ddl(klass, type = nil, table_name = nil)
     fields = fields_for_class(klass)
+    type ||= ''
+    table_name ||= klass::OGTABLE
 
-    sql = "CREATE TABLE #{klass::OGTABLE} (#{fields.join(', ')}"
+    sql = "CREATE #{type} TABLE #{table_name} (#{fields.join(', ')}"
 
     # Create table constraints.
 
@@ -130,7 +165,7 @@ private
       sql << ", #{constraints.join(', ')}"
     end
 
-    sql << ");"
+    sql << ")"
 
     # Create indices.
 
@@ -144,16 +179,67 @@ private
       end
     end
 
-    begin
+    sql
+  end
+
+  def create_table(klass)
+    unless list_tables.include?(klass::OGTABLE)
+      sql = create_table_ddl(klass)
+
       @conn.query(sql).close
       Logger.info "Created table '#{klass::OGTABLE}'."
-    rescue Object => ex
-      # gmosx: any idea how to better test this?
-      if ex.to_s =~ /table .* already exists/i
-        Logger.debug 'Table already exists' if $DBG
-        return
-      else
-        raise
+    else
+      Logger.debug "Table '#{klass::OGTABLE}' already exists" if $DBG
+
+      actual_fields = Set.new(list_fields(klass::OGTABLE))
+      defined_fields = Set.new(klass.properties.values.map { |f| field_for_property(f) } )
+
+      unless defined_fields == actual_fields
+        Logger.debug "Field mismatch in '#{klass::OGTABLE}'. Attempting to correct..."
+
+        fields_to_add = defined_fields - actual_fields
+        fields_to_delete = actual_fields - defined_fields
+
+        fields_to_add.each do |field|
+          if @options[:evolve_schema] == true
+            Logger.debug "Adding field '#{field}' to '#{klass::OGTABLE}'"
+            sql = "ALTER TABLE #{klass::OGTABLE} ADD COLUMN #{property_to_field(klass, klass.properties[field.to_sym])}"
+            @conn.query(sql)
+            @conn.query("VACUUM #{klass::OGTABLE}")
+          else
+            Logger.warn "Table '#{klass::OGTABLE} is missing field '#{field}' and :evolve_schema is not set to true or :cautious!"
+          end
+        end
+
+        # Sqlite3 does _NOT_ support removing columns via alter table. You have to drop the table.
+
+        unless fields_to_delete.empty?
+          if (@options[:evolve_schema] == true) and (@options[:evolve_schema_cautious] == false)
+            Logger.warn "Removing obsolete fields '#{fields_to_delete.to_a.join(', ')}' from '#{klass::OGTABLE}'!"
+
+            field_list = klass.properties.values.map { |f| field_for_property(f) }.join(', ')
+            backup_table = "#{klass::OGTABLE}_backup"
+
+            sql_transaction = [
+              "BEGIN TRANSACTION",
+              "#{create_table_ddl(klass, 'temporary', backup_table)}",
+              "INSERT INTO #{backup_table} SELECT #{field_list} FROM #{klass::OGTABLE}",
+              "DROP TABLE #{klass::OGTABLE}",
+              "#{create_table_ddl(klass)}",
+              "INSERT INTO #{klass::OGTABLE} SELECT #{field_list} FROM #{backup_table}",
+              "DROP TABLE #{backup_table}",
+              "COMMIT"
+            ]
+
+            sql_transaction.each do |s|
+              Logger.debug s if $DBG
+              @conn.query(s)
+            end
+          else
+            Logger.warn "Table '#{klass::OGTABLE}' contains obsolete fields '#{fields_to_delete.to_a.join(', ')}' " +
+              "and :evolve_schema is not set to true or is in cautious mode!"
+          end
+        end
       end
     end
 

data/lib/og/store/sqlite2.rb

@@ -0,0 +1,231 @@
+begin
+  require 'sqlite'
+rescue Object => ex
+  Logger.error 'Ruby-Sqlite bindings are not installed!'
+  Logger.error ex
+end
+
+require 'fileutils'
+
+require 'og/store/sql'
+
+#--
+# Customize the standard Sqlite2 resultset to make
+# more compatible with Og.
+#++
+
+class SQLite::ResultSet # :nodoc: all
+  alias_method :blank?, :eof?
+
+  def each_row
+    each do |row|
+      yield(row, 0)
+    end
+  end
+
+  def first_value
+    val = self.next[0]
+    close
+    return val
+  end
+
+  alias_method :fields, :columns
+end
+
+module Og
+
+# A Store that persists objects into an Sqlite2 database.
+# To read documentation about the methods, consult the documentation
+# for SqlStore and Store.
+
+class Sqlite2Store < SqlStore
+
+  # Override if needed.
+
+  def self.db_filename(options)
+    options[:name] ||= 'data'
+    "#{options[:name]}.db"
+  end
+
+  def self.destroy(options)
+    begin
+      FileUtils.rm(db_filename(options))
+      super
+    rescue Object
+      Logger.info "Cannot drop '#{options[:name]}'!"
+    end
+  end
+
+  # Initialize the Sqlite store.
+  # This store provides a default name.
+
+  def initialize(options)
+    super
+    @conn = SQLite::Database.new(self.class.db_filename(options))
+  end
+
+  def close
+    @conn.close
+    super
+  end
+
+  def enchant(klass, manager)
+    if klass.ann.self.primary_key.symbol == :oid
+      unless klass.properties.include? :oid
+        klass.property :oid, Fixnum, :sql => 'integer PRIMARY KEY'
+      end
+    end
+
+    super
+  end
+
+  def query(sql)
+    Logger.debug sql if $DBG
+    return @conn.query(sql)
+  rescue Exception => ex
+    handle_sql_exception(ex, sql)
+  end
+
+  def exec(sql)
+    Logger.debug sql if $DBG
+    @conn.query(sql).close
+  rescue => ex
+    handle_sql_exception(ex, sql)
+  end
+
+  def start
+    @conn.transaction if @transaction_nesting < 1
+    @transaction_nesting += 1
+  end
+
+  def commit
+    @transaction_nesting -= 1
+    @conn.commit if @transaction_nesting < 1
+  end
+
+  def rollback
+    @transaction_nesting -= 1
+    @conn.rollback if @transaction_nesting < 1
+  end
+
+  def last_insert_rowid
+    conn.query("SELECT last_insert_rowid()").first_value.to_i
+  end
+
+  def sql_update(sql)
+    exec(sql)
+    @conn.changes
+  end
+
+private
+
+  def create_table(klass)
+    fields = fields_for_class(klass)
+
+    sql = "CREATE TABLE #{klass::OGTABLE} (#{fields.join(', ')}"
+
+    # Create table constraints.
+
+    if constraints = klass.ann.self[:sql_constraint]
+      sql << ", #{constraints.join(', ')}"
+    end
+
+    sql << ");"
+
+    # Create indices.
+
+    if indices = klass.ann.self[:index]
+      for data in indices
+        idx, options = *data
+        idx = idx.to_s
+        pre_sql, post_sql = options[:pre], options[:post]
+        idxname = idx.gsub(/ /, "").gsub(/,/, "_").gsub(/\(.*\)/, "")
+        sql << " CREATE #{pre_sql} INDEX #{klass::OGTABLE}_#{idxname}_idx #{post_sql} ON #{klass::OGTABLE} (#{idx});"
+      end
+    end
+
+    begin
+      @conn.query(sql).close
+      Logger.info "Created table '#{klass::OGTABLE}'."
+    rescue Object => ex
+      # gmosx: any idea how to better test this?
+      if ex.to_s =~ /table .* already exists/i
+        Logger.debug 'Table already exists' if $DBG
+        return
+      else
+        raise
+      end
+    end
+
+    # Create join tables if needed. Join tables are used in
+    # 'many_to_many' relations.
+
+    if join_tables = klass.ann.self[:join_tables]
+      for info in join_tables
+        begin
+          create_join_table_sql(info).each do |sql|
+          @conn.query(sql).close
+        end
+          Logger.debug "Created jointable '#{info[:table]}'."
+        rescue Object => ex
+          # gmosx: any idea how to better test this?
+          if ex.to_s =~ /table .* already exists/i
+            Logger.debug 'Join table already exists' if $DBG
+          else
+            raise
+          end
+        end
+      end
+    end
+  end
+
+  def create_field_map(klass)
+    res = @conn.query "SELECT * FROM #{klass::OGTABLE} LIMIT 1"
+    map = {}
+
+    fields = res.columns
+
+    res.fields.size.times do |i|
+      map[fields[i].intern] = i
+    end
+
+    return map
+  ensure
+    res.close if res
+  end
+
+  def eval_og_insert(klass)
+    pk = klass.primary_key.symbol
+    props = klass.properties.values.dup
+    values = props.collect { |p| write_prop(p) }.join(',')
+
+    if klass.schema_inheritance?
+      props << Property.new(:symbol => :ogtype, :klass => String)
+      values << ", '#{klass}'"
+    end
+
+    sql = "INSERT INTO #{klass::OGTABLE} (#{props.collect {|p| field_for_property(p)}.join(',')}) VALUES (#{values})"
+
+    klass.class_eval %{
+      def og_insert(store)
+        #{Glue::Aspects.gen_advice_code(:og_insert, klass.advices, :pre) if klass.respond_to?(:advices)}
+        store.query("#{sql}").close
+        @#{pk} = store.last_insert_rowid
+        #{Glue::Aspects.gen_advice_code(:og_insert, klass.advices, :post) if klass.respond_to?(:advices)}
+      end
+    }
+  end
+
+end
+
+end
+
+# * George Moschovitis <gm@navel.gr>
+# * Ghislain Mary
+# * Mitchell Foral
+
+
+
+
+
+

data/lib/og/test/testcase.rb

@@ -1,7 +1,7 @@
 require 'test/unit'
 require 'test/unit/assertions'
 
-require 'mega/orm_support'
+require 'facet/ormsupport'
 
 require 'glue'
 require 'glue/fixture'

data/lib/og/vendor/mysql.rb

@@ -1,14 +1,15 @@
-# $Id: mysql.rb,v 1.1 2004/02/24 15:42:29 webster132 Exp $
+# $Id: mysql.rb,v 1.24 2005/02/12 11:37:15 tommy Exp $
 #
-# Copyright (C) 2003 TOMITA Masahiro
+# Copyright (C) 2003-2005 TOMITA Masahiro
 # tommy@tmtm.org
 #
 
-class Mysql # :nodoc: all
+class Mysql
 
-  VERSION = "4.0-ruby-0.2.4"
+  VERSION = "4.0-ruby-0.2.5"
 
   require "socket"
+  require "digest/sha1"
 
   MAX_PACKET_LENGTH = 256*256*256-1
   MAX_ALLOWED_PACKET = 1024*1024*1024
@@ -51,11 +52,15 @@ class Mysql # :nodoc: all
   CLIENT_ODBC    = 1 << 6
   CLIENT_LOCAL_FILES  = 1 << 7
   CLIENT_IGNORE_SPACE  = 1 << 8
+  CLIENT_PROTOCOL_41  = 1 << 9
   CLIENT_INTERACTIVE  = 1 << 10
   CLIENT_SSL    = 1 << 11
   CLIENT_IGNORE_SIGPIPE  = 1 << 12
   CLIENT_TRANSACTIONS  = 1 << 13
+  CLIENT_RESERVED  = 1 << 14
+  CLIENT_SECURE_CONNECTION  = 1 << 15
   CLIENT_CAPABILITIES = CLIENT_LONG_PASSWORD|CLIENT_LONG_FLAG|CLIENT_TRANSACTIONS
+  PROTO_AUTH41 = CLIENT_PROTOCOL_41 | CLIENT_SECURE_CONNECTION
 
   # Connection Option
   OPT_CONNECT_TIMEOUT  = 0
@@ -115,19 +120,35 @@ class Mysql # :nodoc: all
       @server_capabilities, = a.slice!(0,2).unpack("v")
     end
     if a.size >= 16 then
-      @server_language, @server_status = a.unpack("cv")
+      @server_language, @server_status = a.slice!(0,3).unpack("cv")
     end
 
     flag = 0 if flag == nil
     flag |= @client_flag | CLIENT_CAPABILITIES
     flag |= CLIENT_CONNECT_WITH_DB if db
-    data = Net::int2str(flag)+Net::int3str(@max_allowed_packet)+(user||"")+"\0"+scramble(passwd, @scramble_buff, @protocol_version==9)
-    if db and @server_capabilities & CLIENT_CONNECT_WITH_DB != 0 then
-      data << "\0"+db
+
+    @pre_411 = (0 == @server_capabilities & PROTO_AUTH41)
+    if @pre_411
+      data = Net::int2str(flag)+Net::int3str(@max_allowed_packet)+
+             (user||"")+"\0"+
+                   scramble(passwd, @scramble_buff, @protocol_version==9)
+    else
+      dummy, @salt2 = a.unpack("a13a12")
+      @scramble_buff += @salt2
+      flag |= PROTO_AUTH41
+      data = Net::int4str(flag) + Net::int4str(@max_allowed_packet) +
+             ([8] + Array.new(23, 0)).pack("c24") + (user||"")+"\0"+
+             scramble41(passwd, @scramble_buff)
+    end
+
+    if db and @server_capabilities & CLIENT_CONNECT_WITH_DB != 0
+      data << "\0" if @pre_411
+      data << db
       @db = db.dup
     end
     write data
     read
+    ObjectSpace.define_finalizer(self, Mysql.finalizer(@net))
     self
   end
   alias :connect :real_connect
@@ -182,7 +203,11 @@ class Mysql # :nodoc: all
   end
 
   def change_user(user="", passwd="", db="")
-    data = user+"\0"+scramble(passwd, @scramble_buff, @protocol_version==9)+"\0"+db
+    if @pre_411
+      data = user+"\0"+scramble(passwd, @scramble_buff, @protocol_version==9)+"\0"+db
+    else
+      data = user+"\0"+scramble41(passwd, @scramble_buff)+db
+    end
     command COM_CHANGE_USER, data
     @user = user
     @passwd = passwd
@@ -243,7 +268,11 @@ class Mysql # :nodoc: all
 
   def list_fields(table, field=nil)
     command COM_FIELD_LIST, "#{table}\0#{field}", true
-    f = read_rows 6
+    if @pre_411
+      f = read_rows 6
+    else
+      f = read_rows 7
+    end
     fields = unpack_fields(f, @server_capabilities & CLIENT_LONG_FLAG != 0)
     res = Result::new self, fields, f.length
     res.eof = true
@@ -253,7 +282,11 @@ class Mysql # :nodoc: all
   def list_processes()
     data = command COM_PROCESS_INFO
     @field_count = get_length data
-    fields = read_rows 5
+    if @pre_411
+      fields = read_rows 5
+    else
+      fields = read_rows 7
+    end
     @fields = unpack_fields(fields, @server_capabilities & CLIENT_LONG_FLAG != 0)
     @status = :STATUS_GET_RESULT
     store_result
@@ -311,7 +344,11 @@ class Mysql # :nodoc: all
 
   def read_one_row(field_count)
     data = read
-    return if data[0] == 254 and data.length == 1
+    if data[0] == 254 and data.length == 1 ## EOF
+      return
+    elsif data[0] == 254 and data.length == 5
+      return
+    end
     rec = []
     field_count.times do
       len = get_length data
@@ -363,7 +400,11 @@ class Mysql # :nodoc: all
       end
     else
       @extra_info = get_length(data, true)
-      fields = read_rows 5
+      if @pre_411
+        fields = read_rows(5)
+      else
+        fields = read_rows(7)
+      end
       @fields = unpack_fields(fields, @server_capabilities & CLIENT_LONG_FLAG != 0)
       @status = :STATUS_GET_RESULT
     end
@@ -373,19 +414,34 @@ class Mysql # :nodoc: all
   def unpack_fields(data, long_flag_protocol)
     ret = []
     data.each do |f|
-      table = org_table = f[0]
-      name = f[1]
-      length = f[2][0]+f[2][1]*256+f[2][2]*256*256
-      type = f[3][0]
-      if long_flag_protocol then
-  flags = f[4][0]+f[4][1]*256
-  decimals = f[4][2]
+      if @pre_411
+        table = org_table = f[0]
+        name = f[1]
+        length = f[2][0]+f[2][1]*256+f[2][2]*256*256
+        type = f[3][0]
+        if long_flag_protocol then
+          flags = f[4][0]+f[4][1]*256
+          decimals = f[4][2]
+        else
+          flags = f[4][0]
+          decimals = f[4][1]
+        end
+        def_value = f[5]
+        max_length = 0
       else
-  flags = f[4][0]
-  decimals = f[4][1]
+        catalog = f[0]
+        db = f[1]
+        table = f[2]
+        org_table = f[3]
+        name = f[4]
+        org_name = f[5]
+        length = f[6][2]+f[6][3]*256+f[6][4]*256*256
+        type = f[6][6]
+        flags = f[6][7]+f[6][8]*256
+        decimals = f[6][9]
+        def_value = ""
+        max_length = 0
       end
-      def_value = f[5]
-      max_length = 0
       ret << Field::new(table, org_table, name, length, type, flags, decimals, def_value, max_length)
     end
     ret
@@ -489,6 +545,16 @@ class Mysql # :nodoc: all
     to.join
   end
 
+  def scramble41(password, message)
+    return 0x00.chr if password.nil? or password.empty?
+    buf = [0x14]
+    s1 = Digest::SHA1.new(password).digest
+    s2 = Digest::SHA1.new(s1).digest
+    x = Digest::SHA1.new(message + s2).digest
+    (0..s1.length - 1).each {|i| buf.push(s1[i] ^ x[i])}
+    buf.pack("C*")
+  end
+
   def error(errno)
     @errno = errno
     @error = Error::err errno
@@ -574,7 +640,6 @@ class Mysql # :nodoc: all
     def free()
       @handle.skip_result
       @handle = @fields = @data = nil
-      GC::start
     end
 
     def num_fields()
@@ -1022,6 +1087,9 @@ class Mysql # :nodoc: all
       end
       @sock.sync = true
       buf.join
+    rescue
+      errno = Error::CR_SERVER_LOST 
+      raise Error::new(errno, Error::err(errno)) 
     end
     
     def write(data)
@@ -1039,6 +1107,9 @@ class Mysql # :nodoc: all
       @pkt_nr = @pkt_nr + 1 & 0xff
       @sock.sync = true
       @sock.flush
+    rescue
+      errno = Error::CR_SERVER_LOST 
+      raise Error::new(errno, Error::err(errno)) 
     end
 
     def close()
@@ -1085,6 +1156,13 @@ class << Mysql
   end
   alias :connect :real_connect
 
+  def finalizer(net)
+    proc {
+      net.clear
+      net.write Mysql::COM_QUIT.chr
+    }
+  end
+
   def escape_string(str)
     str.gsub(/([\0\n\r\032\'\"\\])/) do
       case $1