arel 0.1.0 → 0.1.2

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

@@ -3,10 +3,12 @@ module Arel
     def relation
       nil
     end
-    
+
     def to_sql(formatter = nil)
       self
     end
+
+    include Attribute::Expressions
   end
 
   class Attribute
@@ -28,7 +30,13 @@ module Arel
   end
 
   class Value
-    delegate :inclusion_predicate_sql, :equality_predicate_sql, :to => :value
+    def inclusion_predicate_sql
+      value.inclusion_predicate_sql
+    end
+
+    def equality_predicate_sql
+      value.equality_predicate_sql
+    end
 
     def to_sql(formatter = Sql::WhereCondition.new(relation))
       formatter.value value

data/lib/arel/engines/sql/relations/operations/join.rb

@@ -26,8 +26,8 @@ module Arel
   end
 
   class StringJoin < Join
-    def joins(_, __ = nil)
-      relation2
+    def joins(environment, formatter = Sql::TableReference.new(environment))
+       [relation1.joins(environment), relation2].compact.join(" ")
     end
   end
 end

data/lib/arel/engines/sql/relations/relation.rb

@@ -5,15 +5,36 @@ module Arel
     end
 
     def select_sql
-      build_query \
-        "SELECT     #{select_clauses.join(', ')}",
-        "FROM       #{table_sql(Sql::TableReference.new(self))}",
-        (joins(self)                                   unless joins(self).blank? ),
-        ("WHERE     #{where_clauses.join("\n\tAND ")}" unless wheres.blank?      ),
-        ("GROUP BY  #{group_clauses.join(', ')}"       unless groupings.blank?   ),
-        ("ORDER BY  #{order_clauses.join(', ')}"       unless orders.blank?      ),
-        ("LIMIT     #{taken}"                          unless taken.blank?       ),
-        ("OFFSET    #{skipped}"                        unless skipped.blank?     )
+      if engine.adapter_name == "PostgreSQL" && !orders.blank? && using_distinct_on?
+        # PostgreSQL does not allow arbitrary ordering when using DISTINCT ON, so we work around this
+        # by wrapping the +sql+ string as a sub-select and ordering in that query.
+        order = order_clauses.join(', ').split(',').map { |s| s.strip }.reject(&:blank?)
+        order = order.zip((0...order.size).to_a).map { |s,i| "id_list.alias_#{i} #{'DESC' if s =~ /\bdesc$/i}" }.join(', ')
+
+        query = build_query \
+          "SELECT     #{select_clauses.to_s}",
+          "FROM       #{table_sql(Sql::TableReference.new(self))}",
+          (joins(self)                                   unless joins(self).blank? ),
+          ("WHERE     #{where_clauses.join("\n\tAND ")}" unless wheres.blank?      ),
+          ("GROUP BY  #{group_clauses.join(', ')}"       unless groupings.blank?   )
+
+        build_query \
+          "SELECT * FROM (#{query}) AS id_list",
+          "ORDER BY #{order}",
+          ("LIMIT     #{taken}"                          unless taken.blank?       ),
+          ("OFFSET    #{skipped}"                        unless skipped.blank?     )
+
+      else
+        build_query \
+          "SELECT     #{select_clauses.join(', ')}",
+          "FROM       #{table_sql(Sql::TableReference.new(self))}",
+          (joins(self)                                   unless joins(self).blank? ),
+          ("WHERE     #{where_clauses.join("\n\tAND ")}" unless wheres.blank?      ),
+          ("GROUP BY  #{group_clauses.join(', ')}"       unless groupings.blank?   ),
+          ("ORDER BY  #{order_clauses.join(', ')}"       unless orders.blank?      ),
+          ("LIMIT     #{taken}"                          unless taken.blank?       ),
+          ("OFFSET    #{skipped}"                        unless skipped.blank?     )
+      end
     end
 
     def inclusion_predicate_sql
@@ -46,5 +67,8 @@ module Arel
       orders.collect { |o| o.to_sql(Sql::OrderClause.new(self)) }
     end
 
