datamapper 0.2.3 → 0.2.4

data/example.rb

@@ -37,7 +37,7 @@ DataMapper::Database.setup({
   :username => 'root'
 })
 
-class Animal < DataMapper::Base
+class Animal < DataMapper::Base #:nodoc:
   set_table_name 'animals' # Just as an example. Same inflector as Rails,
     # so this really isn't necessary.
     
@@ -47,17 +47,17 @@ class Animal < DataMapper::Base
   has_and_belongs_to_many :exhibits
 end
 
-class Exhibit < DataMapper::Base
+class Exhibit < DataMapper::Base #:nodoc:
   property :name, :string
   belongs_to :zoo
 end
 
-class Zoo < DataMapper::Base
+class Zoo < DataMapper::Base #:nodoc:
   property :name, :string
   has_many :exhibits
 end
 
-class Person < DataMapper::Base
+class Person < DataMapper::Base #:nodoc:
 
   property :name, :string
   property :age, :integer
@@ -127,4 +127,4 @@ end
 # DataMapper find_by_sql equivilent
 database.query("SELECT * FROM zoos")
 
-end
+end

data/lib/data_mapper/adapters/abstract_adapter.rb

@@ -21,11 +21,11 @@ module DataMapper
         raise NotImplementedError.new
       end
       
-      def save(session, instance)
+      def save(database_context, instance)
         raise NotImplementedError.new
       end
       
-      def load(session, klass, options)
+      def load(database_context, klass, options)
         raise NotImplementedError.new
       end
       

data/lib/data_mapper/adapters/data_object_adapter.rb

@@ -49,13 +49,26 @@ module DataMapper
       
       def initialize(configuration)
         super
-        @connection_pool = Support::ConnectionPool.new(4) { create_connection }
+        @connection_pool = Support::ConnectionPool.new { create_connection }
+      end
+      
+      def activated?
+        @activated
+      end
+      
+      def activate!
+        @activated = true
+        schema.activate!
       end
       
       def create_connection
         raise NotImplementedError.new
       end
       
+      def batch_insertable?
+        true
+      end
+      
       # Yields an available connection. Flushes the connection-pool and reconnects
       # if the connection returns an error.
       def connection
@@ -95,32 +108,34 @@ module DataMapper
         raise NotImplementedError.new
       end
       
-      def query(*args)        
-        connection do |db|
+      def query(*args)
+        db = create_connection
         
-          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 = []
-
-            if fields.size > 1
-              struct = Struct.new(*fields)
-              
-              reader.each do
-                results << struct.new(*reader.current_row)
-              end
-            else
-              reader.each do
-                results << reader.item(0)
-              end
-            end
+        command = db.create_command(args.shift)
+        
+        reader = command.execute_reader(*args)
+        fields = reader.fields.map { |field| Inflector.underscore(field).to_sym }
+        results = []
 
-            results            
+        if fields.size > 1
+          struct = Struct.new(*fields)
+          
+          reader.each do
+            results << struct.new(*reader.current_row)
+          end
+        else
+          reader.each do
+            results << reader.item(0)
           end
         end
+
+        return results
+      rescue => e
+        logger.error { e }
+        raise e
+      ensure
+        reader.close if reader
+        db.close
       end      
       
       def handle_error(error)
@@ -128,153 +143,68 @@ module DataMapper
       end
       
       def schema
-        @schema || ( @schema = Mappings::Schema.new(self, @configuration.database) )
+        @schema || ( @schema = self.class::Mappings::Schema.new(self, @configuration.database) )
       end
       
-      def table_exists?(name)
+      def column_exists_for_table?(table_name, column_name)
         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?
+          table = self.table(table_name)
+          command = db.create_command(table.to_column_exists_sql)
+          command.execute_reader(table.name, column_name, table.schema.name) do |reader|
+            reader.any? { reader.item(1) == column_name.to_s }
           end
         end
       end
-      
-      def truncate(session, name)
-        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)
-        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)
-        table = self.table(name)
-        
-        if table.exists?
-          false
-        else
-          connection do |db|
-            db.create_command(table.to_create_table_sql).execute_non_query
-            true
-          end
-        end
-      end
-      
-      def delete(session, instance)
+            
+      def delete(database_context, instance)
         table = self.table(instance)
         
         if instance.is_a?(Class)
-          connection do |db|
-            db.create_command("DELETE FROM #{table.to_sql}").execute_non_query
-          end
-          session.identity_map.clear!(instance)
+          table.delete_all!
         else
           callback(instance, :before_destroy)
           
-          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_values.clear
-            session.identity_map.delete(instance)
-            callback(instance, :after_destroy)
-          end          
+          if table.paranoid?
+            instance.instance_variable_set(table.paranoid_column.instance_variable_name, Time::now)
+            instance.save
+          else
+            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.database_context = database_context
+              instance.original_values.clear
+              database_context.identity_map.delete(instance)
+              callback(instance, :after_destroy)
+            end
+          end        
         end
       end
       
-      def save(session, instance)
+      def save(database_context, instance, validate = true)
         case instance
