arel-compat 0.4.0

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

@@ -0,0 +1,97 @@
+module Arel
+  class SqlLiteral < String
+    def relation
+      nil
+    end
+
+    def to_sql(formatter = nil)
+      self
+    end
+
+    include Attribute::Expressions
+  end
+
+  class Attribute
+    def column
+      original_relation.column_for(self)
+    end
+
+    def format(object)
+      object.to_sql(Sql::Attribute.new(self))
+    end
+
+    def to_sql(formatter = Sql::WhereCondition.new(relation))
+      formatter.attribute self
+    end
+  end
+
+  class Value
+    def inclusion_predicate_sql
+      value.inclusion_predicate_sql
+    end
+
+    def exclusion_predicate_sql
+      value.exclusion_predicate_sql
+    end
+
+    def equality_predicate_sql
+      value.equality_predicate_sql
+    end
+
+    def inequality_predicate_sql
+      value.inequality_predicate_sql
+    end
+
+    def to_sql(formatter = Sql::WhereCondition.new(relation))
+      formatter.value value
+    end
+
+    def format(object)
+      object.to_sql(Sql::Value.new(relation))
+    end
+  end
+
+  class Ordering
+    def to_sql(formatter = Sql::OrderClause.new(relation))
+      formatter.ordering self
+    end
+  end
+
+  class Ascending < Ordering
+    def direction_sql; 'ASC' end
+  end
+
+  class Descending < Ordering
+    def direction_sql; 'DESC' end
+  end
+
+  class Expression < Attribute
+    def to_sql(formatter = Sql::SelectClause.new(relation))
+      formatter.expression self
+    end
+  end
+
+  class Count < Expression
+    def function_sql; 'COUNT' end
+  end
+
+  class Distinct < Expression
+    def function_sql; 'DISTINCT' end
+  end
+
+  class Sum < Expression
+    def function_sql; 'SUM' end
+  end
+
+  class Maximum < Expression
+    def function_sql; 'MAX' end
+  end
+
+  class Minimum < Expression
+    def function_sql; 'MIN' end
+  end
+
+  class Average < Expression
+    def function_sql; 'AVG' end
+  end
+end

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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,118 @@
+module Arel
+  module SqlCompiler
+    class GenericCompiler
+      attr_reader :relation
+
+      def initialize(relation)
+        @relation = relation
+      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
+      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/operations/alias.rb

@@ -0,0 +1,5 @@
+module Arel
+  class Alias < Compound
+    include Recursion::BaseCase
+  end
+end

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

@@ -0,0 +1,33 @@
+module Arel
+  class Join
+    def table_sql(formatter = Sql::TableReference.new(self))
+      relation1.externalize.table_sql(formatter)
+    end
+
+    def joins(environment, formatter = Sql::TableReference.new(environment))
+      @joins ||= begin
+        this_join = [
+          join_sql,
+          relation2.externalize.table_sql(formatter),
+          ("ON" unless predicates.blank?),
+          (ons + relation2.externalize.wheres).collect { |p| p.bind(environment.relation).to_sql(Sql::WhereClause.new(environment)) }.join(' AND ')
+        ].compact.join(" ")
+        [relation1.joins(environment), this_join, relation2.joins(environment)].compact.join(" ")
+      end
+    end
+  end
+
+  class InnerJoin < Join
+    def join_sql; "INNER JOIN" end
+  end
+
+  class OuterJoin < Join
+    def join_sql; "LEFT OUTER JOIN" end
+  end
+
+  class StringJoin < Join
+    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

@@ -0,0 +1,65 @@
+module Arel
+  module Relation
+    @@connection_tables_primary_keys = {}
+
+    def compiler
+      @compiler ||=  begin
+        "Arel::SqlCompiler::#{engine.adapter_name}Compiler".constantize.new(self)
+      rescue
+        Arel::SqlCompiler::GenericCompiler.new(self)
+      end
+    end
+
+    def to_sql(formatter = Sql::SelectStatement.new(self))
+      formatter.select compiler.select_sql, self
+    end
+
+    def christener
+      @christener ||= Sql::Christener.new
+    end
+
+    def inclusion_predicate_sql
+      "IN"
+    end
+
+    def exclusion_predicate_sql
+      "NOT IN"
+    end
+
+    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
+
+    protected
+
+      def from_clauses
+        sources.blank? ? table_sql(Sql::TableReference.new(self)) : sources
+      end
+
+      def select_clauses
+        attributes.collect { |a| a.to_sql(Sql::SelectClause.new(self)) }
+      end
+
+      def where_clauses
+        wheres.collect { |w| w.to_sql(Sql::WhereClause.new(self)) }
+      end
+
+      def group_clauses
+        groupings.collect { |g| g.to_sql(Sql::GroupClause.new(self)) }
+      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

@@ -0,0 +1,88 @@
+module Arel
+  class Table
+    include Relation, Recursion::BaseCase
+
+    cattr_accessor :engine, :tables
+    attr_reader :name, :engine, :table_alias, :options
+
+    def initialize(name, options = {})
+      @name = name.to_s
+      @table_exists = 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
+      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
+      return @attributes if defined?(@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)
+        end
+      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")
+    end
+
+    def reset
+      @columns = nil
+      @attributes = Header.new([])
+    end
+
+    def ==(other)
+      Table       === other and
+      name        ==  other.name and
+      table_alias ==  other.table_alias
+    end
+  end
+end
+
+def Table(name, engine = Arel::Table.engine)
+  Arel::Table.new(name, engine)
+end
+

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

@@ -0,0 +1,10 @@
+module Arel
+  class Compound
+    delegate :table, :table_sql, :to => :relation
+
+    def build_query(*parts)
+      parts.compact.join(" ")
+    end
+  end
+end
+

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

@@ -0,0 +1,14 @@
+module Arel
+  class Externalization < Compound
+    include Recursion::BaseCase
+
+    def table_sql(formatter = Sql::TableReference.new(relation))
+      formatter.select relation.compiler.select_sql, self
+    end
+
+    # REMOVEME
+    def name
+      relation.name + '_external'
+    end
+  end
+end