datamapper 0.1.1 → 0.2.0

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

@@ -0,0 +1,99 @@
+module DataMapper
+  module Adapters
+    module Sql
+      module Commands
+        
+        class Loader
+          
+          def initialize(load_command, klass)
+            @load_command, @klass = load_command, klass
+            @columns = {}
+            @key = nil
+            @key_index = nil
+            @type_override_present = false
+            @type_override_index = nil
+            @type_override = nil
+            @session = load_command.session
+            @reload = load_command.reload?
+            @set = []
+          end
+          
+          def add_column(column, index)
+            if column.key?
+              @key = column 
+              @key_index = index
+            end
+            
+            if column.type == :class
+              @type_override_present = true
+              @type_override_index = index
+              @type_override = column
+            end
+            
+            @columns[index] = column
+          
+            self
+          end
+          
+          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
+              
+            @klass.callbacks.execute(:before_materialize, instance)
+            
+            original_hashes = instance.original_hashes
+            
+            @columns.each_pair do |index, column|
+              # This may be a little confusing, but we're
+              # setting both the original-hash 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(
+                column.instance_variable_name,
+                column.type_cast_value(values[index])
+              ).hash
+            end
+            
+            instance.instance_variable_set(:@loaded_set, @set)
+            @set << instance
+            
+            @klass.callbacks.execute(:after_materialize, instance)
+            
+            return instance
+          end
+          
+          def loaded_set
+            @set
+          end
+          
+          private
+          
+            def create_instance(instance_id, instance_type = @klass)
+              instance = @session.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)
+              elsif instance.new_record?
+                instance.instance_variable_set(:@__key, instance_id)
+                instance.instance_variable_set(:@new_record, false)
+              end
+
+              instance.session = @session
+
+              return instance
+            end
+          
+        end
+        
+      end # module Commands
+    end # module Sql
+  end # module Adapters
+end # module DataMapper

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

@@ -0,0 +1,30 @@
+module DataMapper
+  module Adapters
+    module Sql
+      module Mappings
+        
+        class AssociationsSet
+          
+          include Enumerable
+          
+          def initialize
+            @set = {}
+          end
+          
+          def <<(association)
+            @set[association.name] = association            
+          end
+          
+          def [](name)
+            @set[name]
+          end
+          
+          def each
+            @set.each { |name, association| yield(association) }
+          end
+        end
+        
+      end # module Mappings
+    end # module Sql
+  end # module Adapters
+end # module DataMapper

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

@@ -7,13 +7,19 @@ module DataMapper
         # Ordinal, Length/Size, Nullability are just a few.
         class Column
     
-          attr_accessor :name, :type, :options
+          attr_accessor :table, :name, :type, :options
     
           def initialize(adapter, table, name, type, options = {})
             @adapter = adapter
             @table = table
             @name, @type, @options = name.to_sym, type, options
             
+            @key = (@options[:key] == 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)
+            @default = @options[:default]
+            
             (class << self; self end).class_eval <<-EOS
               def type_cast_value(value)
                 @adapter.type_cast_#{type}(value)
@@ -22,24 +28,32 @@ module DataMapper
           end
     
           def lazy=(value)
-            @options[:lazy] = value
+            @lazy = value
           end
     
           # Determines if the field should be lazy loaded.
           # You can set this explicitly, or accept the default,
           # which is false for all but text fields.
           def lazy?
-            @options[:lazy] || (type == :text)
+            @lazy
           end
       
           def nullable?
-            @options[:nullable] || true
+            @nullable
           end
       
           def key?
-            @options[:key] || false
+            @key
           end
-    
+          
+          def serial?
+            @serial
+          end
+          
+          def default
+            @default
+          end
+          
           def to_sym
             @name
           end
@@ -82,6 +96,54 @@ module DataMapper
           def inspect
             "#<%s:0x%x @name=%s, @type=%s, @options=%s>" % [self.class.name, (object_id * 2), to_sql, type.inspect, options.inspect]
           end
