datamapper 0.2.2 → 0.2.3

data/CHANGELOG

@@ -111,8 +111,16 @@
 * BUG: Column copy for STI moved into Table#initialize to better handle STI with multiple mapped databases
 * BUG: before_create callbacks moved in the execution flow since they weren't guaranteed to fire before
 * Threading enhancements: Removed single_threaded_mode, #database block form adjusted for thread-safety
-* BUG: Fixed String#blank? when a multi-line string contained a blank line (thanks pimpmaster!)
+* BUG: Fixed String#blank? when a multi-line string contained a blank line (thanks zapnap!)
 * Performance enhancements: (thanks wycats!)
 
 -- 0.2.2
-* Removed C extension bundles and log files from package
+* Removed C extension bundles and log files from package
+
+-- 0.2.3
+* Added String#t for translation and overrides for default validation messages
+* Give credit where it's due: zapnap, not pimpmaster, submitted the String#blank? patch. My bad. :-(
+* MAJOR: Resolve issue with non-unique-hash values and #dirty?; now frozen original values are stored instead
+* Added Base#update_attributes
+* MAJOR: Queries are now passed to the database drivers in a parameterized fashion
+* Updated PostgreSQL driver and adapter to current

data/environment.rb

@@ -1,6 +1,3 @@
-MERB_ROOT = Dir::pwd
-MERB_ENV = 'development'
-
 # Require the DataMapper, and a Mock Adapter.
 require File.dirname(__FILE__) + '/lib/data_mapper'
 require File.dirname(__FILE__) + '/spec/mock_adapter'

data/lib/data_mapper.rb

@@ -16,6 +16,7 @@ unless defined?(DM_PLUGINS_ROOT)
 end
 
 # Require the basics...
+require 'rubygems'
 require 'yaml'
 require 'set'
 require 'fastthread'
@@ -23,6 +24,7 @@ require 'data_mapper/support/blank'
 require 'data_mapper/support/enumerable'
 require 'data_mapper/support/symbol'
 require 'data_mapper/support/string'
+require 'data_mapper/support/silence'
 require 'data_mapper/support/inflector'
 require 'data_mapper/database'
 require 'data_mapper/base'

data/lib/data_mapper/adapters/abstract_adapter.rb

@@ -29,8 +29,8 @@ module DataMapper
         raise NotImplementedError.new
       end
       
-      def log
-        @configuration.log
+      def logger
+        @logger || @logger = @configuration.logger
       end
       
     end # class AbstractAdapter

data/lib/data_mapper/adapters/data_object_adapter.rb

@@ -64,7 +64,7 @@ module DataMapper
           @connection_pool.hold { |active_connection| yield(active_connection) }
         rescue => execution_error
           # Log error on failure
-          @configuration.log.error(execution_error)
+          logger.error { execution_error }
           
           # Close all open connections, assuming that if one
           # had an error, it's likely due to a lost connection,
@@ -84,7 +84,7 @@ module DataMapper
         rescue => close_connection_error
           # An error on closing the connection is almost expected
           # if the socket is broken.
-          @configuration.log.warn(close_connection_error)
+          logger.warn { close_connection_error }
         end
         
         # Reopen fresh connections.
@@ -95,31 +95,13 @@ module DataMapper
         raise NotImplementedError.new
       end
       
-      def execute(*args)
-        connection do |db|
-          sql = escape_sql(*args)
-          log.debug { sql }
-        
-          command = db.create_command(sql)
-        
-          if block_given?
-            command.execute_reader { |reader| yield(reader) }
-          else
-            command.execute_non_query
-          end
-        end
-      rescue => e
-        handle_error(e)
-      end
-      
       def query(*args)        
         connection do |db|
-          sql = escape_sql(*args)
-          log.debug { sql }
         
-          command = db.create_command(sql)
-        
-          command.execute_reader do |reader|
+          command = db.create_command(args.shift)
+          logger.debug { command.text }
+          
+          command.execute_reader(*args) do |reader|
             fields = reader.fields.map { |field| Inflector.underscore(field).to_sym }
             
             results = []
