datamapper 0.2.5 → 0.3.0

data/lib/data_mapper/adapters/mysql_adapter.rb

@@ -17,6 +17,9 @@ module DataMapper
       TRUE_ALIASES << "T".freeze << "\004\bT".freeze
       FALSE_ALIASES << "F".freeze << "\004\bF".freeze
       
+      def empty_insert_sql
+        "() VALUES ()"
+      end
       
       def create_connection
         
@@ -28,6 +31,7 @@ module DataMapper
         builder['password', :password]
         builder['dbname', :database]
         builder['socket', :socket]
+        builder['port', :port]
         
         logger.debug { connection_string.strip }
         

data/lib/data_mapper/adapters/postgresql_adapter.rb

@@ -37,6 +37,7 @@ module DataMapper
         builder['password', :password]
         builder['dbname', :database]
         builder['socket', :socket]
+        builder['port', :port]
         conn = DataObject::Postgres::Connection.new(connection_string.strip)
         conn.logger = self.logger
         conn.open
@@ -239,8 +240,13 @@ module DataMapper
             end
           end
           
+          # size is still required, as length in postgres behaves slightly differently
           def size
-            nil
+            case self.type
+            #strings in postgres can be unlimited length
+            when :string then return (@options.has_key?(:length) || @options.has_key?(:size) ? @size : nil)
+            else nil
+            end
           end
         end # class Column
       end # module Mappings

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

@@ -23,11 +23,12 @@ module DataMapper
         end
         
         def type_cast_boolean(raw_value)
+          return nil if raw_value.nil? || (raw_value.respond_to?(:empty?) && raw_value.empty?)
           case raw_value
             when TrueClass, FalseClass then raw_value
             when *self::class::TRUE_ALIASES then true
             when *self::class::FALSE_ALIASES then false
-            else "Can't type-cast #{raw_value.inspect} to a boolean"
+            else raise CoersionError.new("Can't type-cast #{raw_value.inspect} to a boolean")
           end
         end
         
@@ -45,7 +46,7 @@ module DataMapper
         
         def type_cast_class(raw_value)
           return nil if raw_value.blank?
-          Kernel::const_get(raw_value)
+          Object::recursive_const_get(raw_value)
         end
         
         def type_cast_integer(raw_value)

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

@@ -56,10 +56,14 @@ module DataMapper
                 # setting both the original_value, and the
                 # instance-variable through method chaining to avoid
                 # lots of extra short-lived local variables.
-                type_casted_values[column.name] = instance.instance_variable_set(
-                  column.instance_variable_name,
-                  column.type_cast_value(values[index])
-                )
+                begin
+                  type_casted_values[column.name] = instance.instance_variable_set(
+                    column.instance_variable_name,
+                    column.type_cast_value(values[index])
+                  )
+                rescue => e
+                  raise MaterializationError.new("Failed to materialize column #{column.name.inspect} with value #{values[index].inspect}\n#{e.display}")
+                end
               end
               
               instance.original_values = type_casted_values
@@ -71,7 +75,11 @@ module DataMapper
               return instance
               
             rescue => e
-              raise MaterializationError.new("Failed to materialize row: #{values.inspect}\n#{e.to_yaml}")
+              if e.is_a?(MaterializationError)
+                raise e
+              else
+                raise MaterializationError.new("Failed to materialize row: #{values.inspect}\n#{e.display}")
+              end
             end
 
             def loaded_set
@@ -84,7 +92,7 @@ module DataMapper
                 instance = @database_context.identity_map.get(@klass, instance_id)
 
                 if instance.nil? || @reload
-                  instance = instance_type.new() if instance.nil?
+                  instance = instance_type.allocate() if instance.nil?
                   instance.instance_variable_set(:@__key, instance_id)
                   instance.instance_variable_set(:@new_record, false)
                   @database_context.identity_map.set(instance)