+    def using_distinct_on?
+      select_clauses.any? { |x| x =~ /DISTINCT ON/ }
+    end
   end
 end

data/lib/arel/engines/sql/relations/writes.rb

@@ -1,6 +1,6 @@
 module Arel
   class Deletion < Compound
-    def to_sql(formatter = nil)
+    def to_sql
       build_query \
         "DELETE",
         "FROM #{table_sql}",
@@ -10,30 +10,61 @@ module Arel
   end
 
   class Insert < Compound
-    def to_sql(formatter = nil)
+    def to_sql
+      insertion_attributes_values_sql = if record.is_a?(Value)
+        record.value
+      else
+        build_query "(#{record.keys.collect { |key| engine.quote_column_name(key.name) }.join(', ')})",
+          "VALUES (#{record.collect { |key, value| key.format(value) }.join(', ')})"
+      end
+
       build_query \
         "INSERT",
         "INTO #{table_sql}",
-        "(#{record.keys.collect { |key| engine.quote_column_name(key.name) }.join(', ')})",
-        "VALUES (#{record.collect { |key, value| key.format(value) }.join(', ')})"
+        insertion_attributes_values_sql
     end
   end
 
   class Update < Compound
-    def to_sql(formatter = nil)
+    def to_sql
       build_query \
         "UPDATE #{table_sql} SET",
         assignment_sql,
-        ("WHERE #{wheres.collect(&:to_sql).join('\n\tAND ')}"  unless wheres.blank? ),
-        ("LIMIT #{taken}"                                      unless taken.blank?  )
+        build_update_conditions_sql
     end
 
   protected
 
     def assignment_sql
-      assignments.collect do |attribute, value|
-        "#{engine.quote_column_name(attribute.name)} = #{attribute.format(value)}"
-      end.join(",\n")
+      if assignments.respond_to?(:collect)
+        assignments.collect do |attribute, value|
+          "#{engine.quote_column_name(attribute.name)} = #{attribute.format(value)}"
+        end.join(",\n")
+      else
+        assignments.value
+      end
+    end
+
+    def build_update_conditions_sql
+      conditions = ""
+      conditions << " WHERE #{wheres.collect(&:to_sql).join('\n\tAND ')}" unless wheres.blank?
+      conditions << " ORDER BY #{order_clauses.join(', ')}" unless orders.blank?
+
+      unless taken.blank?
+        conditions << " LIMIT #{taken}"
+
+        if engine.adapter_name != "MySQL"
+          begin
+            quote_primary_key = engine.quote_column_name(table.name.classify.constantize.primary_key)
+          rescue NameError
+            quote_primary_key = engine.quote_column_name("id")
+          end
+
+          conditions =  "WHERE #{quote_primary_key} IN (SELECT #{quote_primary_key} FROM #{engine.connection.quote_table_name table.name} #{conditions})"
+        end
+      end
+
+      conditions
     end
   end
 end

data/lib/arel/session.rb

@@ -5,16 +5,22 @@ module Arel
       alias_method :manufacture, :new
 
       def start
-        if @started
+        if defined?(@started) && @started
           yield
         else
           begin
             @started = true
             @instance = manufacture
-            metaclass.send :alias_method, :new, :instance
+            metaclass.class_eval do
+              undef :new
+              alias_method :new, :instance
+            end
             yield
           ensure
-            metaclass.send :alias_method, :new, :manufacture
+            metaclass.class_eval do
+              undef :new
+              alias_method :new, :manufacture
+            end
             @started = false
           end
         end
@@ -24,7 +30,6 @@ module Arel
     module CRUD
       def create(insert)
         insert.call
-        insert
       end
 
       def read(select)
@@ -35,12 +40,10 @@ module Arel
 
       def update(update)
         update.call
-        update
       end
 
       def delete(delete)
         delete.call
-        delete
       end
     end
     include CRUD

data/spec/arel/algebra/unit/predicates/binary_spec.rb

@@ -1,31 +1,33 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'spec_helper')
+require 'spec_helper'
 
 module Arel