@@ -150,19 +132,35 @@ module DataMapper
       end
       
       def table_exists?(name)
-        execute(table(name).to_exists_sql) { |reader| reader.has_rows? }
+        connection do |db|
+          table = self.table(name)
+          command = db.create_command(table.to_exists_sql)          
+          command.execute_reader(table.name, table.schema.name) do |reader|
+            reader.has_rows?
+          end
+        end
       end
       
       def truncate(session, name)
-        result = execute("TRUNCATE TABLE #{table(name).to_sql}")
-        session.identity_map.clear!(name)
-        result.to_i > 0
+        connection do |db|
+          result = db.create_command("TRUNCATE TABLE #{table(name).to_sql}").execute_non_query
+          session.identity_map.clear!(name)
+          result.to_i > 0
+        end
       end
       
       def drop(session, name)
-        result = execute("DROP TABLE #{table(name).to_sql}")
-        session.identity_map.clear!(name)
-        true
+        table = self.table(name)
+        
+        if table.exists?
+          connection do |db|
+            result = db.create_command("DROP TABLE #{table.to_sql}").execute_non_query
+            session.identity_map.clear!(name)
+            true
+          end
+        else
+          false
+        end
       end
       
       def create_table(name)
@@ -171,7 +169,10 @@ module DataMapper
         if table.exists?
           false
         else
-          execute(table.to_create_table_sql); true
+          connection do |db|
+            db.create_command(table.to_create_table_sql).execute_non_query
+            true
+          end
         end
       end
       
@@ -179,15 +180,20 @@ module DataMapper
         table = self.table(instance)
         
         if instance.is_a?(Class)
-          execute("DELETE FROM #{table.to_sql}")
+          connection do |db|
+            db.create_command("DELETE FROM #{table.to_sql}").execute_non_query
+          end
           session.identity_map.clear!(instance)
         else
           callback(instance, :before_destroy)
           
-          if execute("DELETE FROM #{table.to_sql} WHERE #{table.key.to_sql} = #{quote_value(instance.key)}").to_i > 0
+          if connection do |db|
+              command = db.create_command("DELETE FROM #{table.to_sql} WHERE #{table.key.to_sql} = ?")
+              command.execute_non_query(instance.key).to_i > 0
+            end # connection do...end # if continued below:
             instance.instance_variable_set(:@new_record, true)
             instance.session = session
-            instance.original_hashes.clear
+            instance.original_values.clear
             session.identity_map.delete(instance)
             callback(instance, :after_destroy)
           end          
@@ -210,7 +216,12 @@ module DataMapper
             attributes = instance.dirty_attributes
             
             unless attributes.empty?
-              attributes[:type] = instance.class.name if table.multi_class?
+              if table.multi_class?
+                instance.instance_variable_set(
+                  table[:type].instance_variable_name,
+                  attributes[:type] = instance.class.name
+                )
+              end
             
               keys = []
               values = []
@@ -220,7 +231,10 @@ module DataMapper
               end
           
               # Formatting is a bit off here, but it looks nicer in the log this way.
-              insert_id = execute("INSERT INTO #{table.to_sql} (#{keys.join(', ')}) VALUES (#{values.map { |v| quote_value(v) }.join(', ')})").last_insert_row
+              insert_id = connection do |db|
+                db.create_command("INSERT INTO #{table.to_sql} (#{keys.join(', ')}) VALUES ?")\
+                  .execute_non_query(values).last_insert_row
+              end
               instance.instance_variable_set(:@new_record, false)
               instance.key = insert_id if table.key.serial? && !attributes.include?(table.key.name)
               session.identity_map.set(instance)
@@ -232,22 +246,28 @@ module DataMapper
             
             table = self.table(instance)
             attributes = instance.dirty_attributes
+            parameters = []
             
             unless attributes.empty?
               sql = "UPDATE " << table.to_sql << " SET "
       
               sql << attributes.map do |key, value|
-                "#{table[key].to_sql} = #{quote_value(value)}"
+                parameters << value
+                "#{table[key].to_sql} = ?"
               end.join(', ')
       
