datamapper 0.1.1 → 0.2.0

data/lib/data_mapper/adapters/sql/coersion.rb

@@ -1,3 +1,6 @@
+require 'bigdecimal' 
+require 'bigdecimal/util'
+
 module DataMapper
   module Adapters
     module Sql
@@ -8,8 +11,11 @@ module DataMapper
       # it.
       module Coersion
         
-        TRUE_ALIASES = ['true'.freeze, 'TRUE'.freeze]
-        FALSE_ALIASES = [nil]
+        class CoersionError < StandardError
+        end
+        
+        TRUE_ALIASES = ['true'.freeze, 'TRUE'.freeze, '1'.freeze]
+        FALSE_ALIASES = [nil, '0'.freeze]
         
         def self.included(base)
           base.const_set('TRUE_ALIASES', TRUE_ALIASES.dup)
@@ -47,6 +53,18 @@ module DataMapper
           nil
         end
         
+        def type_cast_decimal(raw_value) 
+          return nil if raw_value.blank? 
+          raw_value.to_d
+        rescue ArgumentError 
+          nil 
+        end
+                
+        def type_cast_float(raw_value)
+          return nil if raw_value.blank?
+          raw_value.to_f
+        end
+        
         def type_cast_datetime(raw_value)
           return nil if raw_value.blank?
           
@@ -54,7 +72,18 @@ module DataMapper
             when DateTime then raw_value
             when Date then DateTime.new(raw_value)
             when String then DateTime::parse(raw_value)
-            else "Can't type-cast #{raw_value.inspect} to a datetime"
+            else raise CoersionError.new("Can't type-cast #{raw_value.inspect} to a datetime")
+          end
+        end
+        
+        def type_cast_date(raw_value)
+          return nil if raw_value.blank?
+          
+          case raw_value
+            when Date then raw_value
+            when DateTime, Time then Date::civil(raw_value.year, raw_value.month, raw_value.day)
+            when String then Date::parse(raw_value)
+            else raise CoersionError.new("Can't type-cast #{raw_value.inspect} to a date")
           end
         end
         

data/lib/data_mapper/adapters/sql/commands/conditions.rb

@@ -5,154 +5,123 @@ module DataMapper
     
         class Conditions
       
-          def initialize(adapter, loader)
+          def initialize(adapter, loader, conditions_hash)
             @adapter, @loader = adapter, loader
-            @has_id = false
+            @conditions = parse_conditions(conditions_hash)
           end
       