-        when Class, Mappings::Table then create_table(instance)
+        when Class then table(instance).create!
+        when Mappings::Table then instance.create!
         when DataMapper::Base then
-          return false unless instance.dirty? && instance.valid?
+          return false unless instance.new_record? || instance.dirty?
           
-          callback(instance, :before_save)           
+          event = instance.new_record? ? :create : :update
           
-          # INSERT
-          result = if instance.new_record?
-            callback(instance, :before_create)
-
-            table = self.table(instance)
-            attributes = instance.dirty_attributes
-            
-            unless attributes.empty?
-              if table.multi_class?
-                instance.instance_variable_set(
-                  table[:type].instance_variable_name,
-                  attributes[:type] = instance.class.name
-                )
-              end
-            
-              keys = []
-              values = []
-              attributes.each_pair do |key, value|
-                keys << table[key].to_sql
-                values << value
-              end
+          return false if validate && !instance.validate_recursively(event, Set.new)
           
-              # Formatting is a bit off here, but it looks nicer in the log this way.
-              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)
-              callback(instance, :after_create)
-            end
-          # UPDATE
-          else            
-            callback(instance, :before_update)
-            
-            table = self.table(instance)
-            attributes = instance.dirty_attributes
-            parameters = []
-            
-            unless attributes.empty?
-              sql = "UPDATE " << table.to_sql << " SET "
-      
-              sql << attributes.map do |key, value|
-                parameters << value
-                "#{table[key].to_sql} = ?"
-              end.join(', ')
-      
-              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
+          callback(instance, :before_save)
+          result = send(event, database_context, instance)
           
+          instance.database_context = database_context
           instance.attributes.each_pair do |name, value|
             instance.original_values[name] = value
           end
           
           instance.loaded_associations.each do |association|
-            association.save if association.respond_to?(:save)
+            association.save_without_validation(database_context) if association.dirty?
           end
           
-          instance.session = session
           callback(instance, :after_save)
           result
         end
@@ -283,12 +213,74 @@ module DataMapper
         raise error
       end
       
-      def load(session, klass, options)
-        self.class::Commands::LoadCommand.new(self, session, klass, options).call
+      def save_without_validation(database_context, instance)
+        save(database_context, instance, false)
+      end
+      
+      def update(database_context, instance)
+        callback(instance, :before_update)
+        
+        table = self.table(instance)
+        attributes = instance.dirty_attributes
+        parameters = []
+        
+        unless attributes.empty?
+          sql = "UPDATE " << table.to_sql << " SET "
+  
+          sql << attributes.map do |key, value|
+            parameters << value
+            "#{table[key].to_sql} = ?"
+          end.join(', ')
+  
+          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
+        else
+          true
+        end
+      end
+      
+      def create(database_context, instance)
+        callback(instance, :before_create)
+
+        table = self.table(instance)
+        attributes = instance.dirty_attributes
+        
+        if table.multi_class?
+          instance.instance_variable_set(
+            table[:type].instance_variable_name,
+            attributes[:type] = instance.class.name
+          )
+        end
+      
+        keys = []
+        values = []
+        attributes.each_pair do |key, value|
+          keys << table[key].to_sql
+          values << value
+        end
+    
+        sql = if keys.size > 0
+          "INSERT INTO #{table.to_sql} (#{keys.join(', ')}) VALUES ?"
+        else
+          "INSERT INTO #{table.to_sql}"
+        end
+        
+        insert_id = connection do |db|
+          db.create_command(sql).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)
+        database_context.identity_map.set(instance)
+        callback(instance, :after_create)
       end
       
-      def count(klass_or_instance, options)
-        query("SELECT COUNT(*) AS row_count FROM " + table(klass_or_instance).to_sql).first.to_i
+      def load(database_context, klass, options)
+        self.class::Commands::LoadCommand.new(self, database_context, klass, options).call
       end
       
       def table(instance)
@@ -340,7 +332,9 @@ module DataMapper
         :decimal => 'decimal'.freeze,
         :float => 'float'.freeze,
         :datetime => 'datetime'.freeze,
-        :date => 'date'.freeze
+        :date => 'date'.freeze,
+        :boolean => 'boolean'.freeze,
+        :object => 'text'.freeze
       }
 
       include Sql

data/lib/data_mapper/adapters/mysql_adapter.rb

@@ -4,7 +4,7 @@ begin
 rescue LoadError
   STDERR.puts <<-EOS
 You must install the DataObjects::Mysql driver.
-  rake dm:install:mysql
+  gem install do_mysql
 EOS
   exit
 end
@@ -34,6 +34,10 @@ module DataMapper
         return conn
       end
       
+      def database_column_name
+        "TABLE_SCHEMA"
+      end
+      
       module Mappings
         
         def to_create_table_sql
@@ -42,6 +46,15 @@ module DataMapper
           end
         end
         
+        class Schema
+
+          def database_tables
+            get_database_tables(@adapter.schema.name)
+          end
+
+        end
+
+        
       end # module Mappings
     end # class MysqlAdapter
     

data/lib/data_mapper/adapters/postgresql_adapter.rb

