datamapper 0.1.0

data/lib/data_mapper/queries/connection.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/result'
+require File.dirname(__FILE__) + '/reader'
+
+module DataMapper
+  module Queries
+  
+    class Connection
+      
+      def initialize(logger)
+        @logger = logger
+      end
+      
+      def log
+        @logger
+      end
+      
+      def execute(sql)
+        raise NotImplementedError.new
+        Results.new
+      end
+      
+      def query(sql)
+        raise NotImplementedError.new
+        Reader.new
+      end
+      
+      def close
+        raise NotImplementedError.new
+      end
+      
+    end
+  
+  end # module Queries
+end # module DataMapper

data/lib/data_mapper/queries/create_table_statement.rb

@@ -0,0 +1,38 @@
+module DataMapper
+  module Queries
+    
+    class CreateTableStatement
+      
+      def initialize(database, klass)
+        @database, @klass = database, klass
+      end
+      
+      def to_sql
+        table = @database[@klass]
+        
+        sql = "CREATE TABLE " << table.to_sql << " ("
+        
+        sql << table.columns.map do |column|
+          column_long_form(column)
+        end.join(', ')
+        
+        sql << ", PRIMARY KEY (#{table.key.to_sql}))"
+        
+        return sql
+      end
+      
+      def column_long_form(column)
+        long_form = "#{column.to_sql} #{@database.adapter.class::TYPES[column.type] || column.type}"
+        
+        long_form << "(#{column.size})" unless column.size.nil?
+        long_form << " NOT NULL" unless column.nullable?
+        long_form << " " << @database.syntax(:auto_increment) if column.key?
+        long_form << " default #{column.options[:default]}" if column.options.has_key?(:default)
+        
+        return long_form
+      end
+      
+    end
+    
+  end
+end

data/lib/data_mapper/queries/delete_statement.rb

@@ -0,0 +1,17 @@
+module DataMapper
+  module Queries
+    
+    class DeleteStatement
+      
+      def initialize(database, instance)
+        @database, @instance = database, instance
+      end
+      
+      def to_sql
+        "DELETE FROM " << @database[@instance.class].to_sql << " WHERE id = " << @database.quote_value(@instance.key)
+      end
+      
+    end
+    
+  end
+end

data/lib/data_mapper/queries/drop_table_statement.rb

@@ -0,0 +1,17 @@
+module DataMapper
+  module Queries
+    
+    class DropTableStatement
+      
+      def initialize(database, klass)
+        @database, @klass = database, klass
+      end
+      
+      def to_sql
+        "DROP TABLE #{@database[@klass].to_sql}"
+      end
+      
+    end
+    
+  end
+end

data/lib/data_mapper/queries/insert_statement.rb

@@ -0,0 +1,29 @@
+module DataMapper
+  module Queries
+    
+    class InsertStatement
+      
+      def initialize(database, instance)
+        @database, @instance = database, instance
+      end
+      
+      # The only thing this method is responsible for is generating the insert statement.
+      # It is the database adapters responsibility to get the last inserted id
+      def to_sql
+        
+        table = @database[@instance.class]
+        
+        keys = []
+        values = []
+        
+        @instance.dirty_attributes.each_pair { |k,v| keys << table[k].to_sql; values << v }
+        
+        # Formatting is a bit off here, but it looks nicer in the log this way.
+        sql = "INSERT INTO #{table.to_sql} (#{keys.join(', ')}) \
+VALUES (#{values.map { |v| @database.quote_value(v) }.join(', ')})"
+      end
+      
+    end
+    
+  end
+end

data/lib/data_mapper/queries/reader.rb

@@ -0,0 +1,42 @@
+module DataMapper
+  module Queries
+  
+    class Reader
+      
+      attr_reader :columns
+      
+      def initialize(database_result_set)
+      end
+      
+      def eof?
+        raise NotImplementedError.new
+      end
+      
+      def records_affected
+        raise NotImplementedError.new
+      end
+      
+      def each
+        raise NotImplementedError.new
+      end
+      
+      def entries
+        raise NotImplementedError.new
+      end
+      
+      def [](column)
+        raise NotImplementedError.new
+      end
+      
+      def each_pair
+        raise NotImplementedError.new
+      end
+      
+      def close
+        raise NotImplementedError.new
+      end
+      
+    end
+  
+  end # module Queries
+end # module DataMapper

data/lib/data_mapper/queries/result.rb

@@ -0,0 +1,19 @@
+module DataMapper
+  module Queries
+  
+    class Result
+      
+      attr_accessor :size, :last_inserted_id
+      
+      def initialize(size, last_inserted_id = nil)
+        @size, @last_inserted_id = size, last_inserted_id
+      end
+      
+      def success?
+        size > 0
+      end
+      
+    end # class Result
+  
+  end # module Queries
+end # module DataMapper

data/lib/data_mapper/queries/select_statement.rb

