arel 0.4.0 → 1.0.0.rc1

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

@@ -3,28 +3,36 @@ module Arel
     class PostgreSQLCompiler < GenericCompiler
 
       def select_sql
-        if !orders.blank? && using_distinct_on?
-          subquery = 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? )
+        if !relation.orders.blank? && using_distinct_on?
+          selects = relation.select_clauses
+          joins   = relation.joins(self)
+          wheres  = relation.where_clauses
+          groups  = relation.group_clauses
+          havings = relation.having_clauses
+          orders  = relation.order_clauses
+
+          subquery_clauses = [ "",
+            "SELECT     #{selects.kind_of?(::Array) ? selects.join("") : selects.to_s}",
+            "FROM       #{relation.from_clauses}",
+            joins,
+            ("WHERE     #{wheres.join(' AND ')}" unless wheres.empty?),
+            ("GROUP BY  #{groups.join(', ')}" unless groups.empty?),
+            ("HAVING    #{havings.join(' AND ')}" unless havings.empty?)
+          ].compact.join ' '
+          subquery_clauses << " #{locked}" unless locked.blank?
 
           build_query \
-            "SELECT * FROM (#{subquery}) AS id_list",
-            "ORDER BY #{aliased_orders(order_clauses)}",
-            ("LIMIT #{taken}" unless taken.blank? ),
-            ("OFFSET #{skipped}" unless skipped.blank? )
+            "SELECT * FROM (#{build_query subquery_clauses}) AS id_list",
+            "ORDER BY #{aliased_orders(orders)}",
+            ("LIMIT #{relation.taken}" unless relation.taken.blank? ),
+            ("OFFSET #{relation.skipped}" unless relation.skipped.blank? )
         else
           super
         end
       end
 
       def using_distinct_on?
-        select_clauses.any? { |x| x =~ /DISTINCT ON/ }
+        relation.select_clauses.any? { |x| x =~ /DISTINCT ON/ }
       end
 
       def aliased_orders(orders)
@@ -35,7 +43,7 @@ module Arel
       end
 
       def supports_insert_with_returning?
-        engine.postgresql_version >= 80200
+        engine.connection.send(:postgresql_version) >= 80200
       end
     end
   end

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

@@ -1,13 +1,12 @@
 module Arel
   module Sql
     class Engine
-
       def initialize(ar = nil)
         @ar = ar
       end
 
       def connection
-        @ar ? @ar.connection : nil
+        @ar && @ar.connection
       end
 
       def adapter_name
@@ -20,36 +19,29 @@ module Arel
         end
       end
 
-      def method_missing(method, *args, &block)
-        @ar.connection.send(method, *args, &block)
-      end
-
-      module CRUD
-        def create(relation)
-          primary_key_value = if relation.primary_key.blank?
-            nil
-          elsif relation.record.is_a?(Hash)
-            attribute = relation.record.detect { |attr, _| attr.name.to_s == relation.primary_key.to_s }
-            attribute && attribute.last.value
-          end
-
-          connection.insert(relation.to_sql(false), nil, relation.primary_key, primary_key_value)
+      def create(relation)
+        primary_key_value = if relation.primary_key.blank?
+          nil
+        elsif relation.record.is_a?(Hash)
+          attribute = relation.record.detect { |attr, _| attr.name.to_s == relation.primary_key.to_s }
+          attribute && attribute.last.value
         end
 
-        def read(relation)
-          rows = connection.select_rows(relation.to_sql)
-          Array.new(rows, relation.attributes)
-        end
+        connection.insert(relation.to_sql(false), nil, relation.primary_key, primary_key_value)
+      end
 
-        def update(relation)
-          connection.update(relation.to_sql)
-        end
+      def read(relation)
+        rows = connection.select_rows(relation.to_sql)
+        Array.new(rows, relation.attributes)
+      end
 
-        def delete(relation)
-          connection.delete(relation.to_sql)
-        end
+      def update(relation)
+        connection.update(relation.to_sql)
+      end
+
+      def delete(relation)
+        connection.delete(relation.to_sql)
       end
-      include CRUD
     end
   end
 end

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

@@ -1,13 +1,28 @@
 module Arel
   module Sql
     class Formatter
-      attr_reader :environment
-      delegate :christener, :engine, :to => :environment
-      delegate :name_for, :to => :christener
-      delegate :quote_table_name, :quote_column_name, :quote, :to => :engine
+      attr_reader :environment, :christener, :engine
 
       def initialize(environment)
         @environment = environment
+        @christener  = environment.christener
+        @engine      = environment.engine
+      end
+
+      def name_for thing
+        @christener.name_for thing
+      end
+
+      def quote_column_name name
+        @engine.connection.quote_column_name name
+      end
+
+      def quote_table_name name
+        @engine.connection.quote_table_name name
+      end
+
+      def quote value, column = nil
+        @engine.connection.quote value, column
       end
     end
 
