sskirby-activerecord 3.2.1

data/lib/active_record/result.rb

@@ -0,0 +1,34 @@
+module ActiveRecord
+  ###
+  # This class encapsulates a Result returned from calling +exec_query+ on any
+  # database connection adapter. For example:
+  #
+  #   x = ActiveRecord::Base.connection.exec_query('SELECT * FROM foo')
+  #   x # => #<ActiveRecord::Result:0xdeadbeef>
+  class Result
+    include Enumerable
+
+    attr_reader :columns, :rows
+
+    def initialize(columns, rows)
+      @columns   = columns
+      @rows      = rows
+      @hash_rows = nil
+    end
+
+    def each
+      hash_rows.each { |row| yield row }
+    end
+
+    def to_hash
+      hash_rows
+    end
+
+    private
+    def hash_rows
+      @hash_rows ||= @rows.map { |row|
+        Hash[@columns.zip(row)]
+      }
+    end
+  end
+end

data/lib/active_record/sanitization.rb

@@ -0,0 +1,194 @@
+require 'active_support/concern'
+
+module ActiveRecord
+  module Sanitization
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def quote_value(value, column = nil) #:nodoc:
+        connection.quote(value,column)
+      end
+
+      # Used to sanitize objects before they're used in an SQL SELECT statement. Delegates to <tt>connection.quote</tt>.
+      def sanitize(object) #:nodoc:
+        connection.quote(object)
+      end
+
+      protected
+
+      # Accepts an array, hash, or string of SQL conditions and sanitizes
+      # them into a valid SQL fragment for a WHERE clause.
+      #   ["name='%s' and group_id='%s'", "foo'bar", 4]  returns  "name='foo''bar' and group_id='4'"
+      #   { :name => "foo'bar", :group_id => 4 }  returns "name='foo''bar' and group_id='4'"
+      #   "name='foo''bar' and group_id='4'" returns "name='foo''bar' and group_id='4'"
+      def sanitize_sql_for_conditions(condition, table_name = self.table_name)
+        return nil if condition.blank?
+
+        case condition
+        when Array; sanitize_sql_array(condition)
+        when Hash;  sanitize_sql_hash_for_conditions(condition, table_name)
+        else        condition
+        end
+      end
+      alias_method :sanitize_sql, :sanitize_sql_for_conditions
+
+      # Accepts an array, hash, or string of SQL conditions and sanitizes
+      # them into a valid SQL fragment for a SET clause.
+      #   { :name => nil, :group_id => 4 }  returns "name = NULL , group_id='4'"
+      def sanitize_sql_for_assignment(assignments)
+        case assignments
+          when Array; sanitize_sql_array(assignments)
+          when Hash;  sanitize_sql_hash_for_assignment(assignments)
+          else        assignments
+        end
+      end
+
+      # Accepts a hash of SQL conditions and replaces those attributes
+      # that correspond to a +composed_of+ relationship with their expanded
+      # aggregate attribute values.
+      # Given:
+      #     class Person < ActiveRecord::Base
+      #       composed_of :address, :class_name => "Address",
+      #         :mapping => [%w(address_street street), %w(address_city city)]
+      #     end
+      # Then:
+      #     { :address => Address.new("813 abc st.", "chicago") }
+      #       # => { :address_street => "813 abc st.", :address_city => "chicago" }
+      def expand_hash_conditions_for_aggregates(attrs)
+        expanded_attrs = {}
+        attrs.each do |attr, value|
+          unless (aggregation = reflect_on_aggregation(attr.to_sym)).nil?
+            mapping = aggregate_mapping(aggregation)
+            mapping.each do |field_attr, aggregate_attr|
+              if mapping.size == 1 && !value.respond_to?(aggregate_attr)
+                expanded_attrs[field_attr] = value
+              else
+                expanded_attrs[field_attr] = value.send(aggregate_attr)
+              end
+            end
+          else
+            expanded_attrs[attr] = value
+          end
+        end
+        expanded_attrs
+      end
+
+      # Sanitizes a hash of attribute/value pairs into SQL conditions for a WHERE clause.
+      #   { :name => "foo'bar", :group_id => 4 }
+      #     # => "name='foo''bar' and group_id= 4"
+      #   { :status => nil, :group_id => [1,2,3] }
+      #     # => "status IS NULL and group_id IN (1,2,3)"
+      #   { :age => 13..18 }
+      #     # => "age BETWEEN 13 AND 18"
+      #   { 'other_records.id' => 7 }
+      #     # => "`other_records`.`id` = 7"
+      #   { :other_records => { :id => 7 } }
+      #     # => "`other_records`.`id` = 7"
+      # And for value objects on a composed_of relationship:
+      #   { :address => Address.new("123 abc st.", "chicago") }
+      #     # => "address_street='123 abc st.' and address_city='chicago'"
+      def sanitize_sql_hash_for_conditions(attrs, default_table_name = self.table_name)
+        attrs = expand_hash_conditions_for_aggregates(attrs)
+
+        table = Arel::Table.new(table_name).alias(default_table_name)
+        PredicateBuilder.build_from_hash(arel_engine, attrs, table).map { |b|
+          connection.visitor.accept b
+        }.join(' AND ')
+      end
+      alias_method :sanitize_sql_hash, :sanitize_sql_hash_for_conditions
+
+      # Sanitizes a hash of attribute/value pairs into SQL conditions for a SET clause.
+      #   { :status => nil, :group_id => 1 }
+      #     # => "status = NULL , group_id = 1"
+      def sanitize_sql_hash_for_assignment(attrs)
+        attrs.map do |attr, value|
+          "#{connection.quote_column_name(attr)} = #{quote_bound_value(value)}"
+        end.join(', ')
+      end
+
+      # Accepts an array of conditions. The array has each value
+      # sanitized and interpolated into the SQL statement.
+      #   ["name='%s' and group_id='%s'", "foo'bar", 4]  returns  "name='foo''bar' and group_id='4'"
+      def sanitize_sql_array(ary)
+        statement, *values = ary
+        if values.first.is_a?(Hash) && statement =~ /:\w+/
+          replace_named_bind_variables(statement, values.first)
+        elsif statement.include?('?')
+          replace_bind_variables(statement, values)
+        elsif statement.blank?
+          statement
+        else
+          statement % values.collect { |value| connection.quote_string(value.to_s) }
+        end
+      end
+
+      alias_method :sanitize_conditions, :sanitize_sql
+
+      def replace_bind_variables(statement, values) #:nodoc:
+        raise_if_bind_arity_mismatch(statement, statement.count('?'), values.size)
+        bound = values.dup
+        c = connection
+        statement.gsub('?') { quote_bound_value(bound.shift, c) }
+      end
+
+      def replace_named_bind_variables(statement, bind_vars) #:nodoc:
+        statement.gsub(/(:?):([a-zA-Z]\w*)/) do
+          if $1 == ':' # skip postgresql casts
+            $& # return the whole match
+          elsif bind_vars.include?(match = $2.to_sym)
+            quote_bound_value(bind_vars[match])
+          else
+            raise PreparedStatementInvalid, "missing value for :#{match} in #{statement}"
+          end
+        end
+      end
+
+      def expand_range_bind_variables(bind_vars) #:nodoc:
+        expanded = []
+
+        bind_vars.each do |var|
+          next if var.is_a?(Hash)
+
+          if var.is_a?(Range)
+            expanded << var.first
+            expanded << var.last
+          else
+            expanded << var
+          end
+        end
+
+        expanded
+      end
+
+      def quote_bound_value(value, c = connection) #:nodoc:
+        if value.respond_to?(:map) && !value.acts_like?(:string)
+          if value.respond_to?(:empty?) && value.empty?
+            c.quote(nil)
+          else
+            value.map { |v| c.quote(v) }.join(',')
+          end
+        else
+          c.quote(value)
+        end
+      end
+
+      def raise_if_bind_arity_mismatch(statement, expected, provided) #:nodoc:
+        unless expected == provided
+          raise PreparedStatementInvalid, "wrong number of bind variables (#{provided} for #{expected}) in: #{statement}"
+        end
+      end
+    end
+
+    # TODO: Deprecate this
+    def quoted_id #:nodoc:
+      quote_value(id, column_for_attribute(self.class.primary_key))
+    end
+
+    private
+
+    # Quote strings appropriately for SQL statements.
+    def quote_value(value, column = nil)
+      self.class.connection.quote(value, column)
+    end
+  end
+end

