arel-compat 0.4.0

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

@@ -0,0 +1,11 @@
+module Arel
+  module SqlCompiler
+    class MySQLCompiler < GenericCompiler
+      def limited_update_conditions(conditions, taken)
+        conditions << " LIMIT #{taken}"
+        conditions
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,95 @@
+module Arel
+  module SqlCompiler
+    class OracleCompiler < GenericCompiler
+
+      def select_sql
+        where_clauses_array = where_clauses
+        if limit_or_offset = !taken.blank? || !skipped.blank?
+          # if need to select first records without ORDER BY and GROUP BY
+          # then can use simple ROWNUM in WHERE clause
+          if skipped.blank? && groupings.blank? && orders.blank?
+            where_clauses_array << "ROWNUM <= #{taken}" if !taken.blank? && skipped.blank? && groupings.blank? && orders.blank?
+            limit_or_offset = false
+          end
+        end
+
+        # when limit or offset subquery is used then cannot use FOR UPDATE directly
+        # and need to construct separate subquery for primary key
+        if use_subquery_for_lock = limit_or_offset && !locked.blank?
+          quoted_primary_key = engine.quote_column_name(primary_key)
+        end
+        select_attributes_string = use_subquery_for_lock ? quoted_primary_key : select_clauses.join(', ')
+
+        # OracleEnhanced adapter workaround when ORDER BY is used with columns not
+        # present in DISTINCT columns list
+        order_clauses_array = if select_attributes_string =~ /DISTINCT.*FIRST_VALUE/ && !orders.blank?
+          order = order_clauses.join(', ').split(',').map { |s| s.strip }.reject(&:blank?)
+          order = order.zip((0...order.size).to_a).map { |s,i| "alias_#{i}__ #{'DESC' if s =~ /\bdesc$/i}" }
+        else
+          order_clauses
+        end
+
+        query = build_query \
+          "SELECT     #{select_attributes_string}",
+          "FROM       #{from_clauses}",
+          (joins(self)                                   unless joins(self).blank? ),
+          ("WHERE     #{where_clauses_array.join(" AND ")}"    unless where_clauses_array.blank?      ),
+          ("GROUP BY  #{group_clauses.join(', ')}"       unless groupings.blank?   ),
+          ("HAVING    #{having_clauses.join(', ')}"      unless havings.blank?     ),
+          ("ORDER BY  #{order_clauses_array.join(', ')}" unless order_clauses_array.blank? )
+
+        # Use existing method from oracle_enhanced adapter to implement limit and offset using subqueries
+        engine.add_limit_offset!(query, :limit => taken, :offset => skipped) if limit_or_offset
+
+        if use_subquery_for_lock
+          build_query \
+            "SELECT     #{select_clauses.join(', ')}",
+            "FROM       #{from_clauses}",
+            "WHERE      #{quoted_primary_key} IN (#{query})",
+            "#{locked}"
+        elsif !locked.blank?
+          build_query query, "#{locked}"
+        else
+          query
+        end
+      end
+
+      def delete_sql
+        where_clauses_array = wheres.collect(&:to_sql)
+        where_clauses_array << "ROWNUM <= #{taken}" unless taken.blank?
+        build_query \
+          "DELETE",
+          "FROM #{table_sql}",
+          ("WHERE #{where_clauses_array.join(' AND ')}" unless where_clauses_array.blank? )
+      end
+
+    protected
+
+      def build_update_conditions_sql
+        conditions = ""
+        where_clauses_array = wheres.collect(&:to_sql)
+        # if need to select first records without ORDER BY
+        # then can use simple ROWNUM in WHERE clause
+        if !taken.blank? && orders.blank?
+          where_clauses_array << "ROWNUM <= #{taken}"
+        end
+        conditions << " WHERE #{where_clauses_array.join(' AND ')}" unless where_clauses_array.blank?
+        unless taken.blank?
+          conditions = limited_update_conditions(conditions, taken)
+        end
+        conditions
+      end
+
+      def limited_update_conditions(conditions, taken)
+        # need to add ORDER BY only if just taken ones should be updated
+        conditions << " ORDER BY #{order_clauses.join(', ')}" unless orders.blank?
+        quoted_primary_key = engine.quote_column_name(primary_key)
+        subquery = "SELECT #{quoted_primary_key} FROM #{engine.connection.quote_table_name table.name} #{conditions}"
+        # Use existing method from oracle_enhanced adapter to get taken records when ORDER BY is used
+        engine.add_limit_offset!(subquery, :limit => taken) unless orders.blank?
+        "WHERE #{quoted_primary_key} IN (#{subquery})"
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Arel
+  module SqlCompiler
+    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? )
+
+          build_query \
+            "SELECT * FROM (#{subquery}) AS id_list",
+            "ORDER BY #{aliased_orders(order_clauses)}",
+            ("LIMIT #{taken}" unless taken.blank? ),
+            ("OFFSET #{skipped}" unless skipped.blank? )
+        else
+          super
+        end
+      end
+
+      def using_distinct_on?
+        select_clauses.any? { |x| x =~ /DISTINCT ON/ }
+      end
+
+      def aliased_orders(orders)
+        # 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 = orders.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(', ')
+      end
+
+      def supports_insert_with_returning?
+        engine.postgresql_version >= 80200
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Arel
+  module SqlCompiler
+    class SQLiteCompiler < GenericCompiler
+      def locked
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,4 @@
+require 'arel/engines/sql/core_extensions/object'
+require 'arel/engines/sql/core_extensions/array'
+require 'arel/engines/sql/core_extensions/range'
+require 'arel/engines/sql/core_extensions/nil_class'