@@ -97,12 +112,13 @@ module Arel
       end
 
       def table(table)
-        if table.name =~ /\s/
-          table.name
-        else
-          quote_table_name(table.name) +
-            (table.name != name_for(table) ? " #{quote_table_name(name_for(table))}" : '')
-        end
+        table_name = table.name
+        return table_name if table_name =~ /\s/
+
+        unique_name = name_for(table)
+
+        quote_table_name(table_name) +
+          (table_name != unique_name ? " #{quote_table_name(unique_name)}" : '')
       end
     end
 

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

@@ -1,10 +1,3 @@
-require 'arel/engines/sql/relations/utilities/compound'
-require 'arel/engines/sql/relations/utilities/recursion'
-require 'arel/engines/sql/relations/utilities/externalization'
 require 'arel/engines/sql/relations/utilities/nil'
 require 'arel/engines/sql/relations/compiler'
-require 'arel/engines/sql/relations/relation'
 require 'arel/engines/sql/relations/table'
-require 'arel/engines/sql/relations/operations/join'
-require 'arel/engines/sql/relations/operations/alias'
-require 'arel/engines/sql/relations/writes'

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

@@ -1,32 +1,65 @@
 module Arel
   module SqlCompiler
     class GenericCompiler
-      attr_reader :relation
+      attr_reader :relation, :engine
 
       def initialize(relation)
         @relation = relation
+        @engine = relation.engine
+      end
+
+      def christener
+        relation.christener
       end
 
       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(' AND ')}"      unless havings.blank?     ),
-          ("ORDER BY  #{order_clauses.join(', ')}"       unless orders.blank?      )
-          engine.add_limit_offset!(query,{ :limit => taken, :offset => skipped }) if taken || skipped
-          query << " #{locked}" unless locked.blank?
-          query
+        projections = @relation.projections
+        if Count === projections.first && projections.size == 1 &&
+          (relation.taken.present? || relation.wheres.present?) && relation.joins(self).blank?
+          subquery = [
+            "SELECT 1 FROM #{relation.from_clauses}", build_clauses
+          ].join ' '
+          query = "SELECT COUNT(*) AS count_id FROM (#{subquery}) AS subquery"
+        else
+          query = [
+            "SELECT     #{relation.select_clauses.join(', ')}",
+            "FROM       #{relation.from_clauses}",
+            build_clauses
+          ].compact.join ' '
+        end
+        query
+      end
+
+      def build_clauses
+        joins   = relation.joins(self)
+        wheres  = relation.where_clauses
+        groups  = relation.group_clauses
+        havings = relation.having_clauses
+        orders  = relation.order_clauses
+
+        clauses = [ "",
+          joins,
+          ("WHERE     #{wheres.join(' AND ')}" unless wheres.empty?),
+          ("GROUP BY  #{groups.join(', ')}" unless groups.empty?),
+          ("HAVING    #{havings.join(' AND ')}" unless havings.empty?),
+          ("ORDER BY  #{orders.join(', ')}" unless orders.empty?)
+        ].compact.join ' '
+
+        offset = relation.skipped
+        limit = relation.taken
+        @engine.connection.add_limit_offset!(clauses, :limit => limit,
+                                  :offset => offset) if offset || limit
+
+        clauses << " #{locked}" unless locked.blank?
+        clauses unless clauses.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?  )
+          "FROM #{relation.table_sql}",
+          ("WHERE #{relation.wheres.collect { |x| x.to_sql }.join(' AND ')}" unless relation.wheres.blank? ),
+          (add_limit_on_delete(relation.taken)                        unless relation.taken.blank?  )
       end
 
       def add_limit_on_delete(taken)
@@ -34,19 +67,19 @@ module Arel
       end
 
       def insert_sql(include_returning = true)
-        insertion_attributes_values_sql = if record.is_a?(Value)
-          record.value
+        insertion_attributes_values_sql = if relation.record.is_a?(Value)
+          relation.record.value
         else
-          attributes = record.keys.sort_by do |attribute|
+          attributes = relation.record.keys.sort_by do |attribute|
             attribute.name.to_s
           end
 
           first = attributes.collect do |key|
-            engine.quote_column_name(key.name)
+            @engine.connection.quote_column_name(key.name)
           end.join(', ')
 
           second = attributes.collect do |key|
-            key.format(record[key])
+            key.format(relation.record[key])
           end.join(', ')
 
           build_query "(#{first})", "VALUES (#{second})"
@@ -54,9 +87,9 @@ module Arel
 
         build_query \
           "INSERT",
-          "INTO #{table_sql}",
+          "INTO #{relation.table_sql}",
           insertion_attributes_values_sql,
-          ("RETURNING #{engine.quote_column_name(primary_key)}" if include_returning && compiler.supports_insert_with_returning?)
+          ("RETURNING #{engine.connection.quote_column_name(relation.primary_key)}" if include_returning && relation.compiler.supports_insert_with_returning?)
       end
 
       def supports_insert_with_returning?
