arel 0.2.1 → 0.3.0

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

@@ -0,0 +1,118 @@
+module Arel
+  module SqlCompiler
+    class GenericCompiler
+      attr_reader :relation
+
+      def initialize(relation)
+        @relation = relation
+      end
+
+      def select_sql
+        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?      ),
+          ("LIMIT     #{taken}"                          unless taken.blank?       ),
+          ("OFFSET    #{skipped}"                        unless skipped.blank?     ),
+          ("#{locked}"                                   unless locked.blank?)
+      end
+
+      def delete_sql
+        build_query \
+          "DELETE",
+          "FROM #{table_sql}",
+          ("WHERE #{wheres.collect(&:to_sql).join(' AND ')}" unless wheres.blank? ),
+          (add_limit_on_delete(taken)                        unless taken.blank?  )
+      end
+
+      def add_limit_on_delete(taken)
+        "LIMIT #{taken}"
+      end
+
+      def insert_sql(include_returning = true)
+        insertion_attributes_values_sql = if record.is_a?(Value)
+          record.value
+        else
+          attributes = record.keys.sort_by do |attribute|
+            attribute.name.to_s
+          end
+
+          first = attributes.collect do |key|
+            engine.quote_column_name(key.name)
+          end.join(', ')
+
+          second = attributes.collect do |key|
+            key.format(record[key])
+          end.join(', ')
+
+          build_query "(#{first})", "VALUES (#{second})"
+        end
+
+        build_query \
+          "INSERT",
+          "INTO #{table_sql}",
+          insertion_attributes_values_sql,
+          ("RETURNING #{engine.quote_column_name(primary_key)}" if include_returning && compiler.supports_insert_with_returning?)
+      end
+
+      def supports_insert_with_returning?
+        false
+      end
+
+      def update_sql
+        build_query \
+          "UPDATE #{table_sql} SET",
+          assignment_sql,
+          build_update_conditions_sql
+      end
+
+    protected
+      def method_missing(method, *args, &block)
+        relation.send(method, *args, &block)
+      end
+
+      def build_query(*parts)
+        parts.compact.join(" ")
+      end
+
+      def assignment_sql
+        if assignments.respond_to?(:collect)
+          attributes = assignments.keys.sort_by do |attribute|
+            attribute.name.to_s
+          end
+
+          attributes.map do |attribute|
+            value = assignments[attribute]
+            "#{engine.quote_column_name(attribute.name)} = #{attribute.format(value)}"
+          end.join(", ")
+        else
+          assignments.value
+        end
+      end
+
+      def build_update_conditions_sql
+        conditions = ""
+        conditions << " WHERE #{wheres.collect(&:to_sql).join(' AND ')}" unless wheres.blank?
+        conditions << " ORDER BY #{order_clauses.join(', ')}" unless orders.blank?
+
+        unless taken.blank?
+          conditions = limited_update_conditions(conditions, taken)
+        end
+
+        conditions
+      end
+
+      def limited_update_conditions(conditions, taken)
+        conditions << " LIMIT #{taken}"
+        quoted_primary_key = engine.quote_column_name(primary_key)
+        "WHERE #{quoted_primary_key} IN (SELECT #{quoted_primary_key} FROM #{engine.connection.quote_table_name table.name} #{conditions})"
+      end
+
+    end
+
+  end
+end

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

@@ -1,86 +1,61 @@
 module Arel
   class Relation
-    def to_sql(formatter = Sql::SelectStatement.new(self))
-      formatter.select select_sql, self
-    end
-
-    def select_sql
-      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.kind_of?(::Array) ? select_clauses.join("") : select_clauses.to_s}",
-          "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?   ),
-          ("#{locked}"                                   unless locked.blank?     )
+    @@connection_tables_primary_keys = {}
 
-        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       #{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?      ),
-          ("LIMIT     #{taken}"                          unless taken.blank?       ),
-          ("OFFSET    #{skipped}"                        unless skipped.blank?     ),
-          ("#{locked}"                                   unless engine.adapter_name =~ /SQLite/ || locked.blank?)
+    def compiler
+      @compiler ||=  begin
+        "Arel::SqlCompiler::#{engine.adapter_name}Compiler".constantize.new(self)
+      rescue
+        Arel::SqlCompiler::GenericCompiler.new(self)
       end
     end
 
