arel-compat 0.4.0

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

@@ -0,0 +1,24 @@
+module Arel
+  class Externalization < Compound
+    attributes :relation
+    deriving :initialize, :==
+
+    def wheres
+      []
+    end
+
+    def attributes
+      @attributes ||= Header.new(relation.attributes.map { |a| a.to_attribute(self) })
+    end
+  end
+
+  module Relation
+    def externalize
+      @externalized ||= externalizable?? Externalization.new(self) : self
+    end
+
+    def externalizable?
+      false
+    end
+  end
+end

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

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

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

@@ -0,0 +1,36 @@
+module Arel
+  class Deletion < Compound
+    attributes :relation
+    deriving :initialize, :==
+
+    def call
+      engine.delete(self)
+    end
+  end
+
+  class Insert < Compound
+    attributes :relation, :record
+    deriving :==
+
+    def initialize(relation, record)
+      @relation, @record = relation, record.bind(relation)
+    end
+
+    def call
+      engine.create(self)
+    end
+  end
+
+  class Update < Compound
+    attributes :relation, :assignments
+    deriving :==
+
+    def initialize(relation, assignments)
+      @relation, @assignments = relation, assignments.bind(relation)
+    end
+
+    def call
+      engine.update(self)
+    end
+  end
+end

data/lib/arel/algebra/value.rb

@@ -0,0 +1,14 @@
+module Arel
+  class Value
+    attributes :value, :relation
+    deriving :initialize, :==
+
+    def bind(relation)
+      Value.new(value, relation)
+    end
+
+    def to_ordering
+      self
+    end
+  end
+end

data/lib/arel/engines.rb

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

data/lib/arel/engines/memory.rb

@@ -0,0 +1,4 @@
+require 'arel/engines/memory/relations'
+require 'arel/engines/memory/primitives'
+require 'arel/engines/memory/engine'
+require 'arel/engines/memory/predicates'

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

@@ -0,0 +1,16 @@
+module Arel
+  module Memory
+    class Engine
+      module CRUD
+        def read(relation)
+          relation.eval
+        end
+
+        def create(relation)
+          relation.eval
+        end
+      end
+      include CRUD
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+module Arel
+  module Predicates
+    class Binary < Predicate
+      def eval(row)
+        operand1.eval(row).send(operator, operand2.eval(row))
+      end
+    end
+
+    class Unary < Predicate
+      def eval(row)
+        operand.eval(row).send(operator)
+      end
+    end
+
+    class Not < Unary
+      def eval(row)
+        !operand.eval(row)
+      end
+    end
+
+    class Polyadic < Predicate
+      def eval(row)
+        predicates.send(compounder) do |operation|
+          operation.eval(row)
+        end
+      end
+    end
+
+    class Any < Polyadic
+      def compounder; :any? end
+    end
+
+    class All < Polyadic
+      def compounder; :all? end
+    end
+
+    class CompoundPredicate < Binary
+      def eval(row)
+        eval "operand1.eval(row) #{operator} operand2.eval(row)"
+      end
+    end
+
+    class Or < CompoundPredicate
+      def operator; :or end
+    end
+
+    class And < CompoundPredicate
+      def operator; :and end
+    end
+
+    class Equality < Binary
+      def operator; :== end
+    end
+
+    class Inequality < Binary
+      def eval(row)
+        operand1.eval(row) != operand2.eval(row)
+      end
+    end
+
+    class GreaterThanOrEqualTo < Binary
+      def operator; :>= end
+    end
+
+    class GreaterThan < Binary
+      def operator; :> end
+    end
+
+    class LessThanOrEqualTo < Binary
+      def operator; :<= end
+    end
+
+    class LessThan < Binary
+      def operator; :< end
+    end
+
+    class Match < Binary
+      def operator; :=~ end
+    end
+
+    class NotMatch < Binary
+      def eval(row)
+        operand1.eval(row) !~ operand2.eval(row)
+      end
+    end
+
+    class In < Binary
+      def eval(row)
+        operand2.eval(row).include?(operand1.eval(row))
+      end
+    end
+
+    class NotIn < Binary
+      def eval(row)
+        !(operand2.eval(row).include?(operand1.eval(row)))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Arel
+  class Attribute
+    def eval(row)
+      row[self]
+    end
+  end
+
+  class Value
+    def eval(row)
+      value
+    end
+  end
+
+  class Ordering
+    def eval(row1, row2)
+      (attribute.eval(row1) <=> attribute.eval(row2)) * direction
+    end
+  end
+
+  class Descending < Ordering
+    def direction; -1 end
+  end
+
+  class Ascending < Ordering
+    def direction; 1 end
+  end
+end

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

