arel 1.0.1 → 2.0.0

data/lib/arel/algebra/relations/utilities/compound.rb

@@ -1,55 +0,0 @@
-module Arel
-  class Compound
-    include Relation
-
-    attr_reader :relation, :engine
-
-    def initialize relation
-      @relation    = relation
-      @engine      = relation.engine
-      @attributes  = nil
-      @wheres      = nil
-      @groupings   = nil
-      @orders      = nil
-      @havings     = nil
-      @projections = nil
-    end
-
-    def join?;           @relation.join?           end
-    def name;            @relation.name            end
-    def table_alias;     @relation.table_alias     end
-    def skipped;         @relation.skipped         end
-    def taken;           @relation.taken           end
-    def joins env;       @relation.joins env       end
-    def column_for attr; @relation.column_for attr end
-    def externalizable?; @relation.externalizable? end
-
-    def sources
-      @relation.sources
-    end
-
-    def table
-      @relation.table
-    end
-
-    def table_sql(formatter = Sql::TableReference.new(self))
-      @relation.table_sql formatter
-    end
-
-    [:wheres, :groupings, :orders, :havings, :projections].each do |operation_name|
-      class_eval <<-OPERATION, __FILE__, __LINE__
-        def #{operation_name}
-          @#{operation_name} ||= relation.#{operation_name}.collect { |o| o.bind(self) }
-        end
-      OPERATION
-    end
-
-    def attributes
-      @attributes ||= relation.attributes.bind(self)
-    end
-
-    def unoperated_rows
-      relation.call.collect { |row| row.bind(self) }
-    end
-  end
-end

data/lib/arel/algebra/relations/utilities/externalization.rb

@@ -1,26 +0,0 @@
-module Arel
-  class Externalization < Compound
-    include Recursion::BaseCase
-
-    def == other
-      super || Externalization === other && relation == other.relation
-    end
-
-    def wheres
-      []
-    end
-
-    def attributes
-      @attributes ||= Header.new(relation.attributes.map { |a| a.to_attribute(self) })
-    end
-
-    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

data/lib/arel/algebra/relations/utilities/nil.rb

@@ -1,7 +0,0 @@
-require 'singleton'
-
-module Arel
-  class Nil
-    include Relation, Singleton
-  end
-end

data/lib/arel/algebra/relations/writes.rb

@@ -1,47 +0,0 @@
-module Arel
-  class Action < Compound
-  end
-
-  class Deletion < Action
-    def call
-      engine.delete(self)
-    end
-
-    def to_sql
-      compiler.delete_sql
-    end
-  end
-
-  class Insert < Action
-    attr_reader :record
-
-    def initialize(relation, record)
-      super(relation)
-      @record = record.bind(relation)
-    end
-
-    def call
-      engine.create(self)
-    end
-
-    def eval
-      unoperated_rows + [Row.new(self, record.values.collect(&:value))]
-    end
-
-    def to_sql(include_returning = true)
-      compiler.insert_sql(include_returning)
-    end
-  end
-
-  class Update < Insert
-    alias :assignments :record
-
-    def call
-      engine.update(self)
-    end
-
-    def to_sql
-      compiler.update_sql
-    end
-  end
-end

data/lib/arel/algebra/value.rb

@@ -1,53 +0,0 @@
-module Arel
-  class Value
-    attr_reader :value, :relation
-
-    def initialize value, relation
-      @value = value
-      @relation = relation
-    end
-
-    def == other
-      super ||
-        Value === other &&
-        value == other.value &&
-        relation == other.relation
-    end
-
-    def eval(row)
-      value
-    end
-
-    def bind(relation)
-      Value.new(value, relation)
-    end
-
-    def to_ordering
-      self
-    end
-
-    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
-end

data/lib/arel/engines.rb

@@ -1,2 +0,0 @@
-require 'arel/engines/sql'
-require 'arel/engines/memory'

data/lib/arel/engines/memory.rb

@@ -1,2 +0,0 @@
-require 'arel/engines/memory/relations'
-require 'arel/engines/memory/engine'

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