@@ -65,14 +98,15 @@ module Arel
 
       def update_sql
         build_query \
-          "UPDATE #{table_sql} SET",
+          "UPDATE #{relation.table_sql} SET",
           assignment_sql,
           build_update_conditions_sql
       end
 
-    protected
-      def method_missing(method, *args, &block)
-        relation.send(method, *args, &block)
+      protected
+
+      def locked
+        relation.locked
       end
 
       def build_query(*parts)
@@ -80,25 +114,26 @@ module Arel
       end
 
       def assignment_sql
-        if assignments.respond_to?(:collect)
-          attributes = assignments.keys.sort_by do |attribute|
+        if relation.assignments.respond_to?(:collect)
+          attributes = relation.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)}"
+            value = relation.assignments[attribute]
+            "#{@engine.connection.quote_column_name(attribute.name)} = #{attribute.format(value)}"
           end.join(", ")
         else
-          assignments.value
+          relation.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?
+        conditions << " WHERE #{relation.wheres.map { |x| x.to_sql }.join(' AND ')}" unless relation.wheres.blank?
+        conditions << " ORDER BY #{relation.order_clauses.join(', ')}" unless relation.orders.blank?
 
+        taken = relation.taken
         unless taken.blank?
           conditions = limited_update_conditions(conditions, taken)
         end
@@ -108,8 +143,8 @@ module Arel
 
       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})"
+        quoted_primary_key = @engine.connection.quote_column_name(relation.primary_key)
+        "WHERE #{quoted_primary_key} IN (SELECT #{quoted_primary_key} FROM #{@engine.connection.quote_table_name relation.table.name} #{conditions})"
       end
 
     end

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

@@ -2,17 +2,36 @@ module Arel
   class Table
     include Relation, Recursion::BaseCase
 
-    cattr_accessor :engine, :tables
-    attr_reader :name, :engine, :table_alias, :options
+    @@engine = nil
+    @@tables = nil
+    class << self # FIXME: Do we really need these?
+      def engine; @@engine; end
+      def engine= e; @@engine = e; end
+
+      def tables; @@tables; end
+      def tables= e; @@tables = e; end
+    end
+
+    attr_reader :name, :engine, :table_alias, :options, :christener
+    attr_reader :table_exists
+    alias :table_exists? :table_exists
 
     def initialize(name, options = {})
       @name = name.to_s
       @table_exists = nil
+      @table_alias = nil
+      @christener = Sql::Christener.new
+      @attributes = nil
+      @matching_attributes = nil
 
       if options.is_a?(Hash)
         @options = options
         @engine = options[:engine] || Table.engine
-        @table_alias = options[:as].to_s if options[:as].present? && options[:as].to_s != @name
+
+        if options[:as]
+          as = options[:as].to_s
+          @table_alias = as unless as == @name
+        end
       else
         @engine = options # Table.new('foo', engine)
       end
@@ -20,10 +39,18 @@ module Arel
       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."
+          begin
+            # try to load an externally defined compiler, in case this adapter has defined the compiler on its own.
+            require "#{@engine.adapter_name.downcase}/arel_compiler"
+          rescue LoadError
+            raise "#{@engine.adapter_name} is not supported by Arel."
+          end
         end
+
+        @@tables ||= engine.connection.tables
+        @table_exists = @@tables.include?(name) ||
+          @engine.connection.table_exists?(name)
       end
     end
 
@@ -31,42 +58,24 @@ module Arel
       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
-      return @attributes if defined?(@attributes)
+      return @attributes if @attributes
       if table_exists?
-        @attributes ||= begin
-          attrs = columns.collect do |column|
-            Sql::Attributes.for(column).new(column, self, column.name.to_sym)
-          end
-          Header.new(attrs)
+        attrs = columns.collect do |column|
+          Sql::Attributes.for(column).new(column, self, column.name.to_sym)
         end
+        @attributes = Header.new(attrs)
       else
         Header.new
       end
     end
 
-    def eql?(other)
-      self == other
-    end
-
-    def hash
-      @hash ||= :name.hash
-    end
-
     def column_for(attribute)
       has_attribute?(attribute) and columns.detect { |c| c.name == attribute.name.to_s }
     end
 
     def columns
-      @columns ||= engine.columns(name, "#{name} Columns")
+      @columns ||= engine.connection.columns(name, "#{name} Columns")
     end
 
     def reset
@@ -74,10 +83,13 @@ module Arel
       @attributes = Header.new([])
     end
 
-    def ==(other)
-      Table       === other and
-      name        ==  other.name and
-      table_alias ==  other.table_alias
+    private
+    def matching_attributes
+      @matching_attributes ||= Hash[attributes.map { |a| [a.root, true] }]
+    end
+
+    def has_attribute?(attribute)
+      matching_attributes.key? attribute.root
     end
   end
 end