-  describe Binary do
-    before do
-      @relation = Table.new(:users)
-      @attribute1 = @relation[:id]
-      @attribute2 = @relation[:name]
-      class ConcreteBinary < Binary
-      end
-    end
-
-    describe '#bind' do
+  module Predicates
+    describe Binary do
       before do
-        @another_relation = @relation.alias
+        @relation = Table.new(:users)
+        @attribute1 = @relation[:id]
+        @attribute2 = @relation[:name]
+        class ConcreteBinary < Binary
+        end
       end
 
-      describe 'when both operands are attributes' do
-        it "manufactures an expression with the attributes bound to the relation" do
-          ConcreteBinary.new(@attribute1, @attribute2).bind(@another_relation). \
-            should == ConcreteBinary.new(@another_relation[@attribute1], @another_relation[@attribute2])
+      describe '#bind' do
+        before do
+          @another_relation = @relation.alias
+        end
+
+        describe 'when both operands are attributes' do
+          it "manufactures an expression with the attributes bound to the relation" do
+            ConcreteBinary.new(@attribute1, @attribute2).bind(@another_relation). \
+              should == ConcreteBinary.new(@another_relation[@attribute1], @another_relation[@attribute2])
+          end
         end
-      end
 
-      describe 'when an operand is a value' do
-        it "manufactures an expression with unmodified values" do
-          ConcreteBinary.new(@attribute1, "asdf").bind(@another_relation). \
-            should == ConcreteBinary.new(@attribute1.find_correlate_in(@another_relation), "asdf".find_correlate_in(@another_relation))
+        describe 'when an operand is a value' do
+          it "manufactures an expression with unmodified values" do
+            ConcreteBinary.new(@attribute1, "asdf").bind(@another_relation). \
+              should == ConcreteBinary.new(@attribute1.find_correlate_in(@another_relation), "asdf".find_correlate_in(@another_relation))
+          end
         end
       end
     end

data/spec/arel/algebra/unit/predicates/equality_spec.rb

@@ -1,26 +1,28 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'spec_helper')
+require 'spec_helper'
 
 module Arel
-  describe Equality do
-    before do
-      @relation1 = Table.new(:users)
-      @relation2 = Table.new(:photos)
-      @attribute1 = @relation1[:id]
-      @attribute2 = @relation2[:user_id]
-    end
-
-    describe '==' do
-      it "obtains if attribute1 and attribute2 are identical" do
-        Equality.new(@attribute1, @attribute2).should == Equality.new(@attribute1, @attribute2)
-        Equality.new(@attribute1, @attribute2).should_not == Equality.new(@attribute1, @attribute1)
+  module Predicates
+    describe Equality do
+      before do
+        @relation1 = Table.new(:users)
+        @relation2 = Table.new(:photos)
+        @attribute1 = @relation1[:id]
+        @attribute2 = @relation2[:user_id]
       end
 
-      it "obtains if the concrete type of the predicates are identical" do
-        Equality.new(@attribute1, @attribute2).should_not == Binary.new(@attribute1, @attribute2)
-      end
+      describe '==' do
+        it "obtains if attribute1 and attribute2 are identical" do
+          check Equality.new(@attribute1, @attribute2).should == Equality.new(@attribute1, @attribute2)
+          Equality.new(@attribute1, @attribute2).should_not == Equality.new(@attribute1, @attribute1)
+        end
+
+        it "obtains if the concrete type of the predicates are identical" do
+          Equality.new(@attribute1, @attribute2).should_not == Binary.new(@attribute1, @attribute2)
+        end
 
-      it "is commutative on the attributes" do
-        Equality.new(@attribute1, @attribute2).should == Equality.new(@attribute2, @attribute1)
+        it "is commutative on the attributes" do
+          Equality.new(@attribute1, @attribute2).should == Equality.new(@attribute2, @attribute1)
+        end
       end
     end
   end

data/spec/arel/algebra/unit/predicates/in_spec.rb

@@ -1,10 +1,12 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'spec_helper')
+require 'spec_helper'
 
 module Arel