data/lib/arel/engines/sql/core_extensions/array.rb

@@ -0,0 +1,24 @@
+module Arel
+  module Sql
+    module ArrayExtensions
+      def to_sql(formatter = nil)
+        if any?
+          "(" + collect { |e| e.to_sql(formatter) }.join(', ') + ")"
+        else
+          "(NULL)"
+        end
+      end
+
+      def inclusion_predicate_sql
+        "IN"
+      end
+
+      def exclusion_predicate_sql
+        "NOT IN"
+      end
+
+      Array.send(:include, self)
+    end
+  end
+end
+

data/lib/arel/engines/sql/core_extensions/nil_class.rb

@@ -0,0 +1,15 @@
+module Arel
+  module Sql
+    module NilClassExtensions
+      def equality_predicate_sql
+        'IS'
+      end
+
+      def inequality_predicate_sql
+        'IS NOT'
+      end
+
+      NilClass.send(:include, self)
+    end
+  end
+end

data/lib/arel/engines/sql/core_extensions/object.rb

@@ -0,0 +1,19 @@
+module Arel
+  module Sql
+    module ObjectExtensions
+      def to_sql(formatter)
+        formatter.scalar self
+      end
+
+      def equality_predicate_sql
+        '='
+      end
+
+      def inequality_predicate_sql
+        '!='
+      end
+
+      Object.send(:include, self)
+    end
+  end
+end

data/lib/arel/engines/sql/core_extensions/range.rb