-          class NormalizationError < StandardError
-        
-            attr_reader :inner_error
-        
-            def initialize(clause, inner_error = nil)
-              @clause = clause
-              @inner_error = inner_error
-          
-              message = "Failed to normalize clause: #{clause.inspect}"
-              message << ", Error: #{inner_error.inspect}" unless inner_error.nil?
-          
-              super(message)
-            end
-        
-          end
-      
-          def normalize(clause, collector)
-            case clause
-              when Hash then
-                clause.each_pair do |k,v|
-                  if k.kind_of?(Symbol::Operator)
-                    if k.type == :select
-                      k.options[:class] ||= @loader.klass
-                  
-                      k.options[:select] ||= if k.value.to_s == @adapter[k.options[:class]].default_foreign_key
-                        @adapter[k.options[:class]].key.column_name
-                      else
-                        k.value
-                      end
-                  
-                      sub_select = @adapter.select_statement(k.options.merge(v))
-                      normalize(["#{@adapter[@loader.klass][k.value.to_sym].to_sql} IN ?", sub_select], collector)
-                    else                
-                      @has_id = true if k.value == :id
-                      op = case k.type
-                        when :gt then '>'
-                        when :gte then '>='
-                        when :lt then '<'
-                        when :lte then '<='
-                        when :not then v.nil? ? 'IS NOT' : (v.kind_of?(Array) ? 'NOT IN' : '<>')
-                        when :eql then v.nil? ? 'IS' : (v.kind_of?(Array) ? 'IN' : '=')
-                        when :like then 'LIKE'
-                        when :in then 'IN'
-                        else raise ArgumentError.new('Operator type not supported')
-                      end
-                      normalize(["#{@adapter[@loader.klass][k.value.to_sym].to_sql} #{op} ?", v], collector)
-                    end
-                  else
-                    @has_id = true if k == :id
-                    case v
-                    when Array then
-                      normalize(["#{@adapter[@loader.klass][k.to_sym].to_sql} IN ?", v], collector)
-                    when LoadCommand then
-                      normalize(["#{@adapter[@loader.klass][k.to_sym].to_sql} IN ?", v], collector)
-                    else
-                      normalize(["#{@adapter[@loader.klass][k.to_sym].to_sql} = ?", v], collector)
-                    end
-                  end
-                end
-              when Array then
-                return collector if clause.empty?
-                @has_id = true if clause.first =~ /(^|\s|\`)id(\`|\s|\=|\<)/ && !clause[1].kind_of?(LoadCommand)
-                collector << escape(clause)
-              when String then
-                @has_id = true if clause =~ /(^|\s|\`)id(\`|\s|\=|\<)/
-                collector << clause
-              else raise NormalizationError.new(clause)              
-            end
-        
-            return collector
+          def empty?
+            @conditions.empty?
           end
       
-          def escape(conditions)
-            clause = conditions.shift
-
-            clause.gsub(/\?/) do |x|
-              # Check if the condition is an in, clause.
-              case conditions.first
+          def to_parameterized_sql
+            sql = []
+            parameters = []
+            
+            @conditions.each do |condition|
+              case condition
+              when String then sql << condition
               when Array then
-                '(' << conditions.shift.map { |c| @adapter.quote_value(c) }.join(', ') << ')'
-              when LoadCommand then
-                '(' << conditions.shift.to_sql << ')'
+                  sql << condition.shift
+                  parameters += condition
               else
-                @adapter.quote_value(conditions.shift)
+                raise "Unable to parse condition: #{condition.inspect}" if condition
               end
             end
+            
+            parameters.unshift("(#{sql.join(') AND (')})")
           end
-      
-          def has_id?
-            normalized_conditions
-            @has_id
-          end
-          
-          def normalized_conditions
-        
-            if @normalized_conditions.nil?
-              @normalized_conditions = []
-
-              normalize(implicits, @normalized_conditions)
           
-              if @loader.options.has_key?(:conditions)
-                normalize(@loader.options[:conditions], @normalized_conditions)
+          private
+            
+            class ConditionsError < StandardError
+              
+              attr_reader :inner_error
+              
+              def initialize(clause, value, inner_error)
+                @clause, @value, @inner_error = clause, value, inner_error
               end
-          
-            end
-        
-            return @normalized_conditions          
-          end
-          
-          def table
-            @table || (@table = @adapter[@loader.klass])
-          end
-          
-          def implicits
-            @implicits || @implicits = begin
               
-              invalid_keys = false
+              def message
+                "Conditions (:clause => #{@clause.inspect}, :value => #{@value.inspect}) failed: #{@inner_error}"
+              end
               
-              implicit_conditions = @loader.options.reject do |k,v|            
-                standard_key = @adapter.class::FIND_OPTIONS.include?(k)
-                invalid_keys = true if !standard_key && table[k.to_sym].nil?
-                standard_key
+              def backtrace
+                @inner_error.backtrace
+              end              
+              
+            end
+            
+            def expression_to_sql(clause, value, collector)
+              qualify_columns = @loader.qualify_columns?
+              
+              case clause
+              when Symbol::Operator then
+                operator = case clause.type
+                when :gt then '>'
+                when :gte then '>='
+                when :lt then '<'
+                when :lte then '<='
+                when :not then inequality_operator(value)
+                when :eql then equality_operator(value)
+                when :like then equality_operator(value, 'LIKE')
+                when :in then equality_operator(value)
+                else raise ArgumentError.new('Operator type not supported')
+                end
+                collector << ["#{primary_class_table[clause].to_sql(qualify_columns)} #{operator} ?", value]
+              when Symbol then
+                collector << ["#{primary_class_table[clause].to_sql(qualify_columns)} #{equality_operator(value)} ?", value]
+              when String then
+                collector << [clause, value]
+              when Mappings::Column then
+                collector << ["#{clause.to_sql(qualify_columns)} #{equality_operator(value)} ?", value]
+              else raise "CAN HAS CRASH? #{clause.inspect}"
               end
+            rescue => e
+              raise ConditionsError.new(clause, value, e)
+            end
+            
+            def equality_operator(value, default = '=')
+              case value
+              when NilClass then 'IS'
+              when Array then 'IN'
+              else default
+              end
+            end
+            
+            def inequality_operator(value, default = '<>')
+              case value
+              when NilClass then 'IS NOT'
+              when Array then 'NOT IN'
+              else default
+              end
+            end
+            
+            def parse_conditions(conditions_hash)
+              collection = []
               
-              if invalid_keys
-                invalid_keys = implicit_conditions.select do |k,v|
-                  table[k.to_sym].nil?
+              case x = conditions_hash.delete(:conditions)
+              when Array then
+                clause = x.shift
+                expression_to_sql(clause, x, collection)
+              when Hash then
+                x.each_pair do |key,value|
+                  expression_to_sql(key, value, collection)
                 end
-                
-                raise "Invalid options: #{invalid_keys.inspect}" unless invalid_keys.nil?
               else
-                implicit_conditions
+                raise "Unable to parse conditions: #{x.inspect}" if x
+              end
+              
+              conditions_hash.each_pair do |key,value|
+                expression_to_sql(key, value, collection)
               end
+              
+              collection              
+            end
+            
+            def primary_class_table
+              @primary_class_table || (@primary_class_table = @loader.send(:primary_class_table))
             end
-          end
-      
-          def empty?
-            !@loader.options.has_key?(:conditions) && implicits.empty? 
-          end
-      
-          def to_a
-            normalized_conditions
-          end
         end
     
       end

data/lib/data_mapper/adapters/sql/commands/load_command.rb

@@ -1,4 +1,5 @@
-require File.dirname(__FILE__) + '/conditions'
+require 'data_mapper/adapters/sql/commands/conditions'
+require 'data_mapper/adapters/sql/commands/loader'
 
 module DataMapper
   module Adapters
@@ -7,287 +8,289 @@ module DataMapper
     
         class LoadCommand
       
-          attr_reader :klass, :order, :limit, :instance_id, :conditions, :options
+          attr_reader :conditions, :session, :options
           
-          def initialize(adapter, session, klass, options)
-            @adapter, @session, @klass, @options = adapter, session, klass, options
+          def initialize(adapter, session, primary_class, options = {})
+            @adapter, @session, @primary_class = adapter, session, primary_class
+            
+            @options, conditions_hash = partition_options(options)
             
             @order = @options[:order]
             @limit = @options[:limit]
+            @offset = @options[:offset]
             @reload = @options[:reload]
-            @instance_id = @options[:id]
-            @conditions = Conditions.new(@adapter, self)
+            @instance_id = conditions_hash[:id]
+            @conditions = Conditions.new(@adapter, self, conditions_hash)
+            @loaders = Hash.new { |h,k| h[k] = Loader.new(self, k) }
+          end
+          
+          # Display an overview of load options at a glance.          
+          def inspect
+            <<-EOS.compress_lines % (object_id * 2)
+              #<#{self.class.name}:0x%x
+                @database=#{@adapter.name}
+                @reload=#{@reload.inspect}
+                @order=#{@order.inspect}
+                @limit=#{@limit.inspect}
+                @offset=#{@offset.inspect}
+                @options=#{@options.inspect}>
+            EOS
+          end
+                              
+          # Access the Conditions instance
+          def conditions
+            @conditions
           end
           
+          # If +true+ then force the command to reload any objects
+          # already existing in the IdentityMap when executing.
           def reload?
             @reload
           end
-
-          def escape(conditions)
-            @adapter.escape(conditions)
-          end
-      
-          def inspect
-            @options.inspect
+          
+          # Determine if there is a limitation on the number of
+          # instances returned in the results. If +nil+, no limit
+          # is set. Can be used in conjunction with #offset for
+          # paging through a set of results.
+          def limit
+            @limit
           end
-      
-          def include?(association_name)
-            return false if includes.empty?
-            includes.include?(association_name)
+          
+          # Used in conjunction with #limit to page through a set
+          # of results.
+          def offset
+            @offset
           end
-      
-          def includes
-            @includes || @includes = begin
-              list = @options[:include] || []
-              list.kind_of?(Array) ? list : [list]
-              list
+          
+          def call
+            
+            # Check to see if the query is for a specific id and return if found
+            #
+            # NOTE: If the :id option is an Array:
+            # We could search for loaded instance ids and reject from
+            # the Array for already loaded instances, but working under the
+            # assumption that we'll probably have to issue a query to find
+            # at-least some of the instances we're looking for, it's faster to
+            # just skip that and go straight for the query.
+            unless reload? || @instance_id.blank? || @instance_id.is_a?(Array)
+              # If the id is for only a single record, attempt to find it.
+              if instance = @session.identity_map.get(@primary_class, @instance_id)
+                return instance
+              end
             end
-          end
-      
-          def select
-            @select_columns || @select_columns = begin
-              select_columns = @options[:select]
-              unless select_columns.nil?
-                select_columns = select_columns.kind_of?(Array) ? select_columns : [select_columns]
-                select_columns.map { |column| @adapter.quote_column_name(column.to_s) }
+            
+            results = []
+            
+            # Execute the statement and load the objects.
+            @adapter.execute(*to_parameterized_sql) do |reader, num_rows|
+              if @options.has_key?(:intercept_load)
+                load(reader, &@options[:intercept_load])
               else
-                @options[:select] = @adapter[klass].columns.select do |column|
-                  include?(column.name) || !column.lazy?
-                end.map { |column| column.to_sql }
+                load(reader)
               end
             end
-          end
-      
-          def table_name
-            @table_name || @table_name = if @options.has_key?(:table)
-              @adapter.quote_table_name(@options[:table])
+            
+            results += @loaders[@primary_class].loaded_set
+            
+            if @limit == 1 || (@instance_id && !@instance_id.is_a?(Array))
+              results.first
             else
-              @adapter[klass].to_sql
+              results
             end
           end
           
-          def to_sql            
-            sql = 'SELECT ' << select.join(', ') << ' FROM ' << table_name
-        
-            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
+          def load(reader)          
+            # The following blocks are identical aside from the yield.
+            # It's written this way to avoid a conditional within each
+            # iterator, and to take advantage of the performance of
+            # yield vs. Proc#call.
+            if block_given?
+              reader.each do
+                @loaders.each_pair do |klass,loader|
+                  row = reader.current_row
+                  yield(loader.materialize(row), @columns, row)
+                end
+              end
+            else
+              reader.each do
+                @loaders.each_pair do |klass,loader|
+                  loader.materialize(reader.current_row)
+                end
+              end
             end
-        
-            return sql
           end
           
-          def call            
-            if instance_id && !reload?
-              if instance_id.kind_of?(Array)
-                instances = instance_id.map do |id|
-                  @session.identity_map.get(klass, id)
-                end.compact
-              
-                return instances if instances.size == instance_id.size
-              else
-                instance = @session.identity_map.get(klass, instance_id)
-                return instance unless instance.nil?
-              end
+          # Generate a select statement based on the initialization
+          # arguments.
+          def to_parameterized_sql
+            parameters = []
+            
+            sql = 'SELECT ' << columns_for_select.join(', ')
+            sql << ' FROM ' << from_table_name            
+            
+            included_associations.each do |association|
+              sql << ' ' << association.to_sql
             end
-          
-            reader = execute(to_sql)
-          
-            results = if eof?(reader)
-              nil
-            elsif limit == 1 || ( instance_id && !instance_id.kind_of?(Array) )
-              fetch_one(reader)
-            else
-              fetch_all(reader)
+            
+            shallow_included_associations.each do |association|
+              sql << ' ' << association.to_shallow_sql
             end
             
-            close_reader(reader)
+            unless conditions.empty?
+              where_clause, *parameters = conditions.to_parameterized_sql
+              sql << ' WHERE ' << where_clause
+            end
             
-            return results
-          end
-
-          def load(hash, set = [])
-
-            instance_class = unless hash['type'].nil?
-              Kernel::const_get(hash['type'])
-            else
-              klass
+            unless @order.nil?
+              sql << ' ORDER BY ' << @order.to_s
             end
-
-            mapping = @adapter[instance_class]
-
-            instance_id = mapping.key.type_cast_value(hash['id'])   
-            instance = @session.identity_map.get(instance_class, instance_id)
-
-            if instance.nil? || 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.instance_variable_set(:@__key, instance_id)
-              
-              instance.class.callbacks.execute(:after_materialize, instance)
-
-              @session.identity_map.set(instance)
+        
+            unless @limit.nil?
+              sql << ' LIMIT ' << @limit.to_s
             end
-
-            instance.instance_variable_set(:@loaded_set, set)
-            instance.session = @session
-            set << instance
-            return instance
-          end
-          
-          def load_instances(fields, rows)            
-            table = @adapter[klass]
             
-            set = []
-            columns = {}
-            key_ordinal = nil
-            key_column = table.key
-            type_ordinal = nil
-            type_column = nil
-            
-            fields.each_with_index do |field, i|
-              column = table.find_by_column_name(field.to_sym)
-              key_ordinal = i if column.key?
-              type_ordinal, type_column = i, column if column.name == :type
-              columns[column] = i
+            unless @offset.nil?
+              sql << ' OFFSET ' << @offset.to_s
             end
             
-            if type_ordinal
-              
-              tables = Hash.new() do |h,k|
-                
-                table_for_row = @adapter[k.blank? ? klass : type_column.type_cast_value(k)]
-                key_ordinal_for_row = nil
-                columns_for_row = {}
+            parameters.unshift(sql)
+          end
+          
+          def qualify_columns?
+            return @qualify_columns unless @qualify_columns.nil?
+            @qualify_columns = !(included_associations.empty? && shallow_included_associations.empty?)
+          end
+          
+          private            
+            # Return the Sql-escaped columns names to be selected in the results.
+            def columns_for_select
+              @columns_for_select || begin
+                qualify_columns = qualify_columns?
+                @columns_for_select = []
                 
-                fields.each_with_index do |field, i|
-                  column = table_for_row.find_by_column_name(field.to_sym)
-                  key_ordinal_for_row = i if column.key?
-                  columns_for_row[column] = i
+                columns.each_with_index do |column,i|
+                  class_for_loader = column.table.klass
+                  @loaders[class_for_loader].add_column(column, i) if class_for_loader
+                  @columns_for_select << column.to_sql(qualify_columns)
                 end
                 
-                h[k] = [ table_for_row.klass, table_for_row.key, key_ordinal_for_row, columns_for_row ]
+                @columns_for_select
               end
               
-              rows.each do |row|
-                klass_for_row, key_column_for_row, key_ordinal_for_row, columns_for_row = *tables[row[type_ordinal]]
+            end
+            
+            # Returns the DataMapper::Adapters::Sql::Mappings::Column instances to
+            # be selected in the results.
+            def columns
+              @columns || begin
+                @columns = primary_class_columns
+                @columns += included_columns
                 
-                load_instance(
-                  create_instance(
-                    klass_for_row,
-                    key_column_for_row.type_cast_value(row[key_ordinal_for_row])
-                  ),
-                  columns_for_row,
-                  row,
-                  set
-                )
-              end
-            else
-              rows.each do |row|
-                load_instance(
-                  create_instance(
-                    klass,
-                    key_column.type_cast_value(row[key_ordinal])
-                  ),
-                  columns,
-                  row,
-                  set
-                )
+                included_associations.each do |assoc|
+                  @columns += assoc.association_columns
+                end
+                
+                shallow_included_associations.each do |assoc|
+                  @columns += assoc.join_columns
+                end
+                
+                @columns
               end
             end
             
-            set.dup
-          end
-          
-          # Create an instance for the specified Class and id in
-          # preparation for loading. This method first checks to
-          # see if the instance is in the IdentityMap.
-          # If not, then a new class is created, it's marked as
-          # not-new, the key is set and it's added to the IdentityMap.
-          # Afterwards the instance's Session is updated to the current
-          # session, and the instance returned.
-          def create_instance(instance_class, instance_id)
-            instance = @session.identity_map.get(instance_class, instance_id)
-            
-            if instance.nil? || reload?
-              instance = instance_class.new()
-              instance.instance_variable_set(:@__key, instance_id)
-              instance.instance_variable_set(:@new_record, false)
-              @session.identity_map.set(instance)
+            # Returns the default columns for the primary_class_table,
+            # or maps symbols specified in a +:select+ option to columns
+            # in the primary_class_table.
+            def primary_class_columns
+              @primary_class_columns || @primary_class_columns = begin
+                if @options.has_key?(:select)
+                  case x = @options[:select]
+                  when Array then x
+                  when Symbol then [x]
+                  else raise ':select option must be a Symbol, or an Array of Symbols'
+                  end.map { |name| primary_class_table[name] }
+                else
+                  primary_class_table.columns.reject { |column| column.lazy? }
+                end
+              end
             end
             
-            instance.session = @session
-            
-            return instance
-          end
-          
-          def load_instance(instance, columns, values, set = [])
+            def included_associations
+              @included_associations || @included_associations = begin
+                associations = primary_class_table.associations
+                include_options.map do |name|
+                  associations[name]
+                end.compact
+              end
+            end
             
-            instance.class.callbacks.execute(:before_materialize, instance)
+            def shallow_included_associations
+              @shallow_included_associations || @shallow_included_associations = begin
+                associations = primary_class_table.associations
+                shallow_include_options.map do |name|
+                  associations[name]
+                end.compact
+              end
+            end
             
-            hashes = {}
+            def included_columns
+              @included_columns || @included_columns = begin
+                include_options.map do |name|
+                  primary_class_table[name]
+                end.compact
+              end
+            end
             
-            columns.each_pair do |column, i|
-              hashes[column.name] = instance.instance_variable_set(
-                column.instance_variable_name,
-                column.type_cast_value(values[i])
-              ).hash
+            def include_options
+              @include_options || @include_options = begin
+                case x = @options[:include]
+                when Array then x
+                when Symbol then [x]
+                else []
+                end
+              end
             end
             
-            instance.instance_variable_set(:@original_hashes, hashes)
+            def shallow_include_options
+              @shallow_include_options || @shallow_include_options = begin
+                case x = @options[:shallow_include]
+                when Array then x
+                when Symbol then [x]
+                else []
+                end
+              end
+            end
             
-            instance.instance_variable_set(:@loaded_set, set)
-            set << instance
+            # Determine if a Column should be included based on the
+            # value of the +:include+ option.
+            def include_column?(name)
+              !primary_class_table[name].lazy? || include_options.includes?(name)
+            end
+
+            # Return the Sql-escaped table name of the +primary_class+.
+            def from_table_name
+              @from_table_name || (@from_table_name = @adapter.table(@primary_class).to_sql)
+            end
             
-            instance.class.callbacks.execute(:after_materialize, instance)
+            # Returns the DataMapper::Adapters::Sql::Mappings::Table for the +primary_class+.
+            def primary_class_table
+              @primary_class_table || (@primary_class_table = @adapter.table(@primary_class))
+            end
             
-            return instance
-          end
-
-          protected
-          def count_rows(reader)
-            raise NotImplementedError.new
-          end
-
-          def close_reader(reader)
-            raise NotImplementedError.new
-          end
-
-          def execute(sql)
-            raise NotImplementedError.new
-          end
-
-          def fetch_one(reader)
-            raise NotImplementedError.new
-          end
-
-          def fetch_all(reader)
-            raise NotImplementedError.new
-          end
+            def partition_options(options)
+              find_options = @adapter.class::FIND_OPTIONS
+              conditions_hash = {}
+              options_hash = {}
+              options.each do |key,value|
+                if key != :conditions && find_options.include?(key)
+                  options_hash[key] = value
+                else
+                  conditions_hash[key] = value
+                end
+              end
+              
+              [ options_hash, conditions_hash ]
+            end
           
         end # class LoadCommand
       end # module Commands