+          
+          def to_long_form
+            @to_long_form || begin
+              @to_long_form = "#{to_sql} #{type_declaration}"
+              
+              unless nullable? || not_null_declaration.blank?
+                @to_long_form << " #{not_null_declaration}"
+              end
+              
+              if key? && !primary_key_declaration.blank?
+                @to_long_form << " #{primary_key_declaration}"
+              end
+              
+              if serial? && !serial_declaration.blank?
+                @to_long_form << " #{serial_declaration}"
+              end
+              
+              if default && !default_declaration.blank?
+                @to_long_form << " #{default_declaration}"
+              end
+        
+              @to_long_form
+            end
+          end
+          
+          private
+          
+          def primary_key_declaration
+            "PRIMARY KEY"
+          end
+          
+          def type_declaration
+            sql = "#{@adapter.class::TYPES[type] || type}"
+            sql << "(#{size})" unless size.nil?
+            sql
+          end
+          
+          def not_null_declaration
+            "NOT NULL"
+          end
+          
+          def serial_declaration
+            "AUTO_INCREMENT"
+          end
+          
+          def default_declaration
+            "DEFAULT #{default}"
+          end
       
         end
     

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

@@ -7,11 +7,14 @@ module DataMapper
     
         class Schema
     
-          def initialize(adapter)
+          attr_reader :name
+          
+          def initialize(adapter, database_name)
+            @name = database_name
             @adapter = adapter
-            @tables = Hash.new { |h,k| h[k] = Table.new(@adapter, k) }
+            @tables = Hash.new { |h,k| h[k] = adapter.class::Mappings::Table.new(@adapter, k) }
           end
-
+          
           def [](klass)
             @tables[klass]
           end

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

@@ -1,4 +1,5 @@
 require File.dirname(__FILE__) + '/column'
+require File.dirname(__FILE__) + '/associations_set'
 
 module DataMapper
   module Adapters
@@ -7,47 +8,41 @@ module DataMapper
     
         class Table
       
-          class Association
-            def initialize(association_name, constant_name)
-              @association_name, @constant_name = association_name, constant_name
-            end
-            
-            def name
-              @association_name
-            end
-            
-            def constant
-              @constant || @constant = begin
-                Object.const_get(@constant_name)
-              end
-            end
+          attr_reader :klass, :name
+      
+          def initialize(adapter, klass_or_name)
+            raise "\"klass_or_name\" must not be nil!" if klass_or_name.nil?
             
-          end
+            @klass = klass_or_name.kind_of?(String) ? nil : klass_or_name
+            @klass_or_name = klass_or_name
             
-          attr_reader :klass
-      
-          def initialize(adapter, setup_klass)
-            raise "\"setup_klass\" must not be nil!" if setup_klass.nil?
             @adapter = adapter
-            @klass = setup_klass
             @columns = []
             @columns_hash = Hash.new { |h,k| h[k] = @columns.find { |c| c.name == k } }
             @columns_by_column_name = Hash.new { |h,k| h[k.to_s] = @columns.find { |c| c.column_name == k.to_s } }
-            @has_many = []
-            @associations = []
+            
+            @associations = AssociationsSet.new
+            
+            @multi_class = false
+            
+            if @klass && @klass.ancestors.include?(DataMapper::Base) && @klass.superclass != DataMapper::Base
+              @adapter.table(@klass.superclass).columns.each do |column|
+                self.add_column(column.name, column.type, column.options)
+              end
+            end
+          end
+          
+          def multi_class?
+            @multi_class
           end
           
           def associations
             @associations
           end
-      
-          # def has_many(association_name, options)
-          #   @associtaions << Association.new(association_name, Inflector.classify(Inflector.singularize(association_name.to_s)))
-          # end
           
-          # def has_many_associations
-          #   @has_many
-          # end
+          def reflect_columns
+            @adapter.reflect_columns(self)
+          end
           
           def columns
             key if @key.nil?