@@ -0,0 +1,103 @@
+require 'data_mapper/queries/conditions'
+
+module DataMapper
+  module Queries
+    
+    class SelectStatement
+      
+      def initialize(database, options)
+        @database, @options = database, options
+      end
+      
+      def limit
+        @options[:limit]
+      end
+      
+      def order
+        @options[:order]
+      end
+
+      def klass
+        @options[:class]
+      end
+
+      def has_id?
+        conditions.has_id?
+      end
+
+      def escape(conditions)
+        @database.escape(conditions)
+      end
+      
+      def inspect
+        @options.inspect
+      end
+      
+      def include?(association_name)
+        return false if includes.empty?
+        includes.include?(association_name)
+      end
+      
+      def includes
+        list = @options[:include] ||= []
+        list.kind_of?(Array) ? list : [list]
+      end
+      
+      def reload?
+        @options[:reload]
+      end
+      
+      def select
+        select_columns = @options[:select]
+        unless select_columns.nil?
+          select_columns = select_columns.kind_of?(Array) ? select_columns : (@options[:select] = [select_columns])
+          select_columns.map { |column| @database.quote_column_name(column.to_s) }
+        else
+          @options[:select] = @database[klass].columns.select do |column|
+            include?(column.name) || !column.lazy?
+          end.map { |column| column.to_sql }
+        end
+      end
+      
+      def instance_id
+        @options[:id]
+      end
+        
+      def conditions
+        @conditions ||= Conditions.new(@database, @options)
+      end
+      
+      def table
+        @table_name || @table_name = if @options.has_key?(:table)
+          @database.quote_table_name(@options[:table])
+        else
+          @database[klass].to_sql
+        end
+      end
+
+      def to_sql
+        sql = 'SELECT ' << select.join(', ') << ' FROM ' << table
+        
+        where = []
+        
+        where += conditions.to_a unless conditions.empty?
+        
+        unless where.empty?
+          sql << ' WHERE (' << where.join(') AND (') << ')'
+        end
+        
+        unless order.nil?
+          sql << ' ORDER BY ' << order.to_s
+        end
+        
+        unless limit.nil?
+          sql << ' LIMIT ' << limit.to_s
+        end
+        
+        return sql
+      end
+      
+    end
+    
+  end
+end

data/lib/data_mapper/queries/table_exists_statement.rb

@@ -0,0 +1,17 @@
+module DataMapper
+  module Queries
+    
+    class TableExistsStatement
+      
+      def initialize(database, klass)
+        @database, @klass = database, klass
+      end
+      
+      def to_sql
+        "SHOW TABLES LIKE #{@database.quote_value(@database[@klass].name)}"
+      end
+      
+    end
+    
+  end
+end

data/lib/data_mapper/queries/truncate_table_statement.rb

@@ -0,0 +1,17 @@
+module DataMapper
+  module Queries
+    
+    class TruncateTableStatement
+      
+      def initialize(database, klass)
+        @database, @klass = database, klass
+      end
+      
+      def to_sql
+        "TRUNCATE TABLE " << @database[@klass].to_sql
+      end
+      
+    end
+    
+  end
+end

data/lib/data_mapper/queries/update_statement.rb

@@ -0,0 +1,25 @@
+module DataMapper
+  module Queries
+    
+    class UpdateStatement
+      
+      def initialize(database, instance)
+        @database, @instance = database, instance
+      end
+      
+      def to_sql
+        table = @database[@instance.class]
+        
+        sql = "UPDATE " << table.to_sql << " SET "
+        
+        @instance.dirty_attributes.map do |k, v|
+          sql << table[k].to_sql << " = " << @database.quote_value(v) << ", "
+        end
+        
+        sql[0, sql.size - 2] << " WHERE #{table.key.to_sql} = " << @database.quote_value(@instance.key)
+      end
+      
+    end
+    
+  end
+end

data/lib/data_mapper/session.rb