data/lib/active_record/schema.rb

@@ -0,0 +1,58 @@
+require 'active_support/core_ext/object/blank'
+
+module ActiveRecord
+  # = Active Record Schema
+  #
+  # Allows programmers to programmatically define a schema in a portable
+  # DSL. This means you can define tables, indexes, etc. without using SQL
+  # directly, so your applications can more easily support multiple
+  # databases.
+  #
+  # Usage:
+  #
+  #   ActiveRecord::Schema.define do
+  #     create_table :authors do |t|
+  #       t.string :name, :null => false
+  #     end
+  #
+  #     add_index :authors, :name, :unique
+  #
+  #     create_table :posts do |t|
+  #       t.integer :author_id, :null => false
+  #       t.string :subject
+  #       t.text :body
+  #       t.boolean :private, :default => false
+  #     end
+  #
+  #     add_index :posts, :author_id
+  #   end
+  #
+  # ActiveRecord::Schema is only supported by database adapters that also
+  # support migrations, the two features being very similar.
+  class Schema < Migration
+    def migrations_paths
+      ActiveRecord::Migrator.migrations_paths
+    end
+
+    # Eval the given block. All methods available to the current connection
+    # adapter are available within the block, so you can easily use the
+    # database definition DSL to build up your schema (+create_table+,
+    # +add_index+, etc.).
+    #
+    # The +info+ hash is optional, and if given is used to define metadata
+    # about the current schema (currently, only the schema's version):
+    #
+    #   ActiveRecord::Schema.define(:version => 20380119000001) do
+    #     ...
+    #   end
+    def self.define(info={}, &block)
+      schema = new
+      schema.instance_eval(&block)
+
+      unless info[:version].blank?
+        initialize_schema_migrations_table
+        assume_migrated_upto_version(info[:version], schema.migrations_paths)
+      end
+    end
+  end
+end

