activerecord 1.11.1 → 1.12.1

data/lib/active_record/callbacks.rb

@@ -345,9 +345,9 @@ module ActiveRecord
           return false if result == false
         end
 
-        send(method) if respond_to_without_attributes?(method)
+        result = send(method) if respond_to_without_attributes?(method)
 
-        return true
+        return result
       end
 
       def callbacks_for(method)

data/lib/active_record/connection_adapters/abstract/connection_specification.rb

@@ -0,0 +1,128 @@
+module ActiveRecord
+  # The root class of all active record objects.
+  class Base
+    class ConnectionSpecification #:nodoc:
+      attr_reader :config, :adapter_method
+      def initialize (config, adapter_method)
+        @config, @adapter_method = config, adapter_method
+      end
+    end
+
+    # The class -> [adapter_method, config] map
+    @@defined_connections = {}
+
+    # Establishes the connection to the database. Accepts a hash as input where
+    # the :adapter key must be specified with the name of a database adapter (in lower-case)
+    # example for regular databases (MySQL, Postgresql, etc):
+    #
+    #   ActiveRecord::Base.establish_connection(
+    #     :adapter  => "mysql",
+    #     :host     => "localhost",
+    #     :username => "myuser",
+    #     :password => "mypass",
+    #     :database => "somedatabase"
+    #   )
+    #
+    # Example for SQLite database:
+    #
+    #   ActiveRecord::Base.establish_connection(
+    #     :adapter => "sqlite",
+    #     :dbfile  => "path/to/dbfile"
+    #   )
+    #
+    # Also accepts keys as strings (for parsing from yaml for example):
+    #   ActiveRecord::Base.establish_connection(
+    #     "adapter" => "sqlite",
+    #     "dbfile"  => "path/to/dbfile"
+    #   )
+    #
+    # The exceptions AdapterNotSpecified, AdapterNotFound and ArgumentError
+    # may be returned on an error.
+    def self.establish_connection(spec = nil)
+      case spec
+        when nil
+          raise AdapterNotSpecified unless defined? RAILS_ENV
+          establish_connection(RAILS_ENV)
+        when ConnectionSpecification
+          @@defined_connections[self] = spec
+        when Symbol, String
+          if configuration = configurations[spec.to_s]
+            establish_connection(configuration)
+          else
+            raise AdapterNotSpecified, "#{spec} database is not configured"
+          end
+        else
+          spec = spec.symbolize_keys
+          unless spec.key?(:adapter) then raise AdapterNotSpecified, "database configuration does not specify adapter" end
+          adapter_method = "#{spec[:adapter]}_connection"
+          unless respond_to?(adapter_method) then raise AdapterNotFound, "database configuration specifies nonexistent #{spec[:adapter]} adapter" end
+          remove_connection
+          establish_connection(ConnectionSpecification.new(spec, adapter_method))
+      end
+    end
+
+    def self.active_connections #:nodoc:
+      if allow_concurrency
+        Thread.current['active_connections'] ||= {}
+      else
+        @@active_connections ||= {}
+      end
+    end
+
+    # Locate the connection of the nearest super class. This can be an
+    # active or defined connections: if it is the latter, it will be
+    # opened and set as the active connection for the class it was defined
+    # for (not necessarily the current class).
+    def self.retrieve_connection #:nodoc:
+      klass = self
+      ar_super = ActiveRecord::Base.superclass
+      until klass == ar_super
+        if conn = active_connections[klass]
+          return conn
+        elsif conn = @@defined_connections[klass]
+          klass.connection = conn
+          return self.connection
+        end
+        klass = klass.superclass
+      end
+      raise ConnectionNotEstablished
+    end
+
+    # Returns true if a connection that's accessible to this class have already been opened.
+    def self.connected?
+      klass = self
+      until klass == ActiveRecord::Base.superclass
+        if active_connections[klass]
+          return true
+        else
+          klass = klass.superclass
+        end
+      end
+      return false
+    end
+
+    # Remove the connection for this class. This will close the active
+    # connection and the defined connection (if they exist). The result
+    # can be used as argument for establish_connection, for easy
+    # re-establishing of the connection.
+    def self.remove_connection(klass=self)
+      conn = @@defined_connections[klass]
+      @@defined_connections.delete(klass)
+      active_connections[klass] = nil
+      conn.config if conn
+    end
+
+    # Set the connection for the class.
+    def self.connection=(spec)
+      if spec.kind_of?(ActiveRecord::ConnectionAdapters::AbstractAdapter)
+        active_connections[self] = spec
+      elsif spec.kind_of?(ConnectionSpecification)
+        self.connection = self.send(spec.adapter_method, spec.config)
+      elsif spec.nil?
+        raise ConnectionNotEstablished
+      else
+        establish_connection spec
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/abstract/database_statements.rb

