datamapper 0.2.3 → 0.2.4

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

@@ -17,17 +17,28 @@ module DataMapper
             @klass_or_name = klass_or_name
             
             @adapter = adapter
+            
+            @temporary = false
             @columns = SortedSet.new
             @columns_hash = Hash.new { |h,k| h[k] = columns.find { |c| c.name == k } }
             
             @associations = AssociationsSet.new
             
             @multi_class = false
+            @paranoid = false
+            @paranoid_column = nil
             
             if @klass && @klass.ancestors.include?(DataMapper::Base) && @klass.superclass != DataMapper::Base
-              @adapter.table(@klass.superclass).columns.each do |column|
+              
+              super_table = @adapter.table(@klass.superclass)
+              
+              super_table.columns.each do |column|
                 self.add_column(column.name, column.type, column.options)
               end
+              
+              super_table.associations.each do |association|
+                @associations << association
+              end
             end
           end
           
@@ -35,10 +46,30 @@ module DataMapper
             @schema || @schema = @adapter.schema
           end
           
+          def paranoid?
+            @paranoid
+          end
+          
+          def paranoid_column
+            @paranoid_column
+          end
+          
           def multi_class?
             @multi_class
           end
           
+          def type_column
+            @type_column
+          end
+          
+          def temporary?
+            @temporary
+          end
+          
+          def temporary=(value)
+            @temporary = value
+          end
+          
           def associations
             @associations
           end
@@ -49,35 +80,124 @@ module DataMapper
           
           def columns
             key if @key.nil?
-            @columns
+            class << self
+              attr_reader :columns
+            end
+            
+            self.columns
           end
           
           def exists?
-            @adapter.table_exists?(name)
+            @adapter.connection do |db|
+              command = db.create_command(to_exists_sql)          
+              command.execute_reader(name, schema.name) do |reader|
+                reader.has_rows?
+              end
+            end
           end
           
           def drop!
-            @adapter.drop(database, self)
+            if exists?
+              @adapter.connection do |db|
+                result = db.create_command(to_drop_sql).execute_non_query
+                database.identity_map.clear!(name)
+                schema.delete(self)
+                true
+              end
+            else
+              false
+            end
           end
           
           def create!(force = false)
-            unless exists? || force
-              drop! if force
-              @adapter.create_table(self)
+            if exists?
+              if force
+                drop!
+                create!
+              else
+                false
+              end
+            else
+              @adapter.connection do |db|
+                db.create_command(to_create_sql).execute_non_query
+                schema << self
+                true
+              end
             end
           end
-      
-          def key
+          
+          def delete_all!
+            @adapter.connection do |db|
+              db.create_command("DELETE FROM #{to_sql}").execute_non_query
+            end
+            database.identity_map.clear!(name)
+          end
+          
+          def truncate!
+            @adapter.connection do |db|
+              result = db.create_command("TRUNCATE TABLE #{to_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?
+              
+              command = db.create_command(sql)
+              command.execute_reader do |reader|
+                if reader.has_rows?
+                  reader.current_row.first.to_i
+                else
+                  0
+                end
+              end
+            end
+          end
+          
+          def insert(hash)
+            @adapter.connection do |db|
+              
+              columns_to_insert = []
+              values = []
+              
+              hash.each_pair do |k,v|
+                column = self[k.to_sym]
+                columns_to_insert << (column ? column.to_sql : k)
+                values << v
+              end
+              
+              command = db.create_command("INSERT INTO #{to_sql} (#{columns_to_insert.join(', ')}) VALUES (#{values.map { '?' }.join(', ')})")
+              command.execute_non_query(*values)
+            end
+          end
+          
+          def key            
             @key || begin
               @key = @columns.find { |column| column.key? }
               
               if @key.nil?
-                @key = add_column(:id, :integer, :key => true, :ordinal => -1)
-                @klass.send(:attr_reader, :id) unless @klass.methods.include?(:id)
+                @key = add_column(:id, :integer, :serial => true, :ordinal => -1)
+                @klass.send(:attr_reader, :id) unless @klass.nil? || @klass.methods.include?(:id)
               end
               
               @key
             end
+            
+            class << self
+              attr_accessor :key
+            end
+            Base::dependencies.resolve!
+            
+            self.key
+          end
+          
+          def keys
+            @keys || begin
+              @keys = @columns.select { |column| column.key? }
+            end
           end
       
           def add_column(column_name, type, options)
@@ -91,8 +211,19 @@ module DataMapper
             column = @adapter.class::Mappings::Column.new(@adapter, self, column_name, type, column_ordinal, options)
             @columns << column
             
-            @multi_class = true if column_name == :type
-        
+            if column_name == :type
+              @multi_class = true
+              @type_column = column
+            end
+            
+            if column_name.to_s =~ /^deleted\_(at|on)$/
+              @paranoid = true
+              @paranoid_column = column
+            end
+            
+            self.flush_sql_caches!
+            @columns_hash.clear
+            
             return column
           end
       
@@ -101,36 +232,77 @@ module DataMapper
           end
       
           def 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
+            @name || @name = begin
+              if @custom_name
+                @custom_name
+              elsif @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_or_name.name)
+                end
               else