-              sql << " WHERE #{table.key.to_sql} = " << quote_value(instance.key)
-          
-              execute(sql).to_i > 0 && callback(instance, :after_update)
+              sql << " WHERE #{table.key.to_sql} = ?"
+              parameters << instance.key
+              
+              connection do |db|
+                db.create_command(sql).execute_non_query(*parameters).to_i > 0 \
+                && callback(instance, :after_update)
+              end
             end
           end
           
           instance.attributes.each_pair do |name, value|
-            instance.original_hashes[name] = value.hash
+            instance.original_values[name] = value
           end
           
           instance.loaded_associations.each do |association|
@@ -259,7 +279,7 @@ module DataMapper
           result
         end
       rescue => error
-        log.error(error)
+        logger.error(error)
         raise error
       end
       
@@ -284,36 +304,6 @@ module DataMapper
         instance.class.callbacks.execute(callback_name, instance)
       end
       
-      # Escape a string of SQL with a set of arguments.
-      # The first argument is assumed to be the SQL to escape,
-      # the remaining arguments (if any) are assumed to be
-      # values to escape and interpolate.
-      #
-      # ==== Examples
-      #   escape_sql("SELECT * FROM zoos")
-      #   # => "SELECT * FROM zoos"
-      # 
-      #   escape_sql("SELECT * FROM zoos WHERE name = ?", "Dallas")
-      #   # => "SELECT * FROM zoos WHERE name = `Dallas`"
-      #
-      #   escape_sql("SELECT * FROM zoos WHERE name = ? AND acreage > ?", "Dallas", 40)
-      #   # => "SELECT * FROM zoos WHERE name = `Dallas` AND acreage > 40"
-      # 
-      # ==== Warning
-      # This method is meant mostly for adapters that don't support
-      # bind-parameters.
-      def escape_sql(*args)
-        sql = args.shift
-      
-        unless args.empty?
-          sql.gsub!(/\?/) do |x|
-            quote_value(args.shift)
-          end
-        end
-        
-        sql
-      end
-      
       # This callback copies and sub-classes modules and classes
       # in the DoAdapter to the inherited class so you don't
       # have to copy and paste large blocks of code from the

data/lib/data_mapper/adapters/mysql_adapter.rb

@@ -24,27 +24,16 @@ module DataMapper
         builder['dbname', :database]
         builder['socket', :socket]
         
-        log.debug { connection_string.strip }
+        logger.debug { connection_string.strip }
         
         conn = DataObject::Mysql::Connection.new(connection_string.strip)
+        conn.logger = self.logger
         conn.open
         cmd = conn.create_command("SET NAMES UTF8")
         cmd.execute_non_query
         return conn
       end
       
-      def quote_time(value)
-        "DATE('#{value.xmlschema}')"
-      end
-      
-      def quote_datetime(value)
-        "DATE('#{value}')"
-      end
-      
-      def quote_date(value)
-        "DATE('#{value.strftime("%Y-%m-%d")}')"
-      end
-      
       module Mappings
         
         def to_create_table_sql

data/lib/data_mapper/adapters/postgresql_adapter.rb

@@ -28,6 +28,7 @@ module DataMapper
       
       def create_connection
         conn = DataObject::Postgres::Connection.new("dbname=#{@configuration.database}")
+        conn.logger = self.logger
         conn.open
         return conn
              
@@ -75,8 +76,8 @@ module DataMapper
             @to_exists_sql || @to_exists_sql = <<-EOS.compress_lines
               SELECT TABLE_NAME
               FROM INFORMATION_SCHEMA.TABLES
-              WHERE TABLE_NAME = #{@adapter.quote_value(name)}
-                AND TABLE_CATALOG = #{@adapter.quote_value(@adapter.schema.name)}
+              WHERE TABLE_NAME = ?
+                AND TABLE_CATALOG = ?
             EOS
           end
           

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

@@ -33,12 +33,14 @@ module DataMapper
         
         def type_cast_string(raw_value)
           return nil if raw_value.blank?