@@ -0,0 +1,104 @@
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    module DatabaseStatements
+      # Returns an array of record hashes with the column names as keys and
+      # column values as values.
+      def select_all(sql, name = nil)
+      end
+
+      # Returns a record hash with the column names as keys and column values
+      # as values.
+      def select_one(sql, name = nil)
+      end
+
+      # Returns a single value from a record
+      def select_value(sql, name = nil)
+        result = select_one(sql, name)
+        result.nil? ? nil : result.values.first
+      end
+
+      # Returns an array of the values of the first column in a select:
+      #   select_values("SELECT id FROM companies LIMIT 3") => [1,2,3]
+      def select_values(sql, name = nil)
+        result = select_all(sql, name)
+        result.map{ |v| v.values.first }
+      end
+
+      # Executes the SQL statement in the context of this connection.
+      # This abstract method raises a NotImplementedError.
+      def execute(sql, name = nil)
+        raise NotImplementedError, "execute is an abstract method"
+      end
+
+      # Returns the last auto-generated ID from the affected table.
+      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) end
+
+      # Executes the update statement and returns the number of rows affected.
+      def update(sql, name = nil) end
+
+      # Executes the delete statement and returns the number of rows affected.
+      def delete(sql, name = nil) end
+
+      # Wrap a block in a transaction.  Returns result of block.
+      def transaction(start_db_transaction = true)
+        transaction_open = false
+        begin
+          if block_given?
+            if start_db_transaction
+              begin_db_transaction 
+              transaction_open = true
+            end
+            yield
+          end
+        rescue Exception => database_transaction_rollback
+          if transaction_open
+            transaction_open = false
+            rollback_db_transaction
+          end
+          raise
+        end
+      ensure
+        commit_db_transaction if transaction_open
+      end
+
+      # Begins the transaction (and turns off auto-committing).
+      def begin_db_transaction()    end
+
+      # Commits the transaction (and turns on auto-committing).
+      def commit_db_transaction()   end
+
+      # Rolls back the transaction (and turns on auto-committing). Must be
+      # done if the transaction block raises an exception or returns false.
+      def rollback_db_transaction() end
+
+      # Alias for #add_limit_offset!.
+      def add_limit!(sql, options)
+        add_limit_offset!(sql, options) if options
+      end
+
+      # Appends +LIMIT+ and +OFFSET+ options to a SQL statement.
+      # This method *modifies* the +sql+ parameter.
+      # ===== Examples
+      #  add_limit_offset!('SELECT * FROM suppliers', {:limit => 10, :offset => 50})
+      # generates
+      #  SELECT * FROM suppliers LIMIT 10 OFFSET 50
+      def add_limit_offset!(sql, options)
+        if limit = options[:limit]
+          sql << " LIMIT #{limit}"
+          if offset = options[:offset]
+            sql << " OFFSET #{offset}"
+          end
+        end
+      end
+
+      def default_sequence_name(table, column)
+        nil
+      end
+
+      # Set the sequence to the max value of the table's column.
+      def reset_sequence!(table, column, sequence = nil)
+        # Do nothing by default.  Implement for PostgreSQL, Oracle, ...
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/abstract/quoting.rb