@@ -358,7 +366,11 @@ module DataMapper
             else raise "CAN HAS CRASH? #{clause.inspect}"
             end
           rescue => e
-            raise ConditionsError.new(clause, value, e)
+            if e.is_a?(ConditionsError)
+              raise e
+            else
+              raise ConditionsError.new(clause, value, e)
+            end
           end
           
           private            
@@ -368,10 +380,12 @@ module DataMapper
                 qualify_columns = qualify_columns?
                 @columns_for_select = []
                 
-                columns.each_with_index do |column,i|
+                i = 0
+                columns.each do |column|
                   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)
+                  i += 1
                 end
                 
                 @columns_for_select
@@ -482,8 +496,13 @@ module DataMapper
 
               case x = conditions_hash.delete(:conditions)
               when Array then
-                clause = x.shift
-                expression_to_sql(clause, x, collection)
+                # DO NOT mutate incoming Array values!!!
+                # Otherwise the mutated version may impact all the
+                # way up to the options passed to the finders,
+                # and have unintended side-effects.
+                array_copy = x.dup
+                clause = array_copy.shift
+                expression_to_sql(clause, array_copy, collection)
               when Hash then
                 x.each_pair do |key,value|
                   expression_to_sql(key, value, collection)

data/lib/data_mapper/adapters/sql/mappings/associations_set.rb

@@ -22,6 +22,10 @@ module DataMapper
           def each
             @set.each { |name, association| yield(association) }
           end
+          
+          def empty?
+            @set.empty?
+          end
         end
         
       end # module Mappings

data/lib/data_mapper/adapters/sql/mappings/column.rb

@@ -7,7 +7,7 @@ module DataMapper
         # Ordinal, Length/Size, Nullability are just a few.
         class Column
           attr_reader :type, :name, :ordinal, :size, :default, :check
-          attr_writer :lazy, :index
+          attr_writer :lazy, :index, :unique
           attr_accessor :table, :options
           
           def initialize(adapter, table, name, type, ordinal, options = {})
@@ -15,13 +15,17 @@ module DataMapper
             @table = table
             @name, self.type, @options = name.to_sym, type, options
             @ordinal = ordinal
-            
+            parse_options!
+          end
+          
+          def parse_options!
             @key = @options[:key] == true || @options[:serial] == true
             @nullable = @options.has_key?(:nullable) ? @options[:nullable] : !@key
             @lazy = @options.has_key?(:lazy) ? @options[:lazy] : (@type == :text && !@key)
             @serial = @options[:serial] == true
             @default = @options[:default]
-            @unique = @options.has_value?(:unique)
+            
+            @unique = if @options[:index] == :unique then @options.delete(:index); true else false end
             @index = @options[:index]
             @check = @options[:check] # only for postgresql
             
@@ -36,8 +40,11 @@ module DataMapper
                 else nil
               end
             end
+            @size = @size.last if @size.is_a?(Range)
           end
           
+          def defaulted?() instance_variables.include?("@default") end
+          
           def type=(value)
             self.flush_sql_caches!
             @type = value
@@ -167,7 +174,7 @@ module DataMapper
           def rename!(new_name)
             old_name = name # Store the old_name
             
-            new_column = @table.add_column(new_name, self.type, self.options)
+            new_column = @table.add_column(new_name, self.type, self.options.merge(:ordinal => self.ordinal))
             
             # Create the new column
             new_column.create!
@@ -181,11 +188,8 @@ module DataMapper
               command.execute_non_query
             end
             
-            # Swap column names
-            self.name, new_column.name = new_column.name, self.name
-            # Drop the old column
-            new_column.drop!
-            true
+            self.drop!
+            new_column
           end
           
           def to_long_form

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