-          raw_value
+          # type-cast values should be immutable for memory conservation
+          raw_value.freeze
         end
         
         def type_cast_text(raw_value)
           return nil if raw_value.blank?
-          raw_value
+          # type-cast values should be immutable for memory conservation
+          raw_value.freeze
         end
         
         def type_cast_class(raw_value)
@@ -48,13 +50,13 @@ module DataMapper
         
         def type_cast_integer(raw_value)
           return nil if raw_value.blank?
-          raw_value.to_i # Integer(raw_value) would be "safer", but not as fast.
+          raw_value.to_i
         rescue ArgumentError
           nil
         end
         
-        def type_cast_decimal(raw_value) 
-          return nil if raw_value.blank? 
+        def type_cast_decimal(raw_value)
+          return nil if raw_value.blank?
           raw_value.to_d
         rescue ArgumentError 
           nil 
@@ -62,14 +64,18 @@ module DataMapper
                 
         def type_cast_float(raw_value)
           return nil if raw_value.blank?
-          raw_value.to_f
+          case raw_value
+            when Float then raw_value
+            when Numeric, String then raw_value.to_f
+            else CoersionError.new("Can't type-cast #{raw_value.inspect} to a float")
+          end
         end
         
         def type_cast_datetime(raw_value)
           return nil if raw_value.blank?
           
           case raw_value
-            when DateTime then raw_value
+            when DateTime then raw_value.freeze
             when Date then DateTime.new(raw_value)
             when String then DateTime::parse(raw_value)
             else raise CoersionError.new("Can't type-cast #{raw_value.inspect} to a datetime")
@@ -80,7 +86,7 @@ module DataMapper
           return nil if raw_value.blank?
           
           case raw_value
-            when Date then raw_value
+            when Date then raw_value.freeze
             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")
@@ -90,10 +96,22 @@ module DataMapper
         def type_cast_value(type, raw_value)
           return nil if raw_value.blank?
           
-          if respond_to?("type_cast_#{type}")
-            send("type_cast_#{type}", raw_value)
+          case type
+          when :string then type_cast_string(raw_value)
+          when :text then type_cast_text(raw_value)
+          when :boolean then type_cast_boolean(raw_value)
+          when :class then type_cast_class(raw_value)
+          when :integer then type_cast_integer(raw_value)
+          when :decimal then type_cast_decimal(raw_value)
+          when :float then type_cast_float(raw_value)
+          when :datetime then type_cast_datetime(raw_value)
+          when :date then type_cast_date(raw_value)
           else
-            raise "Don't know how to type-cast #{{ type => raw_value }.inspect }"
+            if respond_to?("type_cast_#{type}")
+              send("type_cast_#{type}", raw_value)
+            else
+              raise "Don't know how to type-cast #{{ type => raw_value }.inspect }"
+            end
           end
         end
 

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

@@ -48,17 +48,17 @@ module DataMapper
 
               @klass.callbacks.execute(:before_materialize, instance)
 
-              original_hashes = instance.original_hashes
+              original_values = instance.original_values
 
               @columns.each_pair do |index, column|
                 # This may be a little confusing, but we're
-                # setting both the original-hash value, and the
+                # setting both the original_value, and the
                 # instance-variable through method chaining to avoid
                 # lots of extra short-lived local variables.
-                original_hashes[column.name] = instance.instance_variable_set(
+                original_values[column.name] = instance.instance_variable_set(
                   column.instance_variable_name,
                   column.type_cast_value(values[index])
-                ).hash
+                )
               end
 
               instance.instance_variable_set(:@loaded_set, @set)
@@ -200,11 +200,15 @@ module DataMapper
             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
-                load(reader)
+            @adapter.connection do |db|
+              sql, *parameters = to_parameterized_sql
+              command = db.create_command(sql)
+              command.execute_reader(*parameters) do |reader|
+                if @options.has_key?(:intercept_load)
+                  load(reader, &@options[:intercept_load])
+                else
+                  load(reader)
+                end
               end
             end