@@ -0,0 +1,51 @@
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    module Quoting
+      # Quotes the column value to help prevent
+      # {SQL injection attacks}[http://en.wikipedia.org/wiki/SQL_injection].
+      def quote(value, column = nil)
+        case value
+          when String
+            if column && column.type == :binary
+              "'#{quote_string(column.class.string_to_binary(value))}'" # ' (for ruby-mode)
+            elsif column && [:integer, :float].include?(column.type) 
+              value.to_s
+            else
+              "'#{quote_string(value)}'" # ' (for ruby-mode)
+            end
+          when NilClass              then "NULL"
+          when TrueClass             then (column && column.type == :integer ? '1' : quoted_true)
+          when FalseClass            then (column && column.type == :integer ? '0' : quoted_false)
+          when Float, Fixnum, Bignum then value.to_s
+          when Date                  then "'#{value.to_s}'"
+          when Time, DateTime        then "'#{quoted_date(value)}'"
+          else                            "'#{quote_string(value.to_yaml)}'"
+        end
+      end
+
+      # Quotes a string, escaping any ' (single quote) and \ (backslash)
+      # characters.
+      def quote_string(s)
+        s.gsub(/\\/, '\&\&').gsub(/'/, "''") # ' (for ruby-mode)
+      end
+
+      # Returns a quoted form of the column name.  This is highly adapter
+      # specific.
+      def quote_column_name(name)
+        name
+      end
+
+      def quoted_true
+        "'t'"
+      end
+      
+      def quoted_false
+        "'f'"
+      end
+      
+      def quoted_date(value)
+        value.strftime("%Y-%m-%d %H:%M:%S")
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/abstract/schema_definitions.rb

@@ -0,0 +1,249 @@
+require 'parsedate'
+
+module ActiveRecord
+  module ConnectionAdapters #:nodoc:
+    # An abstract definition of a column in a table.
+    class Column
+      attr_reader :name, :default, :type, :limit, :null
+      attr_accessor :primary
+
+      # Instantiates a new column in the table.
+      #
+      # +name+ is the column's name, as in <tt><b>supplier_id</b> int(11)</tt>.
+      # +default+ is the type-casted default value, such as <tt>sales_stage varchar(20) default <b>'new'</b></tt>.
+      # +sql_type+ is only used to extract the column's length, if necessary.  For example, <tt>company_name varchar(<b>60</b>)</tt>.
+      # +null+ determines if this column allows +NULL+ values.
+      def initialize(name, default, sql_type = nil, null = true)
+        @name, @type, @null = name, simplified_type(sql_type), null
+        # have to do this one separately because type_cast depends on #type
+        @default = type_cast(default)
+        @limit   = extract_limit(sql_type) unless sql_type.nil?
+        @primary = nil
+        @text    = [:string, :text].include? @type
+        @number  = [:float, :integer].include? @type
+      end
+
+      def text?
+        @text
+      end
+
+      def number?
+        @number
+      end
+
+      # Returns the Ruby class that corresponds to the abstract data type.
+      def klass
+        case type
+          when :integer       then Fixnum
+          when :float         then Float
+          when :datetime      then Time
+          when :date          then Date
+          when :timestamp     then Time
+          when :time          then Time
+          when :text, :string then String
+          when :binary        then String
+          when :boolean       then Object
+        end
+      end
+
+      # Casts value (which is a String) to an appropriate instance.
+      def type_cast(value)
+        return nil if value.nil?
+        case type
+          when :string    then value
+          when :text      then value
+          when :integer   then value.to_i rescue value ? 1 : 0
+          when :float     then value.to_f
+          when :datetime  then self.class.string_to_time(value)
+          when :timestamp then self.class.string_to_time(value)
+          when :time      then self.class.string_to_dummy_time(value)
+          when :date      then self.class.string_to_date(value)
+          when :binary    then self.class.binary_to_string(value)
+          when :boolean   then value == true or (value =~ /^t(rue)?$/i) == 0 or value.to_s == '1'
+          else value
+        end
+      end
+
+      def type_cast_code(var_name)
+        case type
+          when :string    then nil
+          when :text      then nil
+          when :integer   then "(#{var_name}.to_i rescue #{var_name} ? 1 : 0)"
+          when :float     then "#{var_name}.to_f"
+          when :datetime  then "#{self.class.name}.string_to_time(#{var_name})"
+          when :timestamp then "#{self.class.name}.string_to_time(#{var_name})"
+          when :time      then "#{self.class.name}.string_to_dummy_time(#{var_name})"
+          when :date      then "#{self.class.name}.string_to_date(#{var_name})"
+          when :binary    then "#{self.class.name}.binary_to_string(#{var_name})"
+          when :boolean   then "(#{var_name} == true or (#{var_name} =~ /^t(?:true)?$/i) == 0 or #{var_name}.to_s == '1')"
+          else nil
+        end
+      end
+
+      # Returns the human name of the column name.
+      #
+      # ===== Examples
+      #  Column.new('sales_stage', ...).human_name #=> 'Sales stage'
+      def human_name
+        Base.human_attribute_name(@name)
+      end
+
+      # Used to convert from Strings to BLOBs
+      def self.string_to_binary(value)
+        value
+      end
+
+      # Used to convert from BLOBs to Strings
+      def self.binary_to_string(value)
+        value
+      end
+
+      def self.string_to_date(string)
+        return string unless string.is_a?(String)
+        date_array = ParseDate.parsedate(string)
+        # treat 0000-00-00 as nil
+        Date.new(date_array[0], date_array[1], date_array[2]) rescue nil
+      end
+
+      def self.string_to_time(string)
+        return string unless string.is_a?(String)
+        time_array = ParseDate.parsedate(string)[0..5]
+        # treat 0000-00-00 00:00:00 as nil
+        Time.send(Base.default_timezone, *time_array) rescue nil
+      end
+
+      def self.string_to_dummy_time(string)
+        return string unless string.is_a?(String)
+        time_array = ParseDate.parsedate(string)
+        # pad the resulting array with dummy date information
+        time_array[0] = 2000; time_array[1] = 1; time_array[2] = 1;
+        Time.send(Base.default_timezone, *time_array) rescue nil
+      end
+
+    private
+        def extract_limit(sql_type)
+          $1.to_i if sql_type =~ /\((.*)\)/
+        end
+
+        def simplified_type(field_type)
+          case field_type
+            when /int/i
+              :integer
+            when /float|double|decimal|numeric/i
+              :float
+            when /datetime/i
+              :datetime
+            when /timestamp/i
+              :timestamp
+            when /time/i
+              :time
+            when /date/i
+              :date
+            when /clob/i, /text/i
+              :text
+            when /blob/i, /binary/i
+              :binary
+            when /char/i, /string/i
+              :string
+            when /boolean/i
+              :boolean
+          end
+        end
+    end
+
+    class IndexDefinition < Struct.new(:table, :name, :unique, :columns) #:nodoc:
+    end
+
+    class ColumnDefinition < Struct.new(:base, :name, :type, :limit, :default, :null) #:nodoc:
+      def to_sql
+        column_sql = "#{name} #{type_to_sql(type.to_sym, limit)}"
+        add_column_options!(column_sql, :null => null, :default => default)
+        column_sql
+      end
+      alias to_s :to_sql
+      
+      private
+        def type_to_sql(name, limit)
+          base.type_to_sql(name, limit) rescue name
+        end   
+
+        def add_column_options!(sql, options)
+          base.add_column_options!(sql, options.merge(:column => self))
+        end
+    end
+
+    # Represents a SQL table in an abstract way.
+    # Columns are stored as ColumnDefinition in the #columns attribute.
+    class TableDefinition
+      attr_accessor :columns
+
+      def initialize(base)
+        @columns = []
+        @base = base
+      end
+
+      # Appends a primary key definition to the table definition.
+      # Can be called multiple times, but this is probably not a good idea.
+      def primary_key(name)
+        column(name, native[:primary_key])
+      end
+
+      # Returns a ColumnDefinition for the column with name +name+.
+      def [](name)
+        @columns.find {|column| column.name.to_s == name.to_s}
+      end
+
+      # Instantiates a new column for the table.
+      # The +type+ parameter must be one of the following values:
+      # <tt>:primary_key</tt>, <tt>:string</tt>, <tt>:text</tt>,
+      # <tt>:integer</tt>, <tt>:float</tt>, <tt>:datetime</tt>,
+      # <tt>:timestamp</tt>, <tt>:time</tt>, <tt>:date</tt>,
+      # <tt>:binary</tt>, <tt>:boolean</tt>.
+      #
+      # Available options are (none of these exists by default):
+      # * <tt>:limit</tt>:
+      #   Requests a maximum column length (<tt>:string</tt>, <tt>:text</tt>,
+      #   <tt>:binary</tt> or <tt>:integer</tt> columns only)
+      # * <tt>:default</tt>:
+      #   The column's default value.  You cannot explicitely set the default
+      #   value to +NULL+.  Simply leave off this option if you want a +NULL+
+      #   default value.
+      # * <tt>:null</tt>:
+      #   Allows or disallows +NULL+ values in the column.  This option could
+      #   have been named <tt>:null_allowed</tt>.
+      #
+      # This method returns <tt>self</tt>.
+      #
+      # ===== Examples
+      #  # Assuming def is an instance of TableDefinition
+      #  def.column(:granted, :boolean)
+      #    #=> granted BOOLEAN
+      #
+      #  def.column(:picture, :binary, :limit => 2.megabytes)
+      #    #=> picture BLOB(2097152)
+      #
+      #  def.column(:sales_stage, :string, :limit => 20, :default => 'new', :null => false)
+      #    #=> sales_stage VARCHAR(20) DEFAULT 'new' NOT NULL
+      def column(name, type, options = {})
+        column = self[name] || ColumnDefinition.new(@base, name, type)
+        column.limit = options[:limit] || native[type.to_sym][:limit] if options[:limit] or native[type.to_sym]
+        column.default = options[:default]
+        column.null = options[:null]
+        @columns << column unless @columns.include? column
+        self
+      end
+            
+      # Returns a String whose contents are the column definitions
+      # concatenated together.  This string can then be pre and appended to
+      # to generate the final SQL to create the table.
+      def to_sql
+        @columns * ', '
+      end
+      
+      private
+        def native
+          @base.native_database_types
+        end
+    end
+  end
+end