-                Inflector.tableize(@klass_or_name.name)
+                raise "+klass_or_name+ (#{@klass_or_name.inspect}) must be a Class or a string containing the name of a table"
               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)
-            @name = value
+            flush_sql_caches!
+            @custom_name = value
+            self.name
           end
       
           def default_foreign_key
-            @default_foreign_key || (@default_foreign_key = "#{Inflector.underscore(Inflector.singularize(name))}_id".freeze)
+            @default_foreign_key || (@default_foreign_key = "#{Inflector.underscore(Inflector.singularize(name))}_#{key.name}".freeze)
           end
       
           def to_sql
             @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(', ')})"
+          def to_s
+            name.to_s
+          end
+          
+          def unquote_default(default)
+            default
+          end
+          
+          def get_database_columns
+            columns = []            
+            @adapter.connection do |db|
+              command = db.create_command(to_columns_sql)
+              command.execute_reader(name, schema.name) do |reader|
+                columns = reader.map {
+                  @adapter.class::Mappings::Column.new(@adapter, self, reader.item(1), 
+                  @adapter.class::TYPES.index(reader.item(2)),reader.item(0).to_i,
+                  :nullable => reader.item(3).to_i != 99, :default => unquote_default(reader.item(4)))
+                }
+              end
             end
+            columns
+          end
+          alias_method :database_columns, :get_database_columns
+          
+          def to_create_sql            
+            @to_create_sql || @to_create_sql = begin
+              sql = "CREATE"
+              sql << " TEMPORARY" if temporary?
+              sql << " TABLE #{to_sql} (#{ columns.map { |c| c.to_long_form }.join(",\n") }"
+              unless keys.blank? || (keys.size == 1 && keys.first.serial?)
+                sql << ", PRIMARY KEY (#{keys.map { |c| c.to_sql }.join(', ') })"
+              end
+              sql << ")"
+              sql.compress_lines
+            end
+          end
+          
+          def to_drop_sql
+            @to_drop_sql || @to_drop_sql = "DROP TABLE #{to_sql}"
           end
           
           def to_exists_sql
@@ -138,7 +310,28 @@ module DataMapper
               SELECT TABLE_NAME
               FROM INFORMATION_SCHEMA.TABLES
               WHERE TABLE_NAME = ?
-                AND TABLE_SCHEMA = ?
+                AND #{@adapter.database_column_name} = ?
+            EOS
+          end
+          
+          def to_column_exists_sql
+            @to_column_exists_sql || @to_column_exists_sql = <<-EOS.compress_lines
+              SELECT TABLE_NAME, COLUMN_NAME
+              FROM INFORMATION_SCHEMA.COLUMNS
+              WHERE TABLE_NAME = ?
+              AND COLUMN_NAME = ?
+                AND #{@adapter.database_column_name} = ?
+            EOS
+          end   
+          
+          def to_columns_sql
+            @to_column_exists_sql || @to_column_exists_sql = <<-EOS.compress_lines
+              SELECT ORDINAL_POSITION, COLUMN_NAME, DATA_TYPE,
+              (CASE IS_NULLABLE WHEN 'NO' THEN 99 ELSE 0 END),
+              COLUMN_DEFAULT
+              FROM INFORMATION_SCHEMA.COLUMNS
+              WHERE TABLE_NAME = ?
+              AND #{@adapter.database_column_name} = ?
             EOS
           end
           
@@ -155,7 +348,41 @@ module DataMapper
               @columns.inspect
             ]
           end
-      
+          
+          def flush_sql_caches!(flush_columns = true)
+            @to_column_exists_sql = nil
+            @to_column_exists_sql = nil
+            @to_exists_sql = nil
+            @to_create_sql = nil
+            @to_drop_sql = nil
+            @to_sql = nil
+            @name = nil
+            
+            if flush_columns
+              @columns.each do |column|
+                column.send(:flush_sql_caches!)
+              end
+            end
+            
+            true
+          end
+          
+          def activate!
+            @activated = true
+            @associations.each do |association|
+              association.activate!
+            end
+          end
+          
+          def activated?
+            @activated
+          end
+          
+        end
+        
+        class Schema
+          def to_tables_sql
+          end
         end
     
       end

