datamapper 0.2.3 → 0.2.4

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

@@ -14,8 +14,8 @@ module DataMapper
         class CoersionError < StandardError
         end
         
-        TRUE_ALIASES = ['true'.freeze, 'TRUE'.freeze, '1'.freeze]
-        FALSE_ALIASES = [nil, '0'.freeze]
+        TRUE_ALIASES = ['true'.freeze, 'TRUE'.freeze, '1'.freeze, 1]
+        FALSE_ALIASES = [nil, '0'.freeze, 0]
         
         def self.included(base)
           base.const_set('TRUE_ALIASES', TRUE_ALIASES.dup)
@@ -27,20 +27,20 @@ module DataMapper
             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 #{value.inspect} to a boolean"
+            else "Can't type-cast #{raw_value.inspect} to a boolean"
           end
         end
         
         def type_cast_string(raw_value)
           return nil if raw_value.blank?
           # type-cast values should be immutable for memory conservation
-          raw_value.freeze
+          raw_value
         end
         
         def type_cast_text(raw_value)
           return nil if raw_value.blank?
           # type-cast values should be immutable for memory conservation
-          raw_value.freeze
+          raw_value
         end
         
         def type_cast_class(raw_value)
@@ -75,9 +75,10 @@ module DataMapper
           return nil if raw_value.blank?
           
           case raw_value
-            when DateTime then raw_value.freeze
-            when Date then DateTime.new(raw_value)
-            when String then DateTime::parse(raw_value)
+            when "0000-00-00 00:00:00" then nil
+            when DateTime then raw_value
+            when Date then DateTime.new(raw_value) rescue nil
+            when String then DateTime::parse(raw_value) rescue nil
             else raise CoersionError.new("Can't type-cast #{raw_value.inspect} to a datetime")
           end
         end
@@ -86,13 +87,23 @@ module DataMapper
           return nil if raw_value.blank?
           
           case raw_value
-            when Date then raw_value.freeze
+            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
         
+        def type_cast_object(raw_value)
+          return nil if raw_value.blank?
+
+          begin
+            YAML.load(raw_value)
+          rescue
+            raise CoersionError.new("Can't type-cast #{raw_value.inspect} to an object")
+          end
+        end
+        
         def type_cast_value(type, raw_value)
           return nil if raw_value.blank?
           
@@ -106,6 +117,7 @@ module DataMapper
           when :float then type_cast_float(raw_value)
           when :datetime then type_cast_datetime(raw_value)
           when :date then type_cast_date(raw_value)
+          when :object then type_cast_object(raw_value)
           else
             if respond_to?("type_cast_#{type}")
               send("type_cast_#{type}", raw_value)

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

@@ -15,7 +15,7 @@ module DataMapper
               @type_override_present = false
               @type_override_index = nil
               @type_override = nil
-              @session = load_command.session
+              @database_context = load_command.database_context
               @reload = load_command.reload?
               @set = []
             end
@@ -40,11 +40,13 @@ module DataMapper
             def materialize(values)
 
               instance_id = @key.type_cast_value(values[@key_index])
-              instance = if @type_override_present
-                create_instance(instance_id, @type_override.type_cast_value(values[@type_override_index]))
-              else
-                create_instance(instance_id)
-              end
+              instance = create_instance(instance_id,
+                if @type_override_present
+                  @type_override.type_cast_value(values[@type_override_index]) || @klass
+                else
+                  @klass
+                end
+              )
 
               @klass.callbacks.execute(:before_materialize, instance)
 
@@ -55,10 +57,16 @@ module DataMapper
                 # setting both the original_value, and the
                 # instance-variable through method chaining to avoid
                 # lots of extra short-lived local variables.