@@ -3,8 +3,8 @@ begin
   require 'do_postgres'
 rescue LoadError
   STDERR.puts <<-EOS
-You must install the DataObjects::PostgreSQL driver.
-  rake dm:install:postgresql
+You must install the DataObjects::Postgres driver.
+  gem install do_postgres
 EOS
   exit
 end
@@ -27,16 +27,29 @@ module DataMapper
       end
       
       def create_connection
-        conn = DataObject::Postgres::Connection.new("dbname=#{@configuration.database}")
+        connection_string = ""
+        builder = lambda do |k,v|
+          connection_string << "#{k}=#{@configuration.send(v)} " unless
+            @configuration.send(v).blank?
+        end
+        builder['host', :host]
+        builder['user', :username]
+        builder['password', :password]
+        builder['dbname', :database]
+        builder['socket', :socket]
+        conn = DataObject::Postgres::Connection.new(connection_string.strip)
         conn.logger = self.logger
         conn.open
-        return conn
-             
+
         unless schema_search_path.empty?
           execute("SET search_path TO #{schema_search_path}")
         end
-        
-        return connection
+
+        return conn
+      end
+      
+      def database_column_name
+        "TABLE_CATALOG"
       end
             
       TABLE_QUOTING_CHARACTER = '"'.freeze
@@ -72,15 +85,47 @@ module DataMapper
             return sql
           end
           
-          def to_exists_sql
-            @to_exists_sql || @to_exists_sql = <<-EOS.compress_lines
-              SELECT TABLE_NAME
-              FROM INFORMATION_SCHEMA.TABLES
-              WHERE TABLE_NAME = ?
-                AND TABLE_CATALOG = ?
-            EOS
+          # The logic of this comes from AR; it was modified for smarter typecasting
+          def unquote_default(default)
+            # Boolean types
+            return true if default =~ /true/i
+            return false if default =~ /false/i
+
+            # Char/String/Bytea type values
+            return $1 if default =~ /^'(.*)'::(bpchar|text|character varying|bytea)$/
+
+            # Numeric values
+            return value.to_f if default =~ /^-?[0-9]+(\.[0-9]*)/
+            return value.to_i if default =~ /^-?[0-9]+/
+
+            # Fixed dates / times
+            return Date.parse($1) if default =~ /^'(.+)'::date/
+            return DateTime.parse($1) if default =~ /^'(.+)'::timestamp/            
+
+            # Anything else is blank, some user type, or some function
+            # and we can't know the value of that, so return nil.
+            return nil       
           end
           
+          # def to_exists_sql
+          #   @to_exists_sql || @to_exists_sql = <<-EOS.compress_lines
+          #     SELECT TABLE_NAME
+          #     FROM INFORMATION_SCHEMA.TABLES
+          #     WHERE TABLE_NAME = ?
+          #       AND TABLE_CATALOG = ?
+          #   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 TABLE_CATALOG = ?
+          #   EOS
+          # end          
+                    
           private 
           
           def quote_table(table_suffix = nil)
@@ -91,17 +136,81 @@ module DataMapper
           end
         end # class Table
         
+        class Schema
+          
+          def database_tables
+            get_database_tables("public")
+          end
+          
+        end
+        
         class Column
           def serial_declaration
             "SERIAL"
           end
           
+          def to_alter_sql
+            "ALTER TABLE " <<  table.to_sql << " ALTER COLUMN " << to_alter_form
+          end
+          
+          def alter!
+            result = super
+            reset_alter_state!
+            result
+          end
+          
+          def reset_alter_state!
+            @type_changed = false
+            @default_changed = false
+          end
+          
+          def default=(value)
+            @default_changed = true
+            super
+          end
+          
+          def type=(value)
+            @type_changed = true
+            super
+          end
+          
+          def to_alter_form
+            sql = to_sql.dup
+            
+            changes = 0
+            
+            if @type_changed
+              changes += 1
+              sql << " TYPE " << type_declaration
+              case self.type
+              when :integer then sql << " USING #{to_sql}::integer"
+              when :datetime then
+                sql << " USING timestamp with time zone"
+              end
+            end
+            
+            if @default_changed
+              sql << ", " if changes += 1 > 1
+              
+              if default.blank? || default_declaration.blank?
+                sql << " DROP DEFAULT"
+              else
+                sql << " " << default_declaration
+              end
+            end
+            
+            sql
+          end
+          
           def to_long_form
             @to_long_form || begin
               @to_long_form = "#{to_sql}"
               
               if serial? && !serial_declaration.blank?
                 @to_long_form << " #{serial_declaration}"
+                if key? && !primary_key_declaration.blank?
+                  @to_long_form << " #{primary_key_declaration}"
+                end
               else
                 @to_long_form << " #{type_declaration}"
                 
@@ -109,10 +218,6 @@ module DataMapper
                   @to_long_form << " #{not_null_declaration}"
                 end
                 
-                if key? && !primary_key_declaration.blank?
-                  @to_long_form << " #{primary_key_declaration}"
-                end
-
                 if default && !default_declaration.blank?
                   @to_long_form << " #{default_declaration}"
                 end