@@ -1,10 +0,0 @@
-module Arel
-  module Memory
-    class Engine
-      def read(relation)
-        relation.eval
-      end
-      alias :create :read
-    end
-  end
-end

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

@@ -1,2 +0,0 @@
-require 'arel/engines/memory/relations/array'
-require 'arel/engines/memory/relations/operations'

data/lib/arel/engines/memory/relations/array.rb

@@ -1,37 +0,0 @@
-module Arel
-  class Array
-    include Relation
-
-    attr_reader :array, :attribute_names_and_types
-    include Recursion::BaseCase
-
-    def initialize(array, attribute_names_and_types)
-      @array                     = array
-      @attribute_names_and_types = attribute_names_and_types
-      @engine                    = nil
-      @attributes                = nil
-    end
-
-    def engine
-      @engine ||= Memory::Engine.new
-    end
-
-    def attributes
-      @attributes ||= begin
-        attrs = @attribute_names_and_types.collect do |attribute, type|
-          attribute = type.new(self, attribute) if Symbol === attribute
-          attribute
-        end
-        Header.new(attrs)
-      end
-    end
-
-    def format(attribute, value)
-      value
-    end
-
-    def eval
-      @array.collect { |r| Row.new(self, r) }
-    end
-  end
-end

data/lib/arel/engines/memory/relations/operations.rb

@@ -1,9 +0,0 @@
-module Arel
-  class Alias < Compound
-    include Recursion::BaseCase
-
-    def eval
-      unoperated_rows
-    end
-  end
-end

data/lib/arel/engines/sql.rb

@@ -1,6 +0,0 @@
-require 'arel/engines/sql/attributes'
-require 'arel/engines/sql/engine'
-require 'arel/engines/sql/relations'
-require 'arel/engines/sql/formatters'
-require 'arel/engines/sql/core_extensions'
-require 'arel/engines/sql/christener'

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

@@ -1,45 +0,0 @@
-module Arel
-  module Sql
-    module Attributes
-      def self.for(column)
-        case column.type
-        when :string    then String
-        when :text      then String
-        when :integer   then Integer
-        when :float     then Float
-        when :decimal   then Decimal
-        when :date      then Time
-        when :datetime  then Time
-        when :timestamp then Time
-        when :time      then Time
-        when :binary    then String
-        when :boolean   then Boolean
-        else
-          Undefined
-        end
-      end
-
-      def initialize(column, *args)
-        @column = column
-        super(*args)
-      end
-
-      def type_cast(value)
-        @column.type_cast(value)
-      end
-
-      # Attribute type for column types that Arel doesn't know how to handle.
-      class Undefined < Arel::Attribute
-        include Attributes
-      end
-
-      %w(Boolean Decimal Float Integer String Time).each do |klass|
-        class_eval <<-R
-          class #{klass} < Arel::Attributes::#{klass}
-            include Attributes
-          end
-        R
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-module Arel
-  module Sql
-    class Christener
-      def initialize
-        @names = {}
-      end
-
-      def name_for(relation)
-        table = relation.table
-        name = table.table_alias || table.name
-        list = @names[name] ||= []
-
-        list << table unless list.include? table
-
-        idx = list.index table
-        name + (idx == 0 ? '' : "_#{idx + 1}")
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-# +-----------------------------------------------------------------------+
-# |                                                                       |
-# | Copyright (c) 2010 IBM Corporation                                    |
-# |                                                                       |
-# | Permission is hereby granted, free of charge, to any person obtaining |
-# | a copy of this software and associated documentation files (the       |
-# | "Software"), to deal in the Software without restriction, including   |
-# | without limitation the rights to use, copy, modify, merge, publish,   |
-# | distribute, sublicense, and/or sell copies of the Software, and to    |
-# | permit persons to whom the Software is furnished to do so, subject to |
-# | the following conditions:                                             |
-# |                                                                       |
-# | The above copyright notice and this permission notice shall be        |
-# | included in all copies or substantial portions of the Software.       |
-# |                                                                       |
-# | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       |
-# | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    |
-# | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.|
-# | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR      |
-# | ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION           |
-# | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
-# | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.       |
-# |                                                                       |
-# +-----------------------------------------------------------------------+
-
-#
-#  Author: Praveen Devarao <praveendrl@in.ibm.com>
-#
-
-module Arel
-  module SqlCompiler
-    class IBM_DBCompiler < GenericCompiler
-
-      def limited_update_conditions(conditions, taken)
-        quoted_primary_key = engine.quote_table_name(primary_key)
-        update_conditions = "WHERE #{quoted_primary_key} IN (SELECT #{quoted_primary_key} FROM #{engine.connection.quote_table_name table.name} #{conditions} " #Note: - ')' not added, limit segment is to be appended
-        engine.add_limit_offset!(update_conditions,{:limit=>taken,:offset=>nil})
-        update_conditions << ")" # Close the sql segment
-        update_conditions
-      end
-
-      def add_limit_on_delete(taken)
-        raise "IBM_DB does not support limit on deletion" # Limiting the number of rows to be deleted is not supported by IBM_DB
-      end
-
-    end
-  end
-end

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

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