-    def inclusion_predicate_sql
-      "IN"
+    def to_sql(formatter = Sql::SelectStatement.new(self))
+      formatter.select compiler.select_sql, self
     end
 
     def christener
       @christener ||= Sql::Christener.new
     end
 
-  protected
-
-    def build_query(*parts)
-      parts.compact.join(" ")
+    def inclusion_predicate_sql
+      "IN"
     end
 
-    def from_clauses
-      sources.blank? ? table_sql(Sql::TableReference.new(self)) : sources
+    def primary_key
+      connection_id = engine.connection.object_id
+      if @@connection_tables_primary_keys[connection_id] && @@connection_tables_primary_keys[connection_id].has_key?(table.name)
+        @@connection_tables_primary_keys[connection_id][table.name]
+      else
+        @@connection_tables_primary_keys[connection_id] ||= {}
+        @@connection_tables_primary_keys[connection_id][table.name] = engine.connection.primary_key(table.name)
+      end
     end
 
-    def select_clauses
-      attributes.collect { |a| a.to_sql(Sql::SelectClause.new(self)) }
-    end
+    protected
 
-    def where_clauses
-      wheres.collect { |w| w.to_sql(Sql::WhereClause.new(self)) }
-    end
+      def from_clauses
+        sources.blank? ? table_sql(Sql::TableReference.new(self)) : sources
+      end
 
-    def group_clauses
-      groupings.collect { |g| g.to_sql(Sql::GroupClause.new(self)) }
-    end
+      def select_clauses
+        attributes.collect { |a| a.to_sql(Sql::SelectClause.new(self)) }
+      end
 
-    def having_clauses
-      havings.collect { |g| g.to_sql(Sql::HavingClause.new(self)) }
-    end
+      def where_clauses
+        wheres.collect { |w| w.to_sql(Sql::WhereClause.new(self)) }
+      end
 
-    def order_clauses
-      orders.collect { |o| o.to_sql(Sql::OrderClause.new(self)) }
-    end
+      def group_clauses
+        groupings.collect { |g| g.to_sql(Sql::GroupClause.new(self)) }
+      end
 
-    def using_distinct_on?
-      select_clauses.any? { |x| x =~ /DISTINCT ON/ }
-    end
+      def having_clauses
+        havings.collect { |g| g.to_sql(Sql::HavingClause.new(self)) }
+      end
+
+      def order_clauses
+        orders.collect { |o| o.to_sql(Sql::OrderClause.new(self)) }
+      end
   end
 end

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

@@ -2,7 +2,7 @@ module Arel
   class Table < Relation
     include Recursion::BaseCase
 
-    cattr_accessor :engine
+    cattr_accessor :engine, :tables
     attr_reader :name, :engine, :table_alias, :options
 
     def initialize(name, options = {})
@@ -15,15 +15,35 @@ module Arel
       else
         @engine = options # Table.new('foo', engine)
       end
+
+      if @engine.connection
+        begin
+          require "arel/engines/sql/compilers/#{@engine.adapter_name.downcase}_compiler"
+          @@tables ||= engine.tables
+        rescue LoadError
+          raise "#{@engine.adapter_name} is not supported by Arel."
+        end
+      end
     end
 
     def as(table_alias)
       Table.new(name, options.merge(:as => table_alias))
     end
 
+    def table_exists?
+      if @table_exists
+        true
+      else
+        @table_exists = @@tables.include?(name) || engine.table_exists?(name)
+      end
+    end
+
     def attributes
-      @attributes ||= columns.collect do |column|
-        Attribute.new(self, column.name.to_sym)
+      return @attributes if defined?(@attributes)
+      if table_exists?
+        @attributes = columns.collect { |column| Attribute.new(self, column.name.to_sym) }
+      else
+        []
       end
     end
 

data/lib/arel/engines/sql/relations/utilities/externalization.rb

@@ -3,7 +3,7 @@ module Arel
     include Recursion::BaseCase
 
     def table_sql(formatter = Sql::TableReference.new(relation))
-      formatter.select relation.select_sql, self
+      formatter.select relation.compiler.select_sql, self
     end
 
     # REMOVEME

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