@@ -0,0 +1,240 @@
+require 'data_mapper/loaded_set'
+require 'data_mapper/identity_map'
+
+module DataMapper
+  
+  class Session
+    
+    FIND_OPTIONS = [
+        :select, :limit, :class, :include, :reload, :conditions, :order
+      ]
+      
+    class MaterializationError < StandardError
+    end
+    
+    def initialize(database)
+      @database = database
+    end
+    
+    def identity_map
+      @identity_map || ( @identity_map = IdentityMap.new )
+    end
+    
+    def find(klass, type_or_id, options = {}, &b)
+      options.merge! b.to_hash if block_given?
+      
+      results = case type_or_id
+        when :first then
+          first(@database.select_statement(options.merge(:class => klass, :limit => 1)))
+        when :all then
+          all(@database.select_statement(options.merge(:class => klass)))
+        else
+          first(@database.select_statement(options.merge(:class => klass, :id => type_or_id)))
+      end
+      
+      case results
+        when Array then results.each { |instance| instance.session = self }
+        when Base then results.session = self
+      end
+      return results
+    end
+    
+    def first(options)
+      if options.has_id? && !options.reload?
+        instance = identity_map.get(options.klass, options.instance_id)
+        return instance unless instance.nil?
+      end
+      
+      reader = @database.query(options)
+      instance = reader.eof? ? nil : load(options, reader.next)
+      reader.close
+      return instance
+    rescue DatabaseError => de
+      de.options = options
+      raise de
+    end
+    
+    def all(options)
+      set = LoadedSet.new(@database)
+      reader = @database.query(options)
+      instances = reader.map do |hash|
+        load(options, hash, set)
+      end
+      reader.close
+      return instances
+    rescue => error
+      @database.log.error(error)
+      raise error
+    end
+    
+    def load(options, hash, set = LoadedSet.new(@database))
+            
+      instance_class = unless hash['type'].nil?
+        Kernel::const_get(hash['type'])
+      else
+        options.klass
+      end
+      
+      mapping = @database[instance_class]
+      
+      instance_id = mapping.key.type_cast_value(hash['id'])      
+      instance = identity_map.get(instance_class, instance_id)
+      
+      if instance.nil? || options.reload?
+        instance ||= instance_class.new        
+        instance.class.callbacks.execute(:before_materialize, instance)
+        
+        instance.instance_variable_set(:@new_record, false)
+        hash.each_pair do |name_as_string,raw_value|
+          name = name_as_string.to_sym
+          if column = mapping.find_by_column_name(name)
+            value = column.type_cast_value(raw_value)
+            instance.instance_variable_set(column.instance_variable_name, value)
+          else
+            instance.instance_variable_set("@#{name}", value)
+          end
+          instance.original_hashes[name] = value.hash
+        end
+
+        instance.class.callbacks.execute(:after_materialize, instance)
+        
+        identity_map.set(instance)
+      end
+      
+      instance.instance_variable_set(:@loaded_set, set)
+      set.instances << instance
+      return instance
+    end
+    
+    def save(instance)
+      return false unless instance.dirty?
+      instance.class.callbacks.execute(:before_save, instance)
+      result = instance.new_record? ? insert(instance) : update(instance)
+      instance.session = self
+      instance.class.callbacks.execute(:after_save, instance)
+      result.success?
+    end
+    
+    def insert(instance, inserted_id = nil)
+      instance.class.callbacks.execute(:before_create, instance)
+      result = @database.execute(@database.insert_statement(instance))
+      
+      if result.success?
+        instance.instance_variable_set(:@new_record, false)
+        instance.instance_variable_set(:@id, inserted_id || result.last_inserted_id)
+        calculate_original_hashes(instance)
+        identity_map.set(instance)
+        instance.class.callbacks.execute(:after_create, instance)
+      end
+      
+      return result
+    rescue => error
+      @database.log.error(error)
+      raise error
+    end
+    
+    def update(instance)
+      instance.class.callbacks.execute(:before_update, instance)
+      result = @database.execute(@database.update_statement(instance))
+      calculate_original_hashes(instance)
+      instance.class.callbacks.execute(:after_update, instance)
+      return result
+    rescue => error
+      @database.log.error(error)
+      raise error
+    end
+    
+    def destroy(instance)
+      instance.class.callbacks.execute(:before_destroy, instance)
+      result = @database.execute(@database.delete_statement(instance))
+      if result.success?
+        instance.instance_variable_set(:@new_record, true)
+        instance.original_hashes.clear
+        instance.class.callbacks.execute(:after_destroy, instance)
+      end
+      return result.success?
+    rescue => error
+      @database.log.error(error)
+      raise error
+    end
+    
+    def delete_all(klass)
+      @database.execute(@database.delete_statement(klass))
+    end
+    
+    def truncate(klass)
+      @database.connection do |db|
+        db.execute(@database.truncate_table_statement(klass))
+      end
+    end
+    
+    def create_table(klass)
+      @database.connection do |db|
+        db.execute(@database.create_table_statement(klass))
+      end unless table_exists?(klass)
+    end
+    
+    def drop_table(klass)
+      @database.connection do |db|
+        db.execute(@database.drop_table_statement(klass))
+      end if table_exists?(klass)
+    end
+    
+    def table_exists?(klass)
+      reader = @database.connection do |db|
+        db.query(@database.table_exists_statement(klass))
+      end
+      result = !reader.eof?
+      reader.close
+      result
+    end
+    
+    def query(*args)
+      sql = args.shift
+      
+      unless args.empty?
+        sql.gsub!(/\?/) do |x|
+          @database.quote_value(args.shift)
+        end
+      end
+
+      reader = @database.connection do |db|
+        db.query(sql)
+      end
+      
+      columns = reader.columns.keys
+      klass = Struct.new(*columns.map { |c| c.to_sym })
+      
+      rows = reader.map do |row|
+        klass.new(*columns.map { |c| row[c] })
+      end
+      
+      reader.close
+      return rows
+    end
+    
+    def schema
+      @database.schema
+    end
+    
+    def log
+      @database.log
+    end
+    
+    private
+    
+    # Make sure this uses the factory changes later...
+    def type_cast_value(klass, name, raw_value)
+      @database[klass][name].type_cast_value(raw_value)
+    end
+    
+    # Calculates the original hashes for each value
+    # in an instance's set of attributes, and adds
+    # them to the original_hashes hash.
+    def calculate_original_hashes(instance)
+      instance.attributes.each_pair do |name, value|
+        instance.original_hashes[name] = value.hash
+      end
+    end
+  end
+end