@@ -1,106 +0,0 @@
-module Arel
-  module SqlCompiler
-    class OracleCompiler < GenericCompiler
-
-      def select_sql
-        select_clauses = relation.select_clauses
-        from_clauses = relation.from_clauses
-        joins = relation.joins(self)
-        where_clauses = relation.where_clauses
-        order_clauses = relation.order_clauses
-        group_clauses = relation.group_clauses
-        having_clauses = relation.having_clauses
-        taken = relation.taken
-        skipped = relation.skipped
-        if limit_or_offset = !taken.blank? || !skipped.blank?
-          # if need to select first records without ORDER BY and GROUP BY and without DISTINCT
-          # then can use simple ROWNUM in WHERE clause
-          if skipped.blank? && group_clauses.blank? && order_clauses.blank? && select_clauses[0] !~ /^DISTINCT /
-            where_clauses << "ROWNUM <= #{taken}" if !taken.blank? && skipped.blank? && group_clauses.blank? && order_clauses.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.connection.quote_column_name(relation.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/ && !order_clauses.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                                         unless joins.blank?               ),
-          ("WHERE     #{where_clauses.join(' AND ')}"    unless where_clauses.blank?       ),
-          ("GROUP BY  #{group_clauses.join(', ')}"       unless group_clauses.blank?       ),
-          ("HAVING    #{having_clauses.join(' AND ')}"   unless having_clauses.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.connection.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 = relation.wheres.collect(&:to_sql)
-        taken = relation.taken
-        where_clauses << "ROWNUM <= #{taken}" unless taken.blank?
-        build_query \
-          "DELETE",
-          "FROM #{relation.table_sql}",
-          ("WHERE #{where_clauses.join(' AND ')}" unless where_clauses.blank? )
-      end
-
-    protected
-
-      def build_update_conditions_sql
-        conditions = ""
-        where_clauses = relation.wheres.collect(&:to_sql)
-        taken = relation.taken
-        # if need to select first records without ORDER BY
-        # then can use simple ROWNUM in WHERE clause
-        if !taken.blank? && relation.orders.blank?
-          where_clauses << "ROWNUM <= #{taken}"
-        end
-        conditions << " WHERE #{where_clauses.join(' AND ')}" unless where_clauses.blank?
-        unless taken.blank?
-          conditions = limited_update_conditions(conditions, taken)
-        end
-        conditions
-      end
-
-      def limited_update_conditions(conditions, taken)
-        order_clauses = relation.order_clauses
-        # need to add ORDER BY only if just taken ones should be updated
-        conditions << " ORDER BY #{order_clauses.join(', ')}" unless order_clauses.blank?
-        quoted_primary_key = engine.connection.quote_column_name(relation.primary_key)
-        subquery = "SELECT #{quoted_primary_key} FROM #{engine.connection.quote_table_name relation.table.name} #{conditions}"
-        # Use existing method from oracle_enhanced adapter to get taken records when ORDER BY is used
-        engine.connection.add_limit_offset!(subquery, :limit => taken) unless order_clauses.blank?
-        "WHERE #{quoted_primary_key} IN (#{subquery})"
-      end
-
-    end
-  end
-end