arel 1.0.1 → 2.0.0

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

@@ -1,50 +0,0 @@
-module Arel
-  module SqlCompiler
-    class PostgreSQLCompiler < GenericCompiler
-
-      def select_sql
-        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 (#{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?
-        relation.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.connection.send(:postgresql_version) >= 80200
-      end
-    end
-  end
-end

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

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

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

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

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

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

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

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

@@ -1,47 +0,0 @@
-module Arel
-  module Sql
-    class Engine
-      def initialize(ar = nil)
-        @ar = ar
-      end
-
-      def connection
-        @ar && @ar.connection
-      end
-
-      def adapter_name
-        @adapter_name ||= case (name = connection.adapter_name)
-        # map OracleEnanced adapter to Oracle
-        when /Oracle/
-          'Oracle'
-        else
-          name
-        end
-      end
-
-      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
-  end
-end

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

@@ -1,138 +0,0 @@
-module Arel
-  module Sql
-    class Formatter
-      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
-
-    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)
-        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
-
-    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/relations.rb

@@ -1,3 +0,0 @@
-require 'arel/engines/sql/relations/utilities/nil'
-require 'arel/engines/sql/relations/compiler'
-require 'arel/engines/sql/relations/table'

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

@@ -1,153 +0,0 @@
-module Arel
-  module SqlCompiler
-    class GenericCompiler
-      attr_reader :relation, :engine
-
-      def initialize(relation)
-        @relation = relation
-        @engine = relation.engine
-      end
-
-      def christener
-        relation.christener
-      end
-
-      def select_sql
-        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 #{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)
-        "LIMIT #{taken}"
-      end
-
-      def insert_sql(include_returning = true)
-        insertion_attributes_values_sql = if relation.record.is_a?(Value)
-          relation.record.value
-        else
-          attributes = relation.record.keys.sort_by do |attribute|
-            attribute.name.to_s
-          end
-
-          first = attributes.collect do |key|
-            @engine.connection.quote_column_name(key.name)
-          end.join(', ')
-
-          second = attributes.collect do |key|
-            key.format(relation.record[key])
-          end.join(', ')
-
-          build_query "(#{first})", "VALUES (#{second})"
-        end
-
-        build_query \
-          "INSERT",
-          "INTO #{relation.table_sql}",
-          insertion_attributes_values_sql,
-          ("RETURNING #{engine.connection.quote_column_name(relation.primary_key)}" if include_returning && relation.compiler.supports_insert_with_returning?)
-      end
-
-      def supports_insert_with_returning?
-        false
-      end
-
-      def update_sql
-        build_query \
-          "UPDATE #{relation.table_sql} SET",
-          assignment_sql,
-          build_update_conditions_sql
-      end
-
-      protected
-
-      def locked
-        relation.locked
-      end
-
-      def build_query(*parts)
-        parts.compact.join(" ")
-      end
-
-      def assignment_sql
-        if relation.assignments.respond_to?(:collect)
-          attributes = relation.assignments.keys.sort_by do |attribute|
-            attribute.name.to_s
-          end
-
-          attributes.map do |attribute|
-            value = relation.assignments[attribute]
-            "#{@engine.connection.quote_column_name(attribute.name)} = #{attribute.format(value)}"
-          end.join(", ")
-        else
-          relation.assignments.value
-        end
-      end
-
-      def build_update_conditions_sql
-        conditions = ""
-        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
-
-        conditions
-      end
-
-      def limited_update_conditions(conditions, taken)
-        conditions << " LIMIT #{taken}"
-        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
-
-  end
-end