@@ -0,0 +1,19 @@
+module Arel
+  module Sql
+    module RangeExtensions
+      def to_sql(formatter = nil)
+        formatter.range self.begin, self.end
+      end
+
+      def inclusion_predicate_sql
+        "BETWEEN"
+      end
+
+      def exclusion_predicate_sql
+        "NOT BETWEEN"
+      end
+
+      Range.send(:include, self)
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Arel
+  module Sql
+    class Engine
+
+      def initialize(ar = nil)
+        @ar = ar
+      end
+
+      def connection
+        @ar ? @ar.connection : nil
+      end
+
+      def adapter_name
+        @adapter_name ||= case (name = connection.adapter_name)
+        # map OracleEnanced adapter to Oracle
+        when /Oracle/
+          'Oracle'
+        else
+          name
+        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)
+        end
+
+        def read(relation)
+          rows = connection.select_rows(relation.to_sql)
+          Array.new(rows, relation.attributes)
+        end
+
+        def update(relation)
+          connection.update(relation.to_sql)
+        end
+
+        def delete(relation)
+          connection.delete(relation.to_sql)
+        end
+      end
+      include CRUD
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+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
+
+      def initialize(environment)
+        @environment = environment
+      end
+    end
+
+    class SelectClause < Formatter
+      def attribute(attribute)
+        "#{quote_table_name(name_for(attribute.original_relation))}.#{quote_column_name(attribute.name)}" +
+        (attribute.alias ? " AS #{quote(attribute.alias.to_s)}" : "")
+      end
+
+      def expression(expression)
+        if expression.function_sql == "DISTINCT"
+          "#{expression.function_sql} #{expression.attribute.to_sql(self)}" +
+          (expression.alias ? " AS #{quote_column_name(expression.alias)}" : '')
+        else
+          "#{expression.function_sql}(#{expression.attribute.to_sql(self)})" +
+          (expression.alias ? " AS #{quote_column_name(expression.alias)}" : " AS #{expression.function_sql.to_s.downcase}_id")
+        end
+      end
+
+      def select(select_sql, table)
+        "(#{select_sql}) AS #{quote_table_name(name_for(table))}"
+      end
+
+      def value(value)
+        value
+      end
+    end
+
+    class PassThrough < Formatter
+      def value(value)
+        value
+      end
+    end
+
+    class WhereClause < PassThrough
+    end
+
+    class OrderClause < PassThrough
+      def ordering(ordering)
+        "#{quote_table_name(name_for(ordering.attribute.original_relation))}.#{quote_column_name(ordering.attribute.name)} #{ordering.direction_sql}"
+      end
+    end
+
+    class GroupClause < PassThrough
+      def attribute(attribute)
+        "#{quote_table_name(name_for(attribute.original_relation))}.#{quote_column_name(attribute.name)}"
+      end
+    end
+
+    class HavingClause < PassThrough
+      def attribute(attribute)
+        attribute
+      end
+    end
+
+    class WhereCondition < Formatter
+      def attribute(attribute)
+        "#{quote_table_name(name_for(attribute.original_relation))}.#{quote_column_name(attribute.name)}"
+      end
+
+      def expression(expression)
+        "#{expression.function_sql}(#{expression.attribute.to_sql(self)})"
+      end
+
+      def value(value)
+        value.to_sql(self)
+      end
+
+      def scalar(value, column = nil)
+        quote(value, column)
+      end
+
+      def select(select_sql, table)
+        "(#{select_sql})"
+      end
+    end
+
+    class SelectStatement < Formatter
+      def select(select_sql, table)
+        select_sql
+      end
+    end
+
+    class TableReference < Formatter
+      def select(select_sql, table)
+        "(#{select_sql}) #{quote_table_name(name_for(table))}"
+      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
+      end
+    end
+
+    class Attribute < WhereCondition
+      def scalar(scalar)
+        quote(scalar, environment.column)
+      end
+
+      def range(left, right)
+        "#{scalar(left)} AND #{scalar(right)}"
+      end
+    end
+
+    class Value < WhereCondition
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+module Arel
+  module Predicates
+    class Binary < Predicate
+      def to_sql(formatter = nil)
+        "#{operand1.to_sql} #{predicate_sql} #{operand1.format(operand2)}"
+      end
+    end
+
+    class Unary < Predicate
+      def to_sql(formatter = nil)
+        "#{predicate_sql} (#{operand.to_sql(formatter)})"
+      end
+    end
+
+    class Not < Unary
+      def predicate_sql; "NOT" end
+    end
+
+    class CompoundPredicate < Binary
+      def to_sql(formatter = nil)
+        "(#{operand1.to_sql(formatter)} #{predicate_sql} #{operand2.to_sql(formatter)})"
+      end
+    end
+
+    class Or < CompoundPredicate
+      def predicate_sql; "OR" end
+    end
+
+    class And < CompoundPredicate
+      def predicate_sql; "AND" end
+    end
+
+    class Polyadic < Predicate
+      def to_sql(formatter = nil)
+        "(" +
+          predicates.map {|p| p.to_sql(formatter)}.join(" #{predicate_sql} ") +
+        ")"
+      end
+    end
+
+    class Any < Polyadic
+      def predicate_sql; "OR" end
+    end
+
+    class All < Polyadic
+      def predicate_sql; "AND" end
+    end
+
+    class Equality < Binary
+      def predicate_sql
+        operand2.equality_predicate_sql
+      end
+    end
+
+    class Inequality < Binary
+      def predicate_sql
+        operand2.inequality_predicate_sql
+      end
+    end
+
+    class GreaterThanOrEqualTo < Binary
+      def predicate_sql; '>=' end
+    end
+
+    class GreaterThan < Binary
+      def predicate_sql; '>' end
+    end
+
+    class LessThanOrEqualTo < Binary
+      def predicate_sql; '<=' end
+    end
+
+    class LessThan < Binary
+      def predicate_sql; '<' end
+    end
+
+    class Match < Binary
+      def predicate_sql; 'LIKE' end
+    end
+
+    class NotMatch < Binary
+      def predicate_sql; 'NOT LIKE' end
+    end
+
+    class In < Binary
+      def to_sql(formatter = nil)
+        if operand2.is_a?(Range) && operand2.exclude_end?
+          GreaterThanOrEqualTo.new(operand1, operand2.begin).and(
+            LessThan.new(operand1, operand2.end)
+          ).to_sql(formatter)
+        else
+          super
+        end
+      end
+
+      def predicate_sql; operand2.inclusion_predicate_sql end
+    end
+
+    class NotIn < Binary
+      def predicate_sql; operand2.exclusion_predicate_sql end
+    end
+  end
+end