@@ -0,0 +1,172 @@
+module DataMapper
+  module Adapters
+    module Sql
+      module Mappings
+        
+        class Conditions
+          def initialize(table, adapter, qualify_columns=false, options={})
+            @table = table
+            @qualify_columns = qualify_columns
+            
+            # BEGIN: Partion out the options hash into general options,
+            # and conditions.
+            standard_find_options = adapter.class::FIND_OPTIONS
+            conditions_hash = {}
+            
+            options.each do |key,value|
+              unless standard_find_options.include?(key) && key != :conditions
+                conditions_hash[key] = value
+              end
+            end
+            # END
+            
+            @conditions = parse_conditions(conditions_hash)
+          end
+        
+          # Generate a statement after 'WHERE' based on the initialization
+          # arguments.
+          def to_params_sql
+            parameters = []
+            sql = ""
+          
+            unless @conditions.empty?
+              sql << ' WHERE ('
+            
+              last_index = @conditions.size
+              current_index = 0
+
+              @conditions.each do |condition|
+                case condition
+                when String then sql << condition
+                when Array then
+                    sql << condition.shift
+                    parameters += condition
+                else
+                  raise "Unable to parse condition: #{condition.inspect}" if condition
+                end
+              
+                if (current_index += 1) == last_index
+                  sql << ')'
+                else
+                  sql << ') AND ('
+                end
+              end
+            end
+            
+            parameters.unshift(sql)
+          end
+        
+          def parse_conditions(conditions_hash)
+            collection = []
+
+            case x = conditions_hash.delete(:conditions)
+            when Array then
+              # DO NOT mutate incoming Array values!!!
+              # Otherwise the mutated version may impact all the
+              # way up to the options passed to the finders,
+              # and have unintended side-effects.
+              array_copy = x.dup
+              clause = array_copy.shift
+              expression_to_sql(clause, array_copy, collection)
+            when Hash then
+              x.each_pair do |key,value|
+                expression_to_sql(key, value, collection)
+              end
+            else
+              raise "Unable to parse conditions: #{x.inspect}" if x
+            end
+            
+            if @table.paranoid?
+              conditions_hash[@table.paranoid_column.name] = nil
+            end
+            
+            conditions_hash.each_pair do |key,value|
+              expression_to_sql(key, value, collection)
+            end
+
+            collection              
+          end
+        
+          # expression_to_sql takes a set of arguments, and turns them into a an
+          # Array of generated SQL, followed by optional Values to interpolate as SQL-Parameters.
+          #
+          # Parameters:
+          # +clause+ The name of the column as a Symbol, a raw-SQL String, a Mappings::Column
+          # instance, or a Symbol::Operator.
+          # +value+ The Value for the condition.
+          # +collector+ An Array representing all conditions that is appended to by expression_to_sql
+          #
+          # Returns: Undefined Output. The work performed is added to the +collector+ argument.
+          # Example:
+          #   conditions = []
+          #   expression_to_sql(:name, 'Bob', conditions)
+          #   => +undefined return value+
+          #   conditions.inspect
+          #   => ["name = ?", 'Bob']
+          def expression_to_sql(clause, value, collector)
+            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
+              #Table[column name] is column.to_sql(true/false based on associations or not)
+              collector << ["#{@table[clause].to_sql(@qualify_columns)} #{operator} ?", value]
+            when Symbol then
+              collector << ["#{@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
+          
+          class ConditionsError < StandardError
+
+            attr_reader :inner_error
+
+            def initialize(clause, value, inner_error)
+              @clause, @value, @inner_error = clause, value, inner_error
+            end
+
+            def message
+              "Conditions (:clause => #{@clause.inspect}, :value => #{@value.inspect}) failed: #{@inner_error}"
+            end
+
+            def backtrace
+              @inner_error.backtrace
+            end              
+
+          end
+                  
+        end
+      end
+    end
+  end
+end

data/lib/data_mapper/adapters/sql/mappings/table.rb

@@ -1,4 +1,5 @@
 require File.dirname(__FILE__) + '/column'
+require File.dirname(__FILE__) + '/conditions'
 require File.dirname(__FILE__) + '/associations_set'
 
 module DataMapper
@@ -45,6 +46,10 @@ module DataMapper
             @schema || @schema = @adapter.schema
           end
           
+          def conditions(args)
+            Conditions.new(self, @adapter, @associations.empty?, args)
+          end
+          
           def paranoid?
             @paranoid
           end
@@ -73,6 +78,12 @@ module DataMapper
             @associations
           end
           
+          def activate_associations!(force = false)
+            @associations.each do |association|
+              association.activate! force
+            end
+          end
+
           def reflect_columns
             @adapter.reflect_columns(self)
           end
@@ -85,6 +96,11 @@ module DataMapper
             
             self.columns
           end
+
+          def mapped_column_exists?(column_name)
+            @columns.each {|column| return true if column.name == column_name}
+            false
+          end
           
           def exists?
             @adapter.connection do |db|
@@ -136,19 +152,22 @@ module DataMapper
           
           def truncate!
             @adapter.connection do |db|
-              result = db.create_command("TRUNCATE TABLE #{to_sql}").execute_non_query
+              result = db.create_command(to_truncate_sql).execute_non_query
               database.identity_map.clear!(name)
               result.to_i > 0
             end
           end
           
-          def count(*args)
-            @adapter.connection do |db|
-              sql = "SELECT COUNT(*) AS row_count FROM #{to_sql}"
-              sql << "WHERE #{args}" unless args.empty?
-              
+          def count(args={})
+            sql = "SELECT COUNT(*) AS row_count FROM #{to_sql}"
+            parameters = []
+            
+            paramsql, *parameters = conditions(args).to_params_sql
+            sql << paramsql #gotta shift it in
+
+            @adapter.connection do |db|              
               command = db.create_command(sql)
-              command.execute_reader do |reader|
+              command.execute_reader(*parameters) do |reader|
                 if reader.has_rows?
                   reader.current_row.first.to_i
                 else
@@ -175,13 +194,17 @@ module DataMapper
             end
           end
           
-          def key            
+          def key
             @key || begin
               @key = @columns.find { |column| column.key? }
               
               if @key.nil?
-                @key = add_column(:id, :integer, :serial => true, :ordinal => -1)
-                @klass.send(:attr_reader, :id) unless @klass.nil? || @klass.methods.include?(:id)
+                unless @klass.nil?
+                  @klass.send(:property, :id, :integer, :serial => true, :ordinal => -1)
+                  @key = self[:id]
+                else
+                  @key = add_column(:id, :integer, :serial => true, :ordinal => -1)
+                end
               end
               
               @key
@@ -269,13 +292,13 @@ module DataMapper
             @custom_name = value
             self.name
           end
-      
+          
           def default_foreign_key
-            @default_foreign_key || (@default_foreign_key = "#{Inflector.underscore(Inflector.singularize(name))}_#{key.name}".freeze)
+            @default_foreign_key ||= Inflector.foreign_key(@klass_or_name, key.name).freeze
           end
       
           def to_sql
-            @to_sql || @to_sql = quote_table.freeze
+            @to_sql ||= quote_table.freeze
           end
           
           def to_s
@@ -343,6 +366,10 @@ module DataMapper
             queries
           end
           
+          def to_truncate_sql
+            "TRUNCATE TABLE #{to_sql}"
+          end
+          
           def to_drop_sql
             @to_drop_sql || @to_drop_sql = "DROP TABLE #{to_sql}"
           end
@@ -399,6 +426,7 @@ module DataMapper
             @to_drop_sql = nil
             @to_sql = nil
             @name = nil
+            @columns_hash.clear
             
             if flush_columns
               @columns.each do |column|
@@ -411,9 +439,7 @@ module DataMapper
           
           def activate!
             @activated = true
-            @associations.each do |association|
-              association.activate!
-            end
+            activate_associations!
           end
           
           def activated?
@@ -430,4 +456,4 @@ module DataMapper
       end
     end
   end
-end
+end