datamapper 0.1.0 → 0.1.1

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

@@ -0,0 +1,161 @@
+module DataMapper
+  module Adapters
+    module Sql
+      module Commands
+    
+        class Conditions
+      
+          def initialize(adapter, loader)
+            @adapter, @loader = adapter, loader
+            @has_id = false
+          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
+          end
+      
+          def escape(conditions)
+            clause = conditions.shift
+
+            clause.gsub(/\?/) do |x|
+              # Check if the condition is an in, clause.
+              case conditions.first
+              when Array then
+                '(' << conditions.shift.map { |c| @adapter.quote_value(c) }.join(', ') << ')'
+              when LoadCommand then
+                '(' << conditions.shift.to_sql << ')'
+              else
+                @adapter.quote_value(conditions.shift)
+              end
+            end
+          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)
+              end
+          
+            end
+        
+            return @normalized_conditions          
+          end
+          
+          def table
+            @table || (@table = @adapter[@loader.klass])
+          end
+          
+          def implicits
+            @implicits || @implicits = begin
+              
+              invalid_keys = false
+              
+              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
+              end
+              
+              if invalid_keys
+                invalid_keys = implicit_conditions.select do |k,v|
+                  table[k.to_sym].nil?
+                end
+                
+                raise "Invalid options: #{invalid_keys.inspect}" unless invalid_keys.nil?
+              else
+                implicit_conditions
+              end
+            end
+          end
+      
+          def empty?
+            !@loader.options.has_key?(:conditions) && implicits.empty? 
+          end
+      
+          def to_a
+            normalized_conditions
+          end
+        end
+    
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+module DataMapper
+  module Adapters
+    module Sql
+      module Commands
+    
+        class DeleteCommand
+      
+          def initialize(adapter, klass_or_instance, options = nil)
+            @adapter, @klass_or_instance, @options = adapter, klass_or_instance, options
+          end
+      
+          def truncate?
+            return false if @options.nil?
+            @options[:truncate]
+          end
+          
+          def drop?
+            return false if @options.nil?
+            @options[:drop]
+          end
+          
+          def delete_all?
+            return !truncate? && !drop? && @klass_or_instance.kind_of?(Class)
+          end
+          
+          def klass
+            @klass_or_instance.kind_of?(Class) ? @klass_or_instance : @klass_or_instance.class
+          end
+          
+          def to_truncate_sql
+            "TRUNCATE TABLE " << @adapter[@klass_or_instance].to_sql
+          end
+          
+          def to_drop_sql
+            "DROP TABLE #{@adapter[@klass_or_instance].to_sql}"
+          end
+          
+          def to_delete_sql
+            sql = "DELETE FROM " << @adapter[klass].to_sql
+            sql << " WHERE id = " << @adapter.quote_value(@klass_or_instance.key) unless delete_all?
+            return sql
+          end
+          
+          def to_sql
+            if truncate?
+              to_truncate_sql
+            elsif drop?
+              to_drop_sql
+            else
+              to_delete_sql
+            end
+          end
+          
+          def session
+            return nil if @options.nil?
+            @options[:session]
+          end
+          
+          def call
+            result = nil
+            
+            if truncate?
+              result = execute_truncate(to_sql)
+              session.identity_map.clear!(klass) unless session.nil?
+            elsif drop?
+              result = execute_drop(to_sql)
+              session.identity_map.clear!(klass) unless session.nil?
+            elsif delete_all?
+              result = execute_delete_all(to_sql)
+              session.identity_map.clear!(klass) unless session.nil?
+            else
+              @klass_or_instance.class.callbacks.execute(:before_destroy, @klass_or_instance)
+              
+              result = execute(to_sql)
+              
+              if result
+                @klass_or_instance.instance_variable_set(:@new_record, true)
+                @klass_or_instance.session = session
+                @klass_or_instance.original_hashes.clear
+                session.identity_map.delete(@klass_or_instance) unless session.nil?
+                @klass_or_instance.class.callbacks.execute(:after_destroy, @klass_or_instance)
+              end
+            end
+            
+            return result
+          rescue => error
+            @adapter.log.error(error)
+            raise error
+          end
+          
+          protected
+          def execute_truncate(sql)
+            execute(sql)
+          end
+          
+          def execute_drop(sql)
+            execute(sql)
+          end
+          
+          def execute_delete_all(sql)
+            execute(sql)
+          end
+          
+          def execute(sql)
+            raise NotImplementedError.new
+          end
+          
+        end
+    
+      end
+    end
+  end
+end

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

@@ -0,0 +1,296 @@
+require File.dirname(__FILE__) + '/conditions'
+
+module DataMapper
+  module Adapters
+    module Sql
+      module Commands
+    
+        class LoadCommand
+      
+          attr_reader :klass, :order, :limit, :instance_id, :conditions, :options
+          
+          def initialize(adapter, session, klass, options)
+            @adapter, @session, @klass, @options = adapter, session, klass, options
+            
+            @order = @options[:order]
+            @limit = @options[:limit]
+            @reload = @options[:reload]
+            @instance_id = @options[:id]
+            @conditions = Conditions.new(@adapter, self)
+          end
+          
+          def reload?
+            @reload
+          end
+
+          def escape(conditions)
+            @adapter.escape(conditions)
+          end
+      
+          def inspect
+            @options.inspect
+          end
+      
+          def include?(association_name)
+            return false if includes.empty?
+            includes.include?(association_name)
+          end
+      
+          def includes
+            @includes || @includes = begin
+              list = @options[:include] || []
+              list.kind_of?(Array) ? list : [list]
+              list
+            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) }
+              else
+                @options[:select] = @adapter[klass].columns.select do |column|
+                  include?(column.name) || !column.lazy?
+                end.map { |column| column.to_sql }
+              end
+            end
+          end
+      
+          def table_name
+            @table_name || @table_name = if @options.has_key?(:table)
+              @adapter.quote_table_name(@options[:table])
+            else
+              @adapter[klass].to_sql
+            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
+            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
+            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)
+            end
+            
+            close_reader(reader)
+            
+            return results
+          end
+
+          def load(hash, set = [])
+
+            instance_class = unless hash['type'].nil?
+              Kernel::const_get(hash['type'])
+            else
+              klass
+            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)
+            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
+            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 = {}
+                
+                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
+                end
+                
+                h[k] = [ table_for_row.klass, table_for_row.key, key_ordinal_for_row, columns_for_row ]
+              end
+              
+              rows.each do |row|
+                klass_for_row, key_column_for_row, key_ordinal_for_row, columns_for_row = *tables[row[type_ordinal]]
+                
+                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
+                )
+              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)
+            end
+            
+            instance.session = @session
+            
+            return instance
+          end
+          
+          def load_instance(instance, columns, values, set = [])
+            
+            instance.class.callbacks.execute(:before_materialize, instance)
+            
+            hashes = {}
+            
+            columns.each_pair do |column, i|
+              hashes[column.name] = instance.instance_variable_set(
+                column.instance_variable_name,
+                column.type_cast_value(values[i])
+              ).hash
+            end
+            
+            instance.instance_variable_set(:@original_hashes, hashes)
+            
+            instance.instance_variable_set(:@loaded_set, set)
+            set << instance
+            
+            instance.class.callbacks.execute(:after_materialize, instance)
+            
+            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
+          
+        end # class LoadCommand
+      end # module Commands
+    end # module Sql
+  end # module Adapters
+end # module DataMapper