arel 0.1.0

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/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,35 @@
+module Arel
+  class Binary < Predicate
+    def eval(row)
+      operand1.eval(row).send(operator, operand2.eval(row))
+    end
+  end
+
+  class Equality < Binary
+    def operator; :== 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 In < Binary
+    def operator; :include? 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,25 @@
+module Arel
+  class Array < Relation
+    attributes :array,  :attribute_names
+    include Recursion::BaseCase
+    deriving :==, :initialize
+
+    def engine
+      @engine ||= Memory::Engine.new
+    end
+
+    def attributes
+      @attributes ||= @attribute_names.collect do |name|
+        name.to_attribute(self)
+      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 < Relation
+    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,61 @@
+module Arel
+  class Where < Compound
+    def eval
+      unoperated_rows.select { |row| predicate.eval(row) }
+    end
+  end
+
+  class Order < Compound
+    def eval
+      unoperated_rows.sort do |row1, row2|
+        ordering = orderings.detect { |o| o.eval(row1, row2) != 0 } || orderings.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 Group < Compound
+    def eval
+      raise NotImplementedError
+    end
+  end
+
+  class Alias < Compound
+    def eval
+      unoperated_rows
+    end
+  end
+
+  class Join < Relation
+    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,7 @@
+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/extensions'
+require 'arel/engines/sql/christener'

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

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

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

@@ -0,0 +1,37 @@
+module Arel
+  module Sql
+    class Engine
+      def initialize(ar = nil)
+        @ar = ar
+      end
+
+      def connection
+        @ar.connection
+      end
+
+      def method_missing(method, *args, &block)
+        @ar.connection.send(method, *args, &block)
+      end
+
+      module CRUD
+        def create(relation)
+          connection.insert(relation.to_sql)
+        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/extensions.rb

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

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

@@ -0,0 +1,16 @@
+module Arel
+  module Sql
+    module ArrayExtensions
+      def to_sql(formatter = nil)
+        "(" + collect { |e| e.to_sql(formatter) }.join(', ') + ")"
+      end
+
+      def inclusion_predicate_sql
+        "IN"
+      end
+      
+      Array.send(:include, self)
+    end
+  end
+end
+

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

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

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

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

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

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

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

@@ -0,0 +1,113 @@
+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)
+        # FIXME this should check that the column exists
+        "#{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 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}) AS #{quote_table_name(name_for(table))}"
+      end
+
+      def table(table)
+        quote_table_name(table.name) +
+        (table.name != name_for(table) ? " AS " + quote_table_name(name_for(table)) : '')
+      end
+    end
+
+    class Attribute < WhereCondition
+      def scalar(scalar)
+        quote(scalar, environment.column)
+      end
+
+      def range(left, right)
+        "#{left} AND #{right}"
+      end
+    end
+
+    class Value < WhereCondition
+    end
+  end
+end