@@ -0,0 +1,5 @@
+require 'arel/engines/memory/relations/array'
+require 'arel/engines/memory/relations/operations'
+require 'arel/engines/memory/relations/writes'
+require 'arel/engines/memory/relations/compound'
+

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

@@ -0,0 +1,35 @@
+module Arel
+  class Array
+    include Relation
+
+    attributes :array,  :attribute_names_and_types
+    include Recursion::BaseCase
+    deriving :==, :initialize
+
+    def initialize(array, attribute_names_and_types)
+      @array, @attribute_names_and_types = array, attribute_names_and_types
+    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/compound.rb

@@ -0,0 +1,9 @@
+module Arel
+  class Compound
+    delegate :array, :to => :relation
+
+    def unoperated_rows
+      relation.call.collect { |row| row.bind(self) }
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+module Arel
+  class Where < Compound
+    def eval
+      unoperated_rows.select { |row| predicates.all? { |p| p.eval(row) } }
+    end
+  end
+
+  class Order < Compound
+    def eval
+      unoperated_rows.sort do |row1, row2|
+        ordering = orders.detect { |o| o.eval(row1, row2) != 0 } || orders.last
+        ordering.eval(row1, row2)
+      end
+    end
+  end
+
+  class Project < Compound
+    def eval
+      unoperated_rows.collect { |r| r.slice(*projections) }
+    end
+  end
+
+  class Take < Compound
+    def eval
+      unoperated_rows[0, taken]
+    end
+  end
+
+  class Skip < Compound
+    def eval
+      unoperated_rows[skipped..-1]
+    end
+  end
+
+  class From < Compound
+    def eval
+      unoperated_rows[sources..-1]
+    end
+  end
+
+  class Group < Compound
+    def eval
+      raise NotImplementedError
+    end
+  end
+
+  class Alias < Compound
+    def eval
+      unoperated_rows
+    end
+  end
+
+  class Join
+    def eval
+      result = []
+      relation1.call.each do |row1|
+        relation2.call.each do |row2|
+          combined_row = row1.combine(row2, self)
+          if predicates.all? { |p| p.eval(combined_row) }
+            result << combined_row
+          end
+        end
+      end
+      result
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Arel
+  class Insert < Compound
+    def eval
+      unoperated_rows + [Row.new(self, record.values.collect(&:value))]
+    end
+  end
+end

data/lib/arel/engines/sql.rb

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

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

@@ -0,0 +1,40 @@
+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
+          raise NotImplementedError, "Column type `#{column.type}` is not currently handled"
+        end
+      end
+
+      def initialize(column, *args)
+        @column = column
+        super(*args)
+      end
+
+      def type_cast(value)
+        @column.type_cast(value)
+      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

@@ -0,0 +1,14 @@
+module Arel
+  module Sql
+    class Christener
+      def name_for(relation)
+        @used_names ||= Hash.new(0)
+        (@relation_names ||= Hash.new do |hash, relation|
+          name =  relation.table_alias ? relation.table_alias : relation.name
+          @used_names[name] += 1
+          hash[relation] = name + (@used_names[name] > 1 ? "_#{@used_names[name]}" : '')
+        end)[relation.table]
+      end
+    end
+  end
+end

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

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