og 0.31.0 → 0.40.0

data/lib/og/store/sqlite.rb

@@ -1,348 +0,0 @@
-begin
-  require 'sqlite3'
-rescue Object => ex
-  Logger.error 'Ruby-Sqlite3 bindings are not installed!'
-  Logger.error ex
-end
-
-require 'fileutils'
-require 'set'
-
-require 'og/store/sql'
-
-#--
-# Customize the standard Sqlite3 resultset to make
-# more compatible with Og.
-#++
-
-class SQLite3::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 Sqlite3 database.
-# To read documentation about the methods, consult the documentation
-# for SqlStore and Store.
-
-class SqliteStore < 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 = SQLite3::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
-
-  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
-
-  # Deserialize one object from the ResultSet.
-
-  def read_one(res, klass, options = nil)
-    return nil if res.blank?
-
-    if options and join_relations = options[:include]
-      join_relations = [join_relations].flatten.collect do |n|  
-        klass.relation(n) 
-      end     
-    end
-
-    res_row = res.next
-
-    # causes STI classes to come back as the correct child class 
-    # if accessed from the superclass.
-
-    klass = Og::Entity::entity_from_string(res_row[0]) if klass.schema_inheritance?
-    obj = klass.og_allocate(res_row, 0)
-
-    if options and options[:select]
-      read_row(obj, res, res_row, 0)
-    else    
-      obj.og_read(res_row)
-      read_join_relations(obj, res_row, 0, join_relations) if join_relations 
-    end
-
-    return obj
-
-  ensure
-    res.close
-  end
-
-private
-
-  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 #{type} TABLE #{table_name} (#{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
-
-    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}'."
-    else
-      Logger.debug "Table '#{klass::OGTABLE}' already exists" if $DBG
-
-      actual_fields = Set.new(list_fields(klass::OGTABLE))
-      defined_fields = Set.new(fields_for_class(klass).map { |f| f[0, f.index(' ')] } )
-
-      unless defined_fields == actual_fields
-        Logger.debug "Field mismatch in '#{klass::OGTABLE}'. Attempting to correct..." if $DBG
-
-        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}'" if $DBG
-            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
-
-    # 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]}'." if $DBG
-        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
-
-    # Check if the field should be ignored.
-    ignore = klass.ann[:self][:ignore_field] || klass.ann[:self][:ignore_fields] || klass.ann[:self][:ignore_columns]   
-
-    res.fields.size.times do |i|
-      field_name = fields[i].to_sym
-      unless (ignore and ignore.include?(field_name))
-        map[field_name] = i
-      end
-    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)
-        #{::Aspects.gen_advice_code(:og_insert, klass.advices, :pre) if klass.respond_to?(:advices)}
-        store.query("#{sql}").close
-        @#{pk} = store.last_insert_rowid        
-        #{::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

data/lib/og/store/sqlite2.rb

@@ -1,241 +0,0 @@
-#--
-# TODO: extend from sqlite.rb to avoid code duplication.
-#++
-
-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]}'." if $DBG
-        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
-
-    # Check if the field should be ignored.
-    ignore = klass.ann[:self][:ignore_field] || klass.ann[:self][:ignore_fields] || klass.ann[:self][:ignore_columns]   
-
-    res.fields.size.times do |i|
-      field_name = fields[i].to_sym
-      unless (ignore and ignore.include?(field_name))
-        map[field_name] = i
-      end
-    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)
-        #{::Aspects.gen_advice_code(:og_insert, klass.advices, :pre) if klass.respond_to?(:advices)}
-        store.query("#{sql}").close
-        @#{pk} = store.last_insert_rowid
-        #{::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
-
-
-
-
-
-