data/lib/active_record/schema_dumper.rb

@@ -0,0 +1,204 @@
+require 'stringio'
+require 'active_support/core_ext/big_decimal'
+
+module ActiveRecord
+  # = Active Record Schema Dumper
+  #
+  # This class is used to dump the database schema for some connection to some
+  # output format (i.e., ActiveRecord::Schema).
+  class SchemaDumper #:nodoc:
+    private_class_method :new
+
+    ##
+    # :singleton-method:
+    # A list of tables which should not be dumped to the schema.
+    # Acceptable values are strings as well as regexp.
+    # This setting is only used if ActiveRecord::Base.schema_format == :ruby
+    cattr_accessor :ignore_tables
+    @@ignore_tables = []
+
+    def self.dump(connection=ActiveRecord::Base.connection, stream=STDOUT)
+      new(connection).dump(stream)
+      stream
+    end
+
+    def dump(stream)
+      header(stream)
+      tables(stream)
+      trailer(stream)
+      stream
+    end
+
+    private
+
+      def initialize(connection)
+        @connection = connection
+        @types = @connection.native_database_types
+        @version = Migrator::current_version rescue nil
+      end
+
+      def header(stream)
+        define_params = @version ? ":version => #{@version}" : ""
+
+        if stream.respond_to?(:external_encoding)
+          stream.puts "# encoding: #{stream.external_encoding.name}"
+        end
+
+        stream.puts <<HEADER
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# Note that this schema.rb definition is the authoritative source for your
+# database schema. If you need to create the application database on another
+# system, you should be using db:schema:load, not running all the migrations
+# from scratch. The latter is a flawed and unsustainable approach (the more migrations
+# you'll amass, the slower it'll run and the greater likelihood for issues).
+#
+# It's strongly recommended to check this file into your version control system.
+
+ActiveRecord::Schema.define(#{define_params}) do
+
+HEADER
+      end
+
+      def trailer(stream)
+        stream.puts "end"
+      end
+
+      def tables(stream)
+        @connection.tables.sort.each do |tbl|
+          next if ['schema_migrations', ignore_tables].flatten.any? do |ignored|
+            case ignored
+            when String; tbl == ignored
+            when Regexp; tbl =~ ignored
+            else
+              raise StandardError, 'ActiveRecord::SchemaDumper.ignore_tables accepts an array of String and / or Regexp values.'
+            end
+          end
+          table(tbl, stream)
+        end
+      end
+
+      def table(table, stream)
+        columns = @connection.columns(table)
+        begin
+          tbl = StringIO.new
+
+          # first dump primary key column
+          if @connection.respond_to?(:pk_and_sequence_for)
+            pk, _ = @connection.pk_and_sequence_for(table)
+          elsif @connection.respond_to?(:primary_key)
+            pk = @connection.primary_key(table)
+          end
+
+          tbl.print "  create_table #{table.inspect}"
+          if columns.detect { |c| c.name == pk }
+            if pk != 'id'
+              tbl.print %Q(, :primary_key => "#{pk}")
+            end
+          else
+            tbl.print ", :id => false"
+          end
+          tbl.print ", :force => true"
+          tbl.puts " do |t|"
+
+          # then dump all non-primary key columns
+          column_specs = columns.map do |column|
+            raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" if @types[column.type].nil?
+            next if column.name == pk
+            spec = {}
+            spec[:name]      = column.name.inspect
+
+            # AR has an optimization which handles zero-scale decimals as integers. This
+            # code ensures that the dumper still dumps the column as a decimal.
+            spec[:type]      = if column.type == :integer && [/^numeric/, /^decimal/].any? { |e| e.match(column.sql_type) }
+                                 'decimal'
+                               else
+                                 column.type.to_s
+                               end
+            spec[:limit]     = column.limit.inspect if column.limit != @types[column.type][:limit] && spec[:type] != 'decimal'
+            spec[:precision] = column.precision.inspect if column.precision
+            spec[:scale]     = column.scale.inspect if column.scale
+            spec[:null]      = 'false' unless column.null
+            spec[:default]   = default_string(column.default) if column.has_default?
+            (spec.keys - [:name, :type]).each{ |k| spec[k].insert(0, "#{k.inspect} => ")}
+            spec
+          end.compact
+
+          # find all migration keys used in this table
+          keys = [:name, :limit, :precision, :scale, :default, :null] & column_specs.map{ |k| k.keys }.flatten
+
+          # figure out the lengths for each column based on above keys
+          lengths = keys.map{ |key| column_specs.map{ |spec| spec[key] ? spec[key].length + 2 : 0 }.max }
+
+          # the string we're going to sprintf our values against, with standardized column widths
+          format_string = lengths.map{ |len| "%-#{len}s" }
+
+          # find the max length for the 'type' column, which is special
+          type_length = column_specs.map{ |column| column[:type].length }.max
+
+          # add column type definition to our format string
+          format_string.unshift "    t.%-#{type_length}s "
+
+          format_string *= ''
+
+          column_specs.each do |colspec|
+            values = keys.zip(lengths).map{ |key, len| colspec.key?(key) ? colspec[key] + ", " : " " * len }
+            values.unshift colspec[:type]
+            tbl.print((format_string % values).gsub(/,\s*$/, ''))
+            tbl.puts
+          end
+
+          tbl.puts "  end"
+          tbl.puts
+
+          indexes(table, tbl)
+
+          tbl.rewind
+          stream.print tbl.read
+        rescue => e
+          stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
+          stream.puts "#   #{e.message}"
+          stream.puts
+        end
+
+        stream
+      end
+
+      def default_string(value)
+        case value
+        when BigDecimal
+          value.to_s
+        when Date, DateTime, Time
+          "'" + value.to_s(:db) + "'"
+        else
+          value.inspect
+        end
+      end
+
+      def indexes(table, stream)
+        if (indexes = @connection.indexes(table)).any?
+          add_index_statements = indexes.map do |index|
+            statement_parts = [
+              ('add_index ' + index.table.inspect),
+              index.columns.inspect,
+              (':name => ' + index.name.inspect),
+            ]
+            statement_parts << ':unique => true' if index.unique
+
+            index_lengths = (index.lengths || []).compact
+            statement_parts << (':length => ' + Hash[index.columns.zip(index.lengths)].inspect) unless index_lengths.empty?
+
+            index_orders = (index.orders || {})
+            statement_parts << (':order => ' + index.orders.inspect) unless index_orders.empty?
+
+            '  ' + statement_parts.join(', ')
+          end
+
+          stream.puts add_index_statements.sort.join("\n")
+          stream.puts
+        end
+      end
+  end
+end