arel 0.3.1 → 0.3.2

data/lib/arel.rb

@@ -1,11 +1,12 @@
 require 'active_support/inflector'
-require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/object/blank'
 
 module Arel
   require 'arel/algebra'
   require 'arel/engines'
-  autoload :Session, 'arel/session'
+  require 'arel/version'
 
-  VERSION = "0.3.1"
+  autoload :Session, 'arel/session'
 end

data/lib/arel/algebra.rb

@@ -1,6 +1,6 @@
 require 'arel/algebra/core_extensions'
 
-require 'arel/algebra/attribute'
+require 'arel/algebra/attributes'
 require 'arel/algebra/expression'
 require 'arel/algebra/ordering'
 require 'arel/algebra/predicates'

data/lib/arel/algebra/attributes.rb

@@ -0,0 +1,7 @@
+require "arel/algebra/attributes/attribute"
+require "arel/algebra/attributes/boolean"
+require "arel/algebra/attributes/decimal"
+require "arel/algebra/attributes/float"
+require "arel/algebra/attributes/integer"
+require "arel/algebra/attributes/string"
+require "arel/algebra/attributes/time"

data/lib/arel/algebra/{attribute.rb → attributes/attribute.rb}

@@ -1,6 +1,7 @@
 require 'set'
 
 module Arel
+  class TypecastError < StandardError ; end
   class Attribute
     attributes :relation, :name, :alias, :ancestor
     deriving :==
@@ -85,6 +86,10 @@ module Arel
         Predicates::Equality.new(self, other)
       end
 
+      def not(other)
+        Predicates::Not.new(self, other)
+      end
+
       def lt(other)
         Predicates::LessThan.new(self, other)
       end
@@ -146,5 +151,32 @@ module Arel
       alias_method :to_ordering, :asc
     end
     include Orderings
+
+    module Types
+      def type_cast(value)
+        if root == self
+          raise NotImplementedError, "#type_cast should be implemented in a subclass."
+        else
+          root.type_cast(value)
+        end
+      end
+
+      def type_cast_to_numeric(value, method)
+        return unless value
+        if value.respond_to?(:to_str)
+          str = value.to_str.strip
+          return if str.empty?
+          return $1.send(method) if str =~ /\A(-?(?:0|[1-9]\d*)(?:\.\d+)?|(?:\.\d+))\z/
+        elsif value.respond_to?(method)
+          return value.send(method)
+        end
+        raise typecast_error(value)
+      end
+
+      def typecast_error(value)
+        raise TypecastError, "could not typecast #{value.inspect} to #{self.class.name.split('::').last}"
+      end
+    end
+    include Types
   end
 end

data/lib/arel/algebra/attributes/boolean.rb