data/lib/data_mapper/adapters/sqlite3_adapter.rb

@@ -4,7 +4,7 @@ begin
 rescue LoadError
   STDERR.puts <<-EOS
 You must install the DataObjects::SQLite3 driver.
-  rake dm:install:sqlite3
+  gem install do_sqlite3
 EOS
   exit
 end
@@ -18,7 +18,8 @@ module DataMapper
         :integer => 'INTEGER'.freeze,
         :string => 'TEXT'.freeze,
         :text => 'TEXT'.freeze,
-        :class => 'TEXT'.freeze
+        :class => 'TEXT'.freeze,
+        :boolean => 'INTEGER'.freeze
       })
 
       TABLE_QUOTING_CHARACTER = '"'.freeze
@@ -31,22 +32,45 @@ module DataMapper
         return conn
       end
       
-      def truncate(session, name)
-        result = execute("DELETE FROM #{table(name).to_sql}")
-        session.identity_map.clear!(name)
-        result.to_i > 0
+      def batch_insertable?
+        false
       end
-          
+      
       module Mappings
+        
+        class Schema
+          def to_tables_sql
+            @to_tables_sql || @to_tables_sql = <<-EOS.compress_lines
+              SELECT "name" 
+              FROM sqlite_master 
+              where "type"= "table"
+              and "name" <> "sqlite_sequence"
+            EOS
+          end
+          alias_method :database_tables, :get_database_tables
+        end # class Schema
+        
         class Table
           def to_exists_sql
             @to_exists_sql || @to_exists_sql = <<-EOS.compress_lines
               SELECT "name"
-              FROM "sqlite_master"
+              FROM "#{temporary? ? 'sqlite_temp_master' : 'sqlite_master'}"
               WHERE "type" = "table"
                 AND "name" = ?
             EOS
           end
+          
+          def to_column_exists_sql
+            @to_column_exists_sql || @to_column_exists_sql = <<-EOS.compress_lines
+              PRAGMA TABLE_INFO(?)
+            EOS
+          end
+          alias_method :to_columns_sql, :to_column_exists_sql
+          
+          def unquote_default(default)
+            default.gsub(/(^'|'$)/, "") rescue default
+          end
+          
         end # class Table
         
         class Column
@@ -57,6 +81,67 @@ module DataMapper
           def size
             nil
           end
+                    
+          def alter!
+            @adapter.connection do |db|
+              flush_sql_caches!
+              backup_table = @adapter.table("#{@table.name}_backup")
+
+              @table.columns.each do |column|
+                backup_table.add_column(column.name, column.type, column.options)
+              end
+
+              backup_table.temporary = true
+
+              backup_table.create!
+              
+              sql = <<-EOS.compress_lines
+                INSERT INTO #{backup_table.to_sql} SELECT #{@table.columns.map { |c| c.to_sql }.join(', ')} FROM #{@table.to_sql};
+                DROP TABLE #{@table.to_sql};
+                #{@table.to_create_sql};
+                INSERT INTO #{@table.to_sql} SELECT #{backup_table.columns.map { |c| c.to_sql }.join(', ')} FROM #{backup_table.to_sql};
+              EOS
+              
+              sql.split(';').each do |part|
+                db.create_command(part).execute_non_query
+              end
+              
+              backup_table.drop!
+              flush_sql_caches!
+            end
+          end
+          
+          def drop!
+            @adapter.connection do |db|
+              @table.columns.delete(self)
+              flush_sql_caches!
+              
+              backup_table = @adapter.table("#{@table.name}_backup")
+              
+              @table.columns.each do |column|
+                backup_table.add_column(column.name, column.type, column.options)
+              end
+
+              backup_table.temporary = true
+
+              backup_table.create!
+              
+              sql = <<-EOS.compress_lines
+                INSERT INTO #{backup_table.to_sql} SELECT #{@table.columns.map { |c| c.to_sql }.join(', ')} FROM #{@table.to_sql};
+                DROP TABLE #{@table.to_sql};
+                #{@table.to_create_sql};
+                INSERT INTO #{@table.to_sql} SELECT #{backup_table.columns.map { |c| c.to_sql }.join(', ')} FROM #{backup_table.to_sql};
+              EOS
+              
+              sql.split(';').each do |part|
+                db.create_command(part).execute_non_query
+              end
+              
+              backup_table.drop!
+              flush_sql_caches!
+            end
+          end          
+          
         end # class Column
       end # module Mappings
       

data/lib/data_mapper/associations/belongs_to_association.rb