-                original_values[column.name] = instance.instance_variable_set(
+                type_cast_value = instance.instance_variable_set(
                   column.instance_variable_name,
                   column.type_cast_value(values[index])
                 )
+                
+                original_values[column.name] = case type_cast_value
+                  when String, Date, Time then type_cast_value.dup
+                  when column.type == :object then Marshal.dump(type_cast_value)
+                  else type_cast_value
+                end
               end
 
               instance.instance_variable_set(:@loaded_set, @set)
@@ -67,6 +75,9 @@ module DataMapper
               @klass.callbacks.execute(:after_materialize, instance)
 
               return instance
+              
+            rescue => e
+              raise MaterializationError.new("Failed to materialize row: #{values.inspect}\n#{e.to_yaml}")
             end
 
             def loaded_set
@@ -74,21 +85,23 @@ module DataMapper
             end
 
             private
-
-              def create_instance(instance_id, instance_type = @klass)
-                instance = @session.identity_map.get(@klass, instance_id)
+              
+              class MaterializationError < StandardError; end
+                
+              def create_instance(instance_id, instance_type)
+                instance = @database_context.identity_map.get(@klass, instance_id)
 
                 if instance.nil? || @reload
                   instance = instance_type.new() if instance.nil?
                   instance.instance_variable_set(:@__key, instance_id)
                   instance.instance_variable_set(:@new_record, false)
-                  @session.identity_map.set(instance)
+                  @database_context.identity_map.set(instance)
                 elsif instance.new_record?
                   instance.instance_variable_set(:@__key, instance_id)
                   instance.instance_variable_set(:@new_record, false)
                 end
 
-                instance.session = @session
+                instance.database_context = @database_context
 
                 return instance
               end
@@ -113,10 +126,10 @@ module DataMapper
 
           end
           
-          attr_reader :conditions, :session, :options
+          attr_reader :conditions, :database_context, :options
           
-          def initialize(adapter, session, primary_class, options = {})
-            @adapter, @session, @primary_class = adapter, session, primary_class
+          def initialize(adapter, database_context, primary_class, options = {})
+            @adapter, @database_context, @primary_class = adapter, database_context, primary_class
             
             # BEGIN: Partion out the options hash into general options,
             # and conditions.
@@ -192,7 +205,7 @@ module DataMapper
             # 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)
+              if instance = @database_context.identity_map.get(@primary_class, @instance_id)
                 return [instance]
               end
             end
@@ -347,7 +360,7 @@ module DataMapper
             when Symbol then
               collector << ["#{primary_class_table[clause].to_sql(qualify_columns)} #{equality_operator(value)} ?", value]
             when String then
-              collector << [clause, value]
+              collector << [clause, *value]
             when Mappings::Column then
               collector << ["#{clause.to_sql(qualify_columns)} #{equality_operator(value)} ?", value]
             else raise "CAN HAS CRASH? #{clause.inspect}"
@@ -382,7 +395,7 @@ module DataMapper
                 @columns += included_columns
                 
                 included_associations.each do |assoc|
-                  @columns += assoc.association_columns
+                  @columns += assoc.associated_columns
                 end
                 
                 shallow_included_associations.each do |assoc|
@@ -486,7 +499,11 @@ module DataMapper
               else
                 raise "Unable to parse conditions: #{x.inspect}" if x
               end
-
+              
+              if primary_class_table.paranoid?
+                conditions_hash[primary_class_table.paranoid_column.name] = nil
+              end
+              
               conditions_hash.each_pair do |key,value|
                 expression_to_sql(key, value, collection)
               end

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

@@ -6,26 +6,37 @@ module DataMapper
         # TODO: There are of course many more options to add here.
         # Ordinal, Length/Size, Nullability are just a few.
         class Column
-    
-          attr_accessor :table, :name, :type, :options
-    
+          
+          attr_reader :type, :name
+          attr_accessor :table, :options
+          
           def initialize(adapter, table, name, type, ordinal, options = {})
             @adapter = adapter
             @table = table
-            @name, @type, @options = name.to_sym, type, options
+            @name, self.type, @options = name.to_sym, type, options
             @ordinal = ordinal
             
-            @key = (@options[:key] == true)
+            @key = @options[:key] == true || @options[:serial] == true
             @nullable = @options.has_key?(:nullable) ? @options[:nullable] : !@key
-            @lazy = @options.has_key?(:lazy) ? @options[:lazy] : @type == :text
-            @serial = (@key == true && @type == :integer && @options[:serial] != false)
+            @lazy = @options.has_key?(:lazy) ? @options[:lazy] : (@type == :text && !@key)
+            @serial = @options[:serial] == true
             @default = @options[:default]
-            
+          end
+          
+          def type=(value)
+            self.flush_sql_caches!
+            @type = value
             (class << self; self end).class_eval <<-EOS
               def type_cast_value(value)
-                @adapter.type_cast_#{type}(value)
+                @adapter.type_cast_#{@type}(value)
               end
             EOS
+            @type
+          end
+          
+          def name=(value)
+            flush_sql_caches!
+            @name = value
           end
           
           def ordinal
@@ -59,6 +70,11 @@ module DataMapper
             @default
           end
           
+          def default=(value)
+            self.flush_sql_caches!
+            @default = value
+          end
+          
           def to_sym
             @name
           end
@@ -91,7 +107,7 @@ module DataMapper
               return @size = @options[:length] if @options.has_key?(:length)
           
               @size = case type
-                when :integer then 4
+                when :integer then 11
                 when :string, :class then 50
                 else nil
               end
@@ -102,6 +118,73 @@ module DataMapper
             "#<%s:0x%x @name=%s, @type=%s, @options=%s>" % [self.class.name, (object_id * 2), to_sql, type.inspect, options.inspect]
           end
           
+          def to_create_sql            
+            "ALTER TABLE " <<  table.to_sql << " ADD " << to_long_form
+          end
+          
+          def to_alter_sql
+            "ALTER TABLE " <<  table.to_sql << " MODIFY COLUMN " << to_long_form
+          end
+          
+          def to_drop_sql
+            "ALTER TABLE " <<  table.to_sql << " DROP COLUMN " << to_sql
+          end
+                  
+          def create!
+            @table.columns << self
+            flush_sql_caches!
+            
+            @adapter.connection do |db|
+              command = db.create_command(to_create_sql)
+              command.execute_non_query
+            end
+            true
+          end
+          
+          def drop!
+            @table.columns.delete(self)
+            flush_sql_caches!
+            
+            @adapter.connection do |db|
+              command = db.create_command(to_drop_sql)
+              command.execute_non_query
+            end
+            true
+          end
+          
+          def alter!
+            flush_sql_caches!
+            @adapter.connection do |db|
+              command = db.create_command(to_alter_sql)
+              command.execute_non_query
+            end
+            true
+          end
+          
+          def rename!(new_name)
+            old_name = name # Store the old_name
+            
+            new_column = @table.add_column(new_name, self.type, self.options)
+            
+            # Create the new column
+            new_column.create!
+            
+            # Copy the data from one column to the other.
+            @adapter.connection do |db|
+              command = db.create_command <<-EOS.compress_lines
+                UPDATE #{@table.to_sql} SET
+                #{new_column.to_sql} = #{to_sql}
+              EOS
+              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
+          end
+          
           def to_long_form
             @to_long_form || begin
               @to_long_form = "#{to_sql} #{type_declaration}"
@@ -110,7 +193,10 @@ module DataMapper
                 @to_long_form << " #{not_null_declaration}"
               end
               
-              if key? && !primary_key_declaration.blank?
+              # NOTE: We only do inline PRIMARY KEY declarations
+              # if the column is also serial since we know
+              # "there can be only one".
+              if key? && serial? && !primary_key_declaration.blank?
                 @to_long_form << " #{primary_key_declaration}"
               end
               
@@ -118,8 +204,8 @@ module DataMapper
                 @to_long_form << " #{serial_declaration}"
               end
               
-              if default && !default_declaration.blank?
-                @to_long_form << " #{default_declaration}"
+              unless default.nil? || (value = default_declaration).blank?
+                @to_long_form << " #{value}"
               end
         
               @to_long_form
@@ -131,14 +217,14 @@ module DataMapper
           end
           
           def hash
-            name.hash
+            @hash || @hash = to_sql(true).hash
           end
           
           def eql?(other)
             name == other.name
           end
           
-          private
+          protected
           
           def primary_key_declaration
             "PRIMARY KEY"
@@ -159,7 +245,15 @@ module DataMapper
           end
           
           def default_declaration
-            "DEFAULT #{default}"
+            @adapter.connection { |db| db.create_command("DEFAULT ?").escape_sql([default]) }
+          end
+          
+          def flush_sql_caches!
+            @to_long_form = nil
+            @to_sql = nil
+            @to_sql_with_table_name = nil
+            @column_name = nil
+            @table.flush_sql_caches!(false)
           end
       
         end
@@ -167,4 +261,4 @@ module DataMapper
       end
     end
   end
-end
+end

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

@@ -24,6 +24,33 @@ module DataMapper
               yield table
             end
           end
+          
+          def delete(table)
+            @tables.delete(table.name)
+          end
+          
+          def <<(table)
+            @tables[table.name] = table
+          end
+
+          def to_tables_sql
+            @to_column_exists_sql || @to_column_exists_sql = <<-EOS.compress_lines
+              SELECT TABLE_NAME
+              FROM INFORMATION_SCHEMA.TABLES
+              WHERE TABLE_SCHEMA LIKE ?
+            EOS
+          end
+          
+          def get_database_tables(schema = "%")
+            tables = []            
+            @adapter.connection do |db|
+              command = db.create_command(to_tables_sql)
+              command.execute_reader(schema) do |reader|
+                tables = reader.map { @adapter.class::Mappings::Table.new(@adapter, reader.item(0)) }
+              end
+            end
+            tables
+          end
     
         end