@@ -0,0 +1,21 @@
+module Arel
+  module Attributes
+    class Boolean < Attribute
+      def type_cast(value)
+        case value
+        when true, false then value
+        # when nil            then options[:allow_nil] ? nil : false
+        when nil         then false
+        when 1           then true
+        when 0           then false
+        else
+          case value.to_s.downcase.strip
+          when 'true'  then true
+          when 'false' then false
+          else         raise typecast_error(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/arel/algebra/attributes/decimal.rb

@@ -0,0 +1,9 @@
+module Arel
+  module Attributes
+    class Decimal < Attribute
+      def type_cast(val)
+        type_cast_to_numeric(val, :to_d)
+      end
+    end
+  end
+end

data/lib/arel/algebra/attributes/float.rb

@@ -0,0 +1,9 @@
+module Arel
+  module Attributes
+    class Float < Attribute
+      def type_cast(val)
+        type_cast_to_numeric(val, :to_f)
+      end
+    end
+  end
+end

data/lib/arel/algebra/attributes/integer.rb

@@ -0,0 +1,10 @@
+module Arel
+  module Attributes
+    class Integer < Attribute
+      def type_cast(val)
+        type_cast_to_numeric(val, :to_i)
+      end
+    end
+  end
+end
+    

data/lib/arel/algebra/attributes/string.rb

@@ -0,0 +1,10 @@
+module Arel
+  module Attributes
+    class String < Attribute
+      def type_cast(value)
+        return unless value
+        value.to_s
+      end
+    end
+  end
+end

data/lib/arel/algebra/attributes/time.rb

@@ -0,0 +1,6 @@
+module Arel
+  module Attributes
+    class Time < Attribute
+    end
+  end
+end

data/lib/arel/algebra/predicates.rb

@@ -33,6 +33,7 @@ module Arel
       end
     end
 
+    class Not                   < Binary; end
     class GreaterThanOrEqualTo  < Binary; end
     class GreaterThan           < Binary; end
     class LessThanOrEqualTo     < Binary; end

data/lib/arel/algebra/relations/operations/join.rb

@@ -1,5 +1,7 @@
 module Arel
-  class Join < Relation
+  class Join
+    include Relation
+
     attributes :relation1, :relation2, :predicates
     deriving :==
     delegate :name, :to => :relation1
@@ -60,7 +62,7 @@ module Arel
     end
   end
 
-  class Relation
+  module Relation
     def join?
       false
     end

data/lib/arel/algebra/relations/operations/order.rb

@@ -1,7 +1,8 @@
 module Arel
   class Order < Compound
     attributes :relation, :orderings
-    deriving :==
+    deriving   :==
+    requires   :ordering
 
     def initialize(relation, *orderings, &block)
       @relation = relation

data/lib/arel/algebra/relations/operations/skip.rb

@@ -1,6 +1,7 @@
 module Arel
   class Skip < Compound
     attributes :relation, :skipped
-    deriving :initialize, :==
+    deriving   :initialize, :==
+    requires   :skipping
   end
 end

data/lib/arel/algebra/relations/operations/take.rb

@@ -1,7 +1,8 @@
 module Arel
   class Take < Compound
     attributes :relation, :taken
-    deriving :initialize, :==
+    deriving   :initialize, :==
+    requires   :limiting
 
     def externalizable?
       true

data/lib/arel/algebra/relations/operations/where.rb

@@ -1,16 +1,17 @@
 module Arel
   class Where < Compound
-    attributes :relation, :predicate
-    deriving :==
+    attributes :relation, :predicates
+    deriving   :==
+    requires   :restricting
 
     def initialize(relation, *predicates, &block)
-      predicate = block_given?? yield(relation) : predicates.shift
-      @relation = predicates.empty?? relation : Where.new(relation, *predicates)
-      @predicate = predicate.bind(@relation)
+      predicates = [yield(relation)] + predicates if block_given?
+      @predicates = predicates.map { |p| p.bind(relation) }
+      @relation   = relation
     end
 
     def wheres
-      @wheres ||= (relation.wheres + [predicate]).collect { |p| p.bind(self) }
+      @wheres ||= relation.wheres + predicates
     end
   end
 end

data/lib/arel/algebra/relations/relation.rb

@@ -1,5 +1,5 @@
 module Arel
-  class Relation
+  module Relation
     attr_reader :count
 
     def session
@@ -128,6 +128,7 @@ module Arel
 
     module DefaultOperations
       def attributes;             []  end
+      def projections;            []  end
       def wheres;                 []  end
       def orders;                 []  end
       def inserts;                []  end

data/lib/arel/algebra/relations/utilities/compound.rb

@@ -1,11 +1,19 @@
 module Arel
-  class Compound < Relation
+  class Compound
+    include Relation
+
     attr_reader :relation
     delegate :joins, :join?, :inserts, :taken, :skipped, :name, :externalizable?,
              :column_for, :engine, :sources, :locked, :table_alias,
              :to => :relation
 
-    [:attributes, :wheres, :groupings, :orders, :havings].each do |operation_name|
+    def self.requires(feature = nil)
+      @requires ||= nil
+      @requires = feature if feature
+      @requires
+    end
+
+    [:attributes, :wheres, :groupings, :orders, :havings, :projections].each do |operation_name|
       class_eval <<-OPERATION, __FILE__, __LINE__
         def #{operation_name}
           @#{operation_name} ||= relation.#{operation_name}.collect { |o| o.bind(self) }
@@ -21,6 +29,18 @@ module Arel
       self == other
     end
 
+    def engine
+      requires = self.class.requires
+      engine   = relation.engine
+
+      # Temporary check of whether or not the engine supports where.
+      if requires && engine.respond_to?(:supports) && !engine.supports(requires)
+        Memory::Engine.new
+      else
+        engine
+      end
+    end
+
   private
 
     def arguments_from_block(relation, &block)

data/lib/arel/algebra/relations/utilities/externalization.rb

@@ -12,7 +12,7 @@ module Arel
     end
   end
 
-  class Relation
+  module Relation
     def externalize
       @externalized ||= externalizable?? Externalization.new(self) : self
     end

data/lib/arel/algebra/relations/utilities/nil.rb

@@ -1,7 +1,7 @@
 require 'singleton'
 
 module Arel
-  class Nil < Relation
-    include Singleton
+  class Nil
+    include Relation, Singleton
   end
 end

data/lib/arel/engines/memory/predicates.rb

@@ -10,6 +10,12 @@ module Arel
       def operator; :== end
     end
 
+    class Not < Binary
+      def eval(row)
+        operand1.eval(row) != operand2.eval(row)
+      end
+    end
+
     class GreaterThanOrEqualTo < Binary
       def operator; :>= end
     end

data/lib/arel/engines/memory/relations/array.rb

@@ -1,16 +1,23 @@
 module Arel
-  class Array < Relation
-    attributes :array,  :attribute_names
+  class Array
+    include Relation
+
+    attributes :array,  :attribute_names_and_types
     include Recursion::BaseCase
     deriving :==, :initialize
 
+    def initialize(array, attribute_names_and_types)
+      @array, @attribute_names_and_types = array, attribute_names_and_types
+    end
+
     def engine
       @engine ||= Memory::Engine.new
     end
 
     def attributes
-      @attributes ||= @attribute_names.collect do |name|
-        name.to_attribute(self)
+      @attributes ||= @attribute_names_and_types.collect do |attribute, type|
+        attribute = type.new(self, attribute) if Symbol === attribute
+        attribute
       end
     end
 

data/lib/arel/engines/memory/relations/compound.rb

@@ -1,5 +1,5 @@
 module Arel
-  class Compound < Relation
+  class Compound
     delegate :array, :to => :relation
 
     def unoperated_rows

data/lib/arel/engines/memory/relations/operations.rb

@@ -1,7 +1,7 @@
 module Arel
   class Where < Compound
     def eval
-      unoperated_rows.select { |row| predicate.eval(row) }
+      unoperated_rows.select { |row| predicates.all? { |p| p.eval(row) } }
     end
   end
 
@@ -50,7 +50,7 @@ module Arel
     end
   end
 
-  class Join < Relation
+  class Join
     def eval
       result = []
       relation1.call.each do |row1|

data/lib/arel/engines/sql.rb

@@ -1,3 +1,4 @@
+require 'arel/engines/sql/attributes'
 require 'arel/engines/sql/engine'
 require 'arel/engines/sql/relations'
 require 'arel/engines/sql/primitives'

data/lib/arel/engines/sql/attributes.rb

@@ -0,0 +1,40 @@
+module Arel
+  module Sql
+    module Attributes
+      def self.for(column)
+        case column.type
+        when :string    then String
+        when :text      then String
+        when :integer   then Integer
+        when :float     then Float
+        when :decimal   then Decimal
+        when :date      then Time
+        when :datetime  then Time
+        when :timestamp then Time
+        when :time      then Time
+        when :binary    then String
+        when :boolean   then Boolean
+        else
+          raise NotImplementedError, "Column type `#{column.type}` is not currently handled"
+        end
+      end
+
+      def initialize(column, *args)
+        @column = column
+        super(*args)
+      end
+
+      def type_cast(value)
+        @column.type_cast(value)
+      end
+
+      %w(Boolean Decimal Float Integer String Time).each do |klass|
+        class_eval <<-R
+          class #{klass} < Arel::Attributes::#{klass}
+            include Attributes
+          end
+        R
+      end
+    end
+  end
+end

data/lib/arel/engines/sql/compilers/ibm_db_compiler.rb

@@ -31,20 +31,6 @@ module Arel
   module SqlCompiler
     class IBM_DBCompiler < GenericCompiler
 
-      def select_sql
-        query = build_query \
-          "SELECT     #{select_clauses.join(', ')}",
-          "FROM       #{from_clauses}",
-          (joins(self)                                   unless joins(self).blank? ),
-          ("WHERE     #{where_clauses.join(" AND ")}"    unless wheres.blank?      ),
-          ("GROUP BY  #{group_clauses.join(', ')}"       unless groupings.blank?   ),
-          ("HAVING    #{having_clauses.join(', ')}"      unless havings.blank?     ),
-          ("ORDER BY  #{order_clauses.join(', ')}"       unless orders.blank?      )
-          engine.add_limit_offset!(query,{:limit=>taken,:offset=>skipped}) unless taken.blank?
-          query << "#{locked}" unless locked.blank?
-          query
-      end
-
       def limited_update_conditions(conditions, taken)
         quoted_primary_key = engine.quote_table_name(primary_key)
         update_conditions = "WHERE #{quoted_primary_key} IN (SELECT #{quoted_primary_key} FROM #{engine.connection.quote_table_name table.name} #{conditions} " #Note: - ')' not added, limit segment is to be appended