og 0.31.0 → 0.40.0

data/lib/og/store/alpha/sqlserver.rb

@@ -1,256 +0,0 @@
-# WARNING: 
-# This store is not converted to the latest Og codebase.
-# DO NOT USE YET!
-
-begin
-  require 'dbi'
-rescue Object => ex
-  Logger.error 'Ruby-DBI bindings not present or ADO support not available.'
-  Logger.error ex
-end
-
-require 'og/store/sql'
-
-# Customize the standard SqlServer resultset to make
-# more compatible with Og.
-=begin
-class Sqlserver::Result
-  def blank?
-    0 == num_rows
-  end
-
-  alias_method :next, :fetch_row  
-
-  def each_row
-    each do |row|
-      yield(row, 0)
-    end
-  end
-  
-  def first_value
-    val = fetch_row[0]
-    free
-    return val
-  end
-  
-  alias_method :close, :free
-end
-=end
-
-module Og
-
-module SqlserverUtils
-  include SqlUtils
-  
-  def escape(str)
-    return nil unless str
-    return Sqlserver.quote(str)
-  end
-  
-  def quote(val)
-    case val
-      when Fixnum, Integer, Float
-        val ? val.to_s : 'NULL'
-      when String
-        val ? "'#{escape(val)}'" : 'NULL'
-      when Time
-        val ? "'#{timestamp(val)}'" : 'NULL'
-      when Date
-        val ? "'#{date(val)}'" : 'NULL'
-      when TrueClass
-        val ? "'1'" : 'NULL'
-      else 
-        # gmosx: keep the '' for nil symbols.
-        val ? escape(val.to_yaml) : ''
-    end 
-  end  
-end
-
-# A Store that persists objects into a Sqlserver database.
-# To read documentation about the methods, consult the documentation
-# for SqlStore and Store.
-
-class SqlserverStore < SqlStore
-  extend SqlserverUtils
-  include SqlserverUtils
-
-  def self.create(options)
-    raise 'Not implemented'
-  end
-
-  def self.destroy(options)
-    raise 'Not implemented'
-  end
-
-  def initialize(options)
-    super
-
-    begin
-      @conn = DBI.connect("DBI:ADO:Provider=SQLOLEDB;Data Source=#{options[:address]};Initial Catalog=#{options[:name]};User Id=#{options[:user]};Password=#{options[:password]};")
-    rescue => ex
-      # gmosx, FIXME: drak, fix this!
-      if ex.to_s =~ /database .* does not exist/i
-        Logger.info "Database '#{options[:name]}' not found!"
-        self.class.create(options)
-        retry
-      end
-      raise
-    end
-  end
-
-  def close
-    @conn.disconnect
-    super
-  end
-
-  def enchant(klass, manager)
-    klass.property :oid, Fixnum, :sql => 'integer AUTO_INCREMENT PRIMARY KEY'
-    super
-  end
-  
-  def query(sql)
-#    Logger.debug sql if $DBG
-    return @conn.select_all(sql)
-  rescue => ex
-    handle_sql_exception(ex, sql)
-  end
-
-  def exec(sql)
-#    Logger.debug sql if $DBG
-    @conn.execute(sql).finish 
-  rescue => ex
-    handle_sql_exception(ex, sql)
-  end
-
-private
-
-  def create_table(klass)
-    fields = fields_for_class(klass)
-
-    sql = "CREATE TABLE #{klass::OGTABLE} (#{fields.join(', ')}"
-    
-    # Create table constraints.
-    
-    if klass.__meta and constraints = klass.__meta[:sql_constraint]
-      sql << ", #{constraints.join(', ')}"
-    end
-    
-    sql << ");"
-    
-    # Create indices.
-    
-    if klass.__meta and indices = klass.__meta[: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
-    
-    conn.query_with_result = false
-
-    begin
-      conn.query(sql)
-      Logger.info "Created table '#{klass::OGTABLE}'."
-    rescue => ex
-      # gmosx: any idea how to better test this?
-      if ex.errno == 1050 # table already exists.
-        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 klass.__meta and join_tables = klass.__meta[:join_tables] 
-      for join_table in join_tables
-        begin
-          conn.query(create_join_table_sql(join_table))
-        rescue => ex
-          # gmosx: any idea how to better test this?
-          if ex.errno == 1050 # table already exists.
-            Logger.debug 'Join table already exists' if $DBG
-          else
-            raise
-          end
-        end
-      end
-    end
-  end
-
-  def create_field_map(klass)
-    conn.query_with_result = true
-    res = @conn.query "SELECT * FROM #{klass::OGTABLE} LIMIT 1"
-    map = {}
-
-    res.num_fields.times do |i|
-      map[res.fetch_field.name.intern] = i
-    end
-
-    return map
-  ensure
-    res.close if res
-  end
-
-  def write_prop(p)
-    if p.klass.ancestors.include?(Integer)
-      return "#\{@#{p.symbol} || 'NULL'\}"
-    elsif p.klass.ancestors.include?(Float)
-      return "#\{@#{p.symbol} || 'NULL'\}"    
-    elsif p.klass.ancestors.include?(String)
-      return %|#\{@#{p.symbol} ? "'#\{#{self.class}.escape(@#{p.symbol})\}'" : 'NULL'\}|
-    elsif p.klass.ancestors.include?(Time)
-      return %|#\{@#{p.symbol} ? "'#\{#{self.class}.timestamp(@#{p.symbol})\}'" : 'NULL'\}|
-    elsif p.klass.ancestors.include?(Date)
-      return %|#\{@#{p.symbol} ? "'#\{#{self.class}.date(@#{p.symbol})\}'" : 'NULL'\}|
-    elsif p.klass.ancestors.include?(TrueClass)
-      return "#\{@#{p.symbol} ? \"'1'\" : 'NULL' \}"
-    else 
-      # gmosx: keep the '' for nil symbols.
-      return %|#\{@#{p.symbol} ? "'#\{#{self.class}.escape(@#{p.symbol}.to_yaml)\}'" : "''"\}|
-    end
-  end
-
-  def read_prop(p, col)
-    if p.klass.ancestors.include?(Integer)
-      return "res[#{col} + offset].to_i"
-    elsif p.klass.ancestors.include?(Float)
-      return "res[#{col} + offset].to_f"
-    elsif p.klass.ancestors.include?(String)
-      return "res[#{col} + offset]"
-    elsif p.klass.ancestors.include?(Time)
-      return "#{self.class}.parse_timestamp(res[#{col} + offset])"
-    elsif p.klass.ancestors.include?(Date)
-      return "#{self.class}.parse_date(res[#{col} + offset])"
-    elsif p.klass.ancestors.include?(TrueClass)
-      return "('0' != res[#{col} + offset])"
-    else
-      return "YAML.load(res[#{col} + offset])"
-    end
-  end
-
-  def eval_og_insert(klass)
-    props = klass.properties
-    values = props.collect { |p| write_prop(p) }.join(',') 
-
-    sql = "INSERT INTO #{klass::OGTABLE} (#{props.collect {|p| p.symbol.to_s}.join(',')}) VALUES (#{values})"
-
-    klass.class_eval %{
-      def og_insert(store)
-        #{::Aspects.gen_advice_code(:og_insert, klass.advices, :pre) if klass.respond_to?(:advices)}
-        store.conn.query_with_result = false
-        store.conn.query "#{sql}"
-        @#{klass.pk_symbol} = store.conn.insert_id
-        #{::Aspects.gen_advice_code(:og_insert, klass.advices, :post) if klass.respond_to?(:advices)}
-      end
-    }
-  end
-
-end
-
-end

data/lib/og/store/kirby.rb

@@ -1,490 +0,0 @@
-begin
-  require 'kirbybase'
-rescue Object => ex
-  Logger.error "KirbyBase is not installed. Please run 'gem install KirbyBase'"
-  Logger.error ex
-end
-
-require 'fileutils'
-
-require 'og/store/sql'
-
-module Og
-  
-  #Fix for schema inheritance.  Instead of inferring the property on each
-  #access of the database we add it explicitly when the marker module
-  #is imported.  Currently this fix is applied for this store only.  The 
-  #other stores should be similarly altered.
-  module SchemaInheritanceBase
-    property :ogtype, String
-  end
-  
-  # A Store that persists objects into a KirbyBase database.
-  # To read documentation about the methods, consult the documentation
-  # for SqlStore and Store.
-  
-  class KirbyStore < SqlStore
-    
-    Text = :Text
-
-    # Override if needed.
-    
-    def self.base_dir(options)
-      options[:base_dir] || './kirbydb'
-    end
-    
-    def self.destroy(options)
-      begin
-        FileUtils.rm_rf(base_dir(options))
-        super
-      rescue Object
-        Logger.info 'Cannot drop database!'
-      end
-    end
-    
-    def initialize(options)
-      super
-      
-      @typemap = {
-        Integer => :Integer,
-        Fixnum => :Integer,
-        Float => :Float,
-        String => :String,
-        Time => :Time,
-        Date => :Date,
-        TrueClass => :Boolean,
-        FalseClass => :Boolean,
-        Object => :Object,
-        Array => :String,
-        Hash => :String
-      }
-      
-      mode = options[:mode] || :local
-      
-      if mode == :client
-        # Use a client/server configuration.
-        @conn = KirbyBase.new(:client, options[:address], options[:port])
-      else
-        # Use an in-process configuration.
-        base_dir = self.class.base_dir(options)
-        FileUtils.mkdir_p(base_dir) unless File.exist?(base_dir)
-        @conn = KirbyBase.new(
-                              :local, 
-                              nil, nil, 
-                              base_dir, 
-                              options[:ext] || '.tbl'
-                              )
-      end
-    end
-    
-    def close
-      # Nothing to do.
-      super
-    end
-
-    def enchant(klass, manager)
-      klass.send(:attr_accessor, :oid)
-      klass.send(:alias_method, :recno, :oid)
-      klass.send(:alias_method, :recno=, :oid=)
-      
-      super
-    end
-
-    def get_table(klass)
-      @conn.get_table(klass.table.to_sym)
-    end
-    
-    # :section: Lifecycle methods.
-    
-    def load(pk, klass)
-      convert_to_instance(klass, get_table(klass)[pk.to_i])
-    end
-    
-    #convert the given record into an instance of the given class.
-    #Supports schema_inheritance.
-    def convert_to_instance(klass, record)
-      return nil unless record
-      
-      if(klass.schema_inheritance?)
-        obj = eval("#{record.ogtype}.allocate")
-      elsif
-        obj = klass.allocate
-      end
-
-      record.each_pair do |k, v|
-        assign_sym = (k.to_s + '=').to_sym
-        if (v && obj.respond_to?(assign_sym))
-          obj.method(assign_sym).call(v)
-        end
-      end
-      obj
-    end
-    
-    alias_method :exist?, :load
-  
-    def reload(obj, pk)
-      raise 'Cannot reload unmanaged object' unless obj.saved?
-      new_obj = load(pk, obj.class)
-      #TODO: replace obj with new_obj
-    end
-  
-    def find(options)  
-      #FIXME: this currently overrides options with scope; this should
-      #work the other way around
-      if scope = options[:class].get_scope
-        scope = scope.dup
-        options.update(scope)
-      end
-      query(options)
-    end
-
-    def find_one(options)
-      query(options).first
-    end
-    
-    #--
-    # FIXME: optimize me!
-    #++
-    
-    def count(options)
-      find(options).size
-    end
-    
-    #--
-    # FIXME: optimize me! 
-    # 
-    #++
-    
-    def aggregate(term = 'COUNT(*)', options = {})
-      case term.upcase
-      when /COUNT/
-        count(options)
-      when /MIN/ 
-        term =~ /MIN\((\w*)\)/
-        find_column_values($1, options){|result| result.min}
-      when /MAX/
-        term =~ /MAX\((\w*)\)/
-        find_column_values($1, options) {|result| result.max}
-      when /AVG/
-        term =~ /AVG\((\w*)\)/
-        values = find_column_values($1, options) do |results|
-          results.inject(0.0){|sum, result| sum + result} / results.size
-        end
-      when /SUM/
-        term =~ /SUM\((\w*)\)/
-        values = find_column_values($1, options) do |results|      
-          results.inject(0.0){|sum, result| sum + result}
-        end
-      end
-    end
-    alias_method :calculate, :aggregate
-    
-    #find an array of values for the given column; or a hash of arrays
-    #if there is a group by expression.  Takes an optional block
-    #that operates on each value in the array.
-    
-    def find_column_values(column_name, options)
-      options[:column] = column_name
-      results = find(options)
-      if (block_given?)
-        if (options[:group]) #hash of arrays
-          results.values.collect { |group| yield group}
-        else
-          yield results
-        end
-      end
-    end
-
-    #needs refactoring, badly
-    def query(options)
-      Logger.debug "Querying with #{options.inspect}." if $DBG
-      
-      klass = options[:class]
-      
-      table = get_table(klass)
-      result_set = []
-      if (klass.schema_inheritance_child?)
-        type_condition = 'ogtype = \'' + klass.name + '\''
-        condition = options[:condition]
-        
-        if (condition)
-          #if there is already an ogtype condition do nothing
-          if (condition !~ /ogtype/)
-            options[:condition] = condition + " and #{type_condition}"
-          end
-        else
-          options[:condition] = type_condition
-        end
-      end
-      
-      #FIXME: add support for select statements with mathematics (tc_select)
-      #as well as 'from table' statements
-      if condition = options[:condition] || options[:where]
-        condition = condition.is_a?(Array) ? prepare_statement(condition) : condition
-        condition.gsub!(/ogtc_resolveoptions\w*\./, '')
-        condition.gsub!(/([^><])=/, '\1==')
-        condition.gsub!(/ OR /, ' or ')
-        condition.gsub!(/ AND /, ' and ')
-        condition.gsub!(/LIKE '(.*?)'/, '=~ /\1/')
-        condition.gsub!(/\%/, '')
-        condition.gsub!(/(\w*?)\s?([=><])(.)/, 'o.\1 \2\3')
-        condition.gsub!(/o.oid/, 'o.recno')
-        if(condition =~ /LIMIT (\d+)/)
-          condition.gsub!(/LIMIT (\d+)/, '')
-          options[:limit] = $1.to_i
-        end
-        result_set = eval("table.select do |o| #{condition} end")
-      else
-        result_set = table.select
-      end
-      
-      if (order = options[:order])
-        order = order.to_s
-        desc = (order =~ /DESC/)
-        order = order.gsub(/DESC/, '').gsub(/ASC/, '')
-        eval("result_set.sort { |x, y| x.#{order} <=> y.#{order} }")
-        result_set.reverse! if desc
-      end
-      
-      if (options[:limit])
-        limit = options[:limit]
-        if (result_set.size > limit)
-          result_set = result_set[0, limit]
-        end
-      end
-      
-      if (column = options[:column])
-        if (!result_set.methods.include?(column))
-          return []
-        end
-        begin
-        #if there is a group by expression on a valid column
-        #gather arrays of values
-        if ((group = options[:group]) && result_set.method(options[:group]))
-          #store an empty array under the key if there is no value
-          groups = Hash.new {|groups, key| groups[key] = []}
-          result_set.each do |object|
-            groups[object.method(group).call] << object.method(column).call
-          end
-          return groups
-        end
-        rescue NameError => error
-          Logger.warn 'Attempt to group by missing column:'
-          Logger.warn 'Column \'' + options[:group].to_s + '\' does not exist on table \'' + klass.name + '\''
-          raise error
-        end
-        
-        #when called on a resultset a column method returns an array of that 
-        #column's values
-        return result_set.method(column).call()
-      end
-
-      result_set.map { |object| convert_to_instance(klass, object) }
-    end
-
-    def start
-      # nop
-    end
-    
-    # Commit a transaction.
-    
-    def commit
-      # nop, not supported?
-    end
-    
-    # Rollback a transaction.
-    
-    def rollback
-      # nop, not supported?
-    end
-    
-    def sql_update(sql)
-      # nop, not supported.
-    end
-    
-    #FIXME: this method relies on naming conventions and does not account
-    #for more than one set of '::' marks.
-    
-    def join(obj1, obj2, table, options = nil)
-      first, second = join_object_ordering(obj1, obj2)
-      
-      options[get_key(first)] = first.pk
-      options[get_key(second)] = second.pk
-      
-      @conn.get_table(table.to_sym).insert(options)
-    end
-    
-    #retrieve the join table key name for the object
-    
-    def get_key(obj)
-      obj.class.name =~ /::(\w*)/
-      ($1.downcase + '_oid').to_sym
-    end
-    
-    def unjoin(obj1, obj2, table)
-      first, second = join_object_ordering(obj1, obj2)
-      
-      @conn.get_table(table.to_sym).delete do |r|
-        r.send(get_key(first)) == first.pk and
-          r.send(get_key(second)) == second.pk
-      end
-    end
-    
-    private
-
-    def typemap(key)
-      @typemap[key]
-    end
-
-    def create_table(klass)
-      if @conn.table_exists?(klass.table.to_sym)
-        get_table(klass).pack # Kirby specific method of database cleanup. 
-        
-        field_names = field_names_for_class(klass)
-        
-        actual_fields = get_table(klass).field_names
-        
-        field_names.each do |needed_field|
-          next if actual_fields.include?(needed_field)
-          
-          if @options[:evolve_schema] == true
-            Logger.debug "Adding field '#{needed_field}' to '#{klass.table}'" if $DBG
-            field_type = typemap(klass.properties[needed_field].klass)
-            if get_table(klass).respond_to?(:add_column)
-              get_table(klass).add_column(needed_field, field_type)
-            else
-              @conn.add_table_column(klass.table, needed_field, field_type)
-            end
-          else
-            Logger.warn "Table '#{klass.table}' is missing field '#{needed_field}' and :evolve_schema is not set to true!"
-          end
-        end
-        
-        actual_fields.each do |obsolete_field|
-          next if field_names.include?(obsolete_field) || obsolete_field == :recno
-          if @options[:evolve_schema] == true and @options[:evolve_schema_cautious] == false
-            Logger.debug "Removing obsolete field '#{obsolete_field}' from '#{klass.table}'" if $DBG
-            if get_table(klass).respond_to?(:drop_column)
-              get_table(klass).drop_column(obsolete_field)
-            else
-              @conn.drop_table_column(klass.table, obsolete_field)
-            end
-          else
-            Logger.warn "You have an obsolete field '#{obsolete_field}' on table '#{klass.table}' and :evolve_schema is not set or is in cautious mode!"
-          end
-        end
-      else
-        Logger.debug "Creating table '#{klass.table}'" if $DBG
-        fields = fields_for_class(klass)
-        table = @conn.create_table(klass.table.to_sym, *fields)
-      end
-
-=begin
-    # 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
-        unless @conn.table_exists?(info[:table].to_sym)
-          @conn.create_table(info[:table].to_sym, *create_join_table_sql(info))
-          Logger.debug "Created jointable '#{info[:table]}'." if $DBG
-        end
-      end
-    end
-=end
-    end
-      
-    def create_join_table_sql(join_info)
-      [join_info[:first_key].to_sym, :Integer, join_info[:second_key].to_sym, :Integer]
-    end
-
-    def drop_table(klass)
-      @conn.drop_table(klass.table) if @conn.table_exists?(klass.table)
-    end
-
-    def field_names_for_class(klass)
-      properties = get_properties_for_class(klass)
-      properties.values.map {|p| p.symbol }
-    end
-
-    def fields_for_class(klass)
-      fields = []
-      
-      get_properties_for_class(klass).values.each do |p|
-        klass.index(p.symbol) if p.index
-        
-        fields << p.symbol
-        
-        type = typemap(p.klass)
-        
-        fields << type
-      end
-      
-      fields
-    end
-    
-    def eval_og_insert(klass)
-      pk = klass.primary_key.symbol
-      
-      fields = get_properties_for_class(klass).keys
-      fields = fields.map { |f| ":#{f} => (self.respond_to?(:#{f}) ? self.#{f} : nil)"} 
-      field_string = fields.join(', ')
-      klass.class_eval %{ 
-        def og_insert(store)
-          @ogtype = #{klass}
-          #{::Aspects.gen_advice_code(:og_insert, klass.advices, :pre) if klass.respond_to?(:advices)}
-          Logger.debug "Inserting \#{self}." if $DBG
-          @#{pk} = store.get_table(#{klass}).insert({#{field_string}})
-          #{::Aspects.gen_advice_code(:og_insert, klass.advices, :post) if klass.respond_to?(:advices)}
-        end
-      }
-    end
-
-    # Compile the og_update method for the class.
-
-    def eval_og_update(klass)
-      pk = klass.pk_symbol
-      updates = klass.properties.keys.collect { |p| ":#{p} => @#{p}" }
-
-      klass.module_eval %{
-        def og_update(store, options = nil)
-          #{::Aspects.gen_advice_code(:og_update, klass.advices, :pre) if klass.respond_to?(:advices)}
-          store.get_table(#{klass}).update { |r| r.recno == #{pk} }.set(#{updates.join(', ')})
-          #{::Aspects.gen_advice_code(:og_update, klass.advices, :post) if klass.respond_to?(:advices)}
-        end
-      }
-    end
-  
-    def eval_og_read(klass)
-      klass.module_eval %{
-        def og_read(res, row = 0, offset = 0)
-          #{::Aspects.gen_advice_code(:og_read, klass.advices, :pre) if klass.respond_to?(:advices)}
-          #{::Aspects.gen_advice_code(:og_read, klass.advices, :post) if klass.respond_to?(:advices)}
-        end
-      }
-    end
-  
-    def eval_og_delete(klass)
-      klass.module_eval %{
-        def og_delete(store, pk, cascade = true)
-          pk ||= self.pk
-          pk = pk.to_i
-          #{::Aspects.gen_advice_code(:og_delete, klass.advices, :pre) if klass.respond_to?(:advices)}
-          table = store.get_table(self.class)
-          transaction do |tx|
-            table.delete { |r| r.recno == pk }
-            if cascade and #{klass}.ann.self[:descendants]
-              #{klass}.ann.self.descendants.each do |dclass, foreign_key|
-                dtable = store.get_table(dclass)
-                dtable.delete { |r| foreign_key == pk }
-              end
-            end
-          end
-        #{::Aspects.gen_advice_code(:og_delete, klass.advices, :post) if klass.respond_to?(:advices)}
-        end
-      }
-    end
-  end
-end
-
-# * George Moschovitis <gm@navel.gr>