-  describe In do
-    before do
-      @relation = Table.new(:users)
-      @attribute = @relation[:id]
+  module Predicates
+    describe In do
+      before do
+        @relation = Table.new(:users)
+        @attribute = @relation[:id]
+      end
     end
   end
 end

data/spec/arel/algebra/unit/primitives/attribute_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'spec_helper')
+require 'spec_helper'
 
 module Arel
   describe Attribute do
@@ -73,10 +73,8 @@ module Arel
 
         describe 'when dividing two matching attributes' do
           it 'returns a the highest score for the most similar attributes' do
-            (@aliased_relation[:id] / @relation[:id]) \
-              .should == (@aliased_relation[:id] / @relation[:id])
-            (@aliased_relation[:id] / @relation[:id]) \
-              .should < (@aliased_relation[:id] / @aliased_relation[:id])
+            check((@aliased_relation[:id] / @relation[:id]).should == (@aliased_relation[:id] / @relation[:id]))
+            (@aliased_relation[:id] / @relation[:id]).should < (@aliased_relation[:id] / @aliased_relation[:id])
           end
         end
       end
@@ -89,43 +87,43 @@ module Arel
 
       describe '#eq' do
         it "manufactures an equality predicate" do
-          @attribute.eq('name').should == Equality.new(@attribute, 'name')
+          @attribute.eq('name').should == Predicates::Equality.new(@attribute, 'name')
         end
       end
 
       describe '#lt' do
         it "manufactures a less-than predicate" do
-          @attribute.lt(10).should == LessThan.new(@attribute, 10)
+          @attribute.lt(10).should == Predicates::LessThan.new(@attribute, 10)
         end
       end
 
       describe '#lteq' do
         it "manufactures a less-than or equal-to predicate" do
-          @attribute.lteq(10).should == LessThanOrEqualTo.new(@attribute, 10)
+          @attribute.lteq(10).should == Predicates::LessThanOrEqualTo.new(@attribute, 10)
         end
       end
 
       describe '#gt' do
         it "manufactures a greater-than predicate" do
-          @attribute.gt(10).should == GreaterThan.new(@attribute, 10)
+          @attribute.gt(10).should == Predicates::GreaterThan.new(@attribute, 10)
         end
       end
 
       describe '#gteq' do
         it "manufactures a greater-than or equal-to predicate" do
-          @attribute.gteq(10).should == GreaterThanOrEqualTo.new(@attribute, 10)
+          @attribute.gteq(10).should == Predicates::GreaterThanOrEqualTo.new(@attribute, 10)
         end
       end
 
       describe '#matches' do
         it "manufactures a match predicate" do
-          @attribute.matches(/.*/).should == Match.new(@attribute, /.*/)
+          @attribute.matches(/.*/).should == Predicates::Match.new(@attribute, /.*/)
         end
       end
 
       describe '#in' do
         it "manufactures an in predicate" do
-          @attribute.in(1..30).should == In.new(@attribute, (1..30))
+          @attribute.in(1..30).should == Predicates::In.new(@attribute, (1..30))
         end
       end
     end

data/spec/arel/algebra/unit/primitives/expression_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'spec_helper')
+require 'spec_helper'
 
 module Arel
   describe Expression do

data/spec/arel/algebra/unit/primitives/value_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'spec_helper')
+require 'spec_helper'
 
 module Arel
   describe Value do

data/spec/arel/algebra/unit/relations/alias_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'spec_helper')
+require 'spec_helper'
 
 module Arel
   describe Alias do
@@ -8,7 +8,7 @@ module Arel
 
     describe '==' do
       it "obtains if the objects are the same" do
-        Alias.new(@relation).should_not == Alias.new(@relation)
+        check Alias.new(@relation).should_not == Alias.new(@relation)
         (aliaz = Alias.new(@relation)).should == aliaz
       end
     end

data/spec/arel/algebra/unit/relations/delete_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'spec_helper')
+require 'spec_helper'
 
 module Arel
   describe Deletion do