@@ -59,11 +54,14 @@ module DataMapper
           end
           
           def drop!
-            @adapter.delete(@klass, :drop => true) if exists?
+            @adapter.drop(database, self) if exists?
           end
           
-          def create!
-            @adapter.save(database, @klass) unless exists?
+          def create!(force = false)
+            unless exists? || force
+              drop! if force
+              @adapter.create_table(self)
+            end
           end
       
           def key
@@ -86,8 +84,9 @@ module DataMapper
         
             if column.nil?
               reset_derived_columns!
-              column = Column.new(@adapter, self, column_name, type, options)
+              column = @adapter.class::Mappings::Column.new(@adapter, self, column_name, type, options)
               @columns.send(column_name == :id ? :unshift : :push, column)
+              @multi_class = true if column_name == :type
             end
         
             return column
@@ -103,13 +102,18 @@ module DataMapper
           end
       
           def name
-            @name || begin
-              @name = if @klass.superclass != DataMapper::Base && @klass.superclass != Object
-                @adapter[@klass.superclass].name
+            @name || @name = if @klass_or_name.kind_of?(String)
+              @klass_or_name
+            elsif @klass_or_name.kind_of?(Class)
+              if @klass_or_name.superclass != DataMapper::Base \
+                && @klass_or_name.ancestors.include?(DataMapper::Base)
+                @adapter.table(@klass_or_name.superclass).name
               else
-                Inflector.tableize(@klass.name)
-              end.freeze
-            end
+                Inflector.tableize(@klass_or_name.name)
+              end
+            else
+              raise "+klass_or_name+ (#{@klass_or_name.inspect}) must be a Class or a string containing the name of a table"
+            end.freeze
           end
       
           def name=(value)
@@ -117,15 +121,40 @@ module DataMapper
           end
       
           def default_foreign_key
-            @default_foreign_key || (@default_foreign_key = "#{String::memoized_underscore(Inflector.singularize(name))}_id".freeze)
+            @default_foreign_key || (@default_foreign_key = "#{Inflector.underscore(Inflector.singularize(name))}_id".freeze)
           end
       
           def to_sql
-            @to_sql || (@to_sql = @adapter.quote_table_name(name).freeze)
+            @to_sql || @to_sql = quote_table.freeze
+          end
+          
+          def to_create_table_sql
+            @to_create_table_sql || @to_create_table_sql = begin
+              "CREATE TABLE #{to_sql} (#{columns.map { |c| c.to_long_form }.join(', ')})"
+            end
+          end
+          
+          def to_exists_sql
+            @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_SCHEMA = #{@adapter.quote_value(@adapter.schema.name)}
+            EOS
+          end
+          
+          def quote_table
+            @adapter.quote_table_name(name)
           end
       
           def inspect
-            "#<%s:0x%x @klass=%s, @name=%s, @columns=%s>" % [self.class.name, (object_id * 2), @klass.name, to_sql, @columns.inspect]
+            "#<%s:0x%x @klass=%s, @name=%s, @columns=%s>" % [
+              self.class.name,
+              (object_id * 2),
+              klass.inspect,
+              to_sql,
+              @columns.inspect
+            ]
           end
       
           private

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

@@ -26,9 +26,15 @@ module DataMapper
             when String then "'#{value.gsub("'", "''")}'"
             when Class then "'#{value.name}'"
             when Date then "'#{value.to_s}'"
-            when Time, DateTime then "'#{value.strftime("%Y-%m-%d %H:%M:%S")}'"
+            when Time, DateTime then "'#{value.utc.strftime("%Y-%m-%d %H:%M:%S")}'"
             when TrueClass, FalseClass then value.to_s.upcase
-            else raise "Don't know how to quote #{value.inspect}"
+            when Array then "(#{value.map { |entry| quote_value(entry) }.join(', ')})"
+            else 
+              if value.respond_to?(:to_sql)
+                value.to_sql
+              else
+                raise "Don't know how to quote #{value.inspect}"
+              end
           end
         end