@@ -5,9 +5,7 @@ module DataMapper
     
     class BelongsToAssociation < HasNAssociation
 
-      def define_accessor(klass)
-        klass.property((@options[:foreign_key] || "#{name}_id").to_sym, :integer)
-        
+      def define_accessor(klass)        
         klass.class_eval <<-EOS
           
           def create_#{@association_name}(options = {})
@@ -33,14 +31,47 @@ module DataMapper
         EOS
       end
       
-      def foreign_key
-        @foreign_key || @foreign_key = begin
-          table[@options[:foreign_key] || "#{name}_id".to_sym]
-        end
+      # Reverse the natural order for BelongsToAssociations
+      alias constant associated_constant
+      def associated_constant
+        @constant
       end
-
+      
+      def foreign_key_name
+        @foreign_key_name || @foreign_key_name = (@options[:foreign_key] || "#{name}_#{key_table.key.name}".to_sym)
+      end
+      
+      def to_sql
+        "JOIN #{key_table.to_sql} ON #{foreign_key_column.to_sql(true)} = #{primary_key_column.to_sql(true)}"
+      end
+      
       class Instance < Associations::Reference
-         
+        
+        def dirty?
+          @associated && @new_member
+        end
+        
+        def validate_recursively(event, cleared)
+          @associated.nil? || cleared.include?(@associated) || @associated.validate_recursively(event, cleared)
+        end
+        
+        def save_without_validation(database_context)
+          @new_member = false
+          unless @associated.nil?
+            @instance.instance_variable_set(
+              association.foreign_key_column.instance_variable_name,
+              @associated.key
+            )
+            @instance.database_context.adapter.save_without_validation(database_context, @instance)
+          end
+        end
+        
+        def reload!
+          @new_member = false
+          @associated = nil
+          instance
+        end
+        
         def instance
           @associated || @associated = begin                    
             if @instance.loaded_set.nil?
@@ -48,11 +79,11 @@ module DataMapper
             else
               
               # Temp variable for the instance variable name.
-              fk = association.foreign_key.to_sym
+              fk = association.foreign_key_column.to_sym
               
               set = @instance.loaded_set.group_by { |instance| instance.send(fk) }
 
-              @instance.session.all(association.constant, association.association_table.key.to_sym => set.keys).each do |assoc|
+              @instance.database_context.all(association.constant, association.associated_table.key.to_sym => set.keys).each do |assoc|
                 set[assoc.key].each do |primary_instance|
                   primary_instance.send(setter_method, assoc)
                 end
@@ -64,11 +95,11 @@ module DataMapper
         end
       
         def create(options)
-          @associated = association.constant.create(options)
+          @associated = association.associated_constant.create(options)
         end
       
         def build(options)
-          @associated = association.constant.new(options)
+          @associated = association.associated_constant.new(options)
         end
       
         def setter_method
@@ -76,51 +107,19 @@ module DataMapper
         end
         
         def set(val)
-          @instance.instance_variable_set(association.foreign_key.instance_variable_name, val.key)
+          raise "RecursionError" if val == @instance
+          @new_member = true
+          @instance.instance_variable_set(association.foreign_key_column.instance_variable_name, val.key)
           @associated = val
         end
+        
+        def ensure_foreign_key!
+          if @associated
+            @instance.instance_variable_set(association.foreign_key.instance_variable_name, @associated.key)
+          end
+        end
             
       end # class Instance
-      
-      
-      # def find
-      #   return @result unless @result.nil?
-      #   
-      #   unless @instance.loaded_set.nil?
-      #     
-      #     # Temp variable for the instance variable name.
-      #     setter_method = "#{@association_name}=".to_sym
-      #     instance_variable_name = "@#{foreign_key}".to_sym
-      #     
-      #     set = @instance.loaded_set.group_by { |instance| instance.instance_variable_get(instance_variable_name) }
-      #     
-      #     # Fetch the foreign objects for all instances in the current object's loaded-set.
-      #     @instance.session.all(constant, :id => set.keys).each do |owner|
-      #       set[owner.key].each do |instance|
-      #         instance.send(setter_method, owner)
-      #       end
-      #     end
-      #   end
-      #   
-      #   return @result
-      # end
-
-      # def create(options = {})
-      #   associated = constant.new(options)
-      #   if associated.save
-      #     @instance.send("#{constant.foreign_key}=", associated.id)
-      #     @result = associated
-      #   end
-      # end
-      # 
-      # def build(options = {})
-      #   @result = constant.new(options)
-      # end
-      # 
-      # def set(val)
-      #   @result = val
-      # end
-            
     end
     
   end