@@ -1,86 +1,19 @@
 module Arel
   class Deletion < Compound
     def to_sql
-      build_query \
-        "DELETE",
-        "FROM #{table_sql}",
-        ("WHERE #{wheres.collect(&:to_sql).join(' AND ')}" unless wheres.blank? ),
-        ("LIMIT #{taken}"                                     unless taken.blank?  )
+      compiler.delete_sql
     end
   end
 
   class Insert < Compound
-    def to_sql
-      insertion_attributes_values_sql = if record.is_a?(Value)
-        record.value
-      else
-        attributes = record.keys.sort_by do |attribute|
-          attribute.name.to_s
-        end
-
-        first = attributes.collect do |key|
-          engine.quote_column_name(key.name)
-        end.join(', ')
-
-        second = attributes.collect do |key|
-          key.format(record[key])
-        end.join(', ')
-
-        build_query "(#{first})", "VALUES (#{second})"
-      end
-
-      build_query \
-        "INSERT",
-        "INTO #{table_sql}",
-        insertion_attributes_values_sql
+    def to_sql(include_returning = true)
+      compiler.insert_sql(include_returning)
     end
   end
 
   class Update < Compound
     def to_sql
-      build_query \
-        "UPDATE #{table_sql} SET",
-        assignment_sql,
-        build_update_conditions_sql
-    end
-
-  protected
-
-    def assignment_sql
-      if assignments.respond_to?(:collect)
-        attributes = assignments.keys.sort_by do |attribute|
-          attribute.name.to_s
-        end
-
-        attributes.map do |attribute|
-          value = assignments[attribute]
-          "#{engine.quote_column_name(attribute.name)} = #{attribute.format(value)}"
-        end.join(", ")
-      else
-        assignments.value
-      end
-    end
-
-    def build_update_conditions_sql
-      conditions = ""
-      conditions << " WHERE #{wheres.collect(&:to_sql).join(' AND ')}" 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
+      compiler.update_sql
     end
   end
 end

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

@@ -16,10 +16,9 @@ module Arel
       end
 
       describe 'when given a', Symbol, String do
-        it "returns the attribute with the same name, if it exists" do
+        it "returns the attribute with the same name" do
           check @relation[:id].should == @attribute1
           check @relation['id'].should == @attribute1
-          @relation[:does_not_exist].should be_nil
         end
       end
     end

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

@@ -10,7 +10,6 @@ module Arel
       describe 'when given a', Symbol do
         it "manufactures an attribute if the symbol names an attribute within the relation" do
           check @relation[:id].should == Attribute.new(@relation, :id)
-          @relation[:does_not_exist].should be_nil
         end
       end
 

data/spec/arel/engines/memory/integration/joins/cross_engine_spec.rb

@@ -12,6 +12,11 @@ module Arel
       @photos.delete
       @photos.insert(@photos[:id] => 1, @photos[:user_id] => 1, @photos[:camera_id] => 6)
       @photos.insert(@photos[:id] => 2, @photos[:user_id] => 2, @photos[:camera_id] => 42)
+      # Oracle adapter returns database integers as Ruby integers and not strings
+      @adapter_returns_integer = false
+      adapter_is :oracle do
+        @adapter_returns_integer = true
+      end
     end
 
     describe 'when the in memory relation is on the left' do
@@ -22,8 +27,8 @@ module Arel
           .project(@users[:name], @photos[:camera_id]) \
         .let do |relation|
           relation.call.should == [
-            Row.new(relation, ['bryan', '6']),
-            Row.new(relation, ['emilio', '42'])
+            Row.new(relation, ['bryan', @adapter_returns_integer ? 6 : '6']),
+            Row.new(relation, ['emilio', @adapter_returns_integer ? 42 : '42'])
           ]
         end
       end
@@ -37,8 +42,8 @@ module Arel
           .project(@users[:name], @photos[:camera_id]) \
         .let do |relation|
           relation.call.should == [
-            Row.new(relation, ['bryan', '6']),
-            Row.new(relation, ['emilio', '42'])
+            Row.new(relation, ['bryan', @adapter_returns_integer ? 6 : '6']),
+            Row.new(relation, ['emilio', @adapter_returns_integer ? 42 : '42'])
           ]
         end
       end