arel 1.0.1 → 2.0.0

data/lib/arel/nodes/less_than.rb

@@ -0,0 +1,6 @@
+module Arel
+  module Nodes
+    class LessThan < Arel::Nodes::Binary
+    end
+  end
+end

data/lib/arel/nodes/less_than_or_equal.rb

@@ -0,0 +1,6 @@
+module Arel
+  module Nodes
+    class LessThanOrEqual < Arel::Nodes::Binary
+    end
+  end
+end

data/lib/arel/nodes/lock.rb

@@ -0,0 +1,6 @@
+module Arel
+  module Nodes
+    class Lock
+    end
+  end
+end

data/lib/arel/nodes/matches.rb

@@ -0,0 +1,6 @@
+module Arel
+  module Nodes
+    class Matches < Arel::Nodes::Binary
+    end
+  end
+end

data/lib/arel/nodes/max.rb

@@ -0,0 +1,6 @@
+module Arel
+  module Nodes
+    class Max < Arel::Nodes::Function
+    end
+  end
+end

data/lib/arel/nodes/min.rb

@@ -0,0 +1,6 @@
+module Arel
+  module Nodes
+    class Min < Arel::Nodes::Function
+    end
+  end
+end

data/lib/arel/nodes/node.rb

@@ -0,0 +1,30 @@
+module Arel
+  module Nodes
+    ###
+    # Abstract base class for all AST nodes
+    class Node
+      ###
+      # Factory method to create a Nodes::Grouping node that has an Nodes::Or
+      # node as a child.
+      def or right
+        Nodes::Grouping.new Nodes::Or.new(self, right)
+      end
+
+      ###
+      # Factory method to create an Nodes::And node.
+      def and right
+        Nodes::And.new self, right
+      end
+
+      # FIXME: this method should go away.  I don't like people calling
+      # to_sql on non-head nodes.  This forces us to walk the AST until we
+      # can find a node that has a "relation" member.
+      #
+      # Maybe we should just use `Table.engine`?  :'(
+      def to_sql engine = Table.engine
+        viz = Visitors.for engine
+        viz.accept self
+      end
+    end
+  end
+end

data/lib/arel/nodes/not_equal.rb

@@ -0,0 +1,6 @@
+module Arel
+  module Nodes
+    class NotEqual < Arel::Nodes::Binary
+    end
+  end
+end

data/lib/arel/nodes/not_in.rb

@@ -0,0 +1,6 @@
+module Arel
+  module Nodes
+    class NotIn < Arel::Nodes::Binary
+    end
+  end
+end

data/lib/arel/nodes/offset.rb

@@ -0,0 +1,11 @@
+module Arel
+  module Nodes
+    class Offset
+      attr_accessor :value
+
+      def initialize value
+        @value = value
+      end
+    end
+  end
+end

data/lib/arel/nodes/on.rb

@@ -0,0 +1,11 @@
+module Arel
+  module Nodes
+    class On
+      attr_accessor :expr
+
+      def initialize expr
+        @expr = expr
+      end
+    end
+  end
+end

data/lib/arel/nodes/or.rb

@@ -0,0 +1,6 @@
+module Arel
+  module Nodes
+    class Or < Arel::Nodes::Binary
+    end
+  end
+end

data/lib/arel/nodes/ordering.rb

@@ -0,0 +1,19 @@
+module Arel
+  module Nodes
+    class Ordering < Arel::Nodes::Node
+      attr_accessor :expr, :direction
+
+      def initialize expression, direction = :asc
+        @expr, @direction = expression, direction
+      end
+
+      def ascending?
+        direction == :asc
+      end
+
+      def descending?
+        direction == :desc
+      end
+    end
+  end
+end

data/lib/arel/nodes/outer_join.rb

@@ -0,0 +1,6 @@
+module Arel
+  module Nodes
+    class OuterJoin < Arel::Nodes::Join
+    end
+  end
+end

data/lib/arel/nodes/select_core.rb

@@ -0,0 +1,25 @@
+module Arel
+  module Nodes
+    class SelectCore
+      attr_accessor :froms, :projections, :wheres, :groups
+      attr_accessor :having
+
+      def initialize
+        @froms       = nil
+        @projections = []
+        @wheres      = []
+        @groups      = []
+        @having      = nil
+      end
+
+      def initialize_copy other
+        super
+        @froms       = @froms.clone if @froms
+        @projections = @projections.clone
+        @wheres      = @wheres.clone
+        @group       = @groups.clone
+        @having      = @having.clone if @having
+      end
+    end
+  end
+end

data/lib/arel/nodes/select_statement.rb

@@ -0,0 +1,22 @@
+module Arel
+  module Nodes
+    class SelectStatement
+      attr_reader :cores
+      attr_accessor :limit, :orders, :lock, :offset
+
+      def initialize cores = [SelectCore.new]
+        @cores  = cores
+        @orders = []
+        @limit  = nil
+        @lock   = nil
+        @offset = nil
+      end
+
+      def initialize_copy other
+        super
+        @cores  = @cores.map { |x| x.clone }
+        @orders = @orders.map { |x| x.clone }
+      end
+    end
+  end
+end

data/lib/arel/nodes/sql_literal.rb

@@ -0,0 +1,7 @@
+module Arel
+  module Nodes
+    class SqlLiteral < String
+      include Arel::Expressions
+    end
+  end
+end

data/lib/arel/nodes/string_join.rb

@@ -0,0 +1,11 @@
+module Arel
+  module Nodes
+    class StringJoin < Arel::Nodes::Join
+      undef :constraint
+
+      def initialize left, right
+        super(left, right, nil)
+      end
+    end
+  end
+end

data/lib/arel/nodes/sum.rb

@@ -0,0 +1,6 @@
+module Arel
+  module Nodes
+    class Sum < Arel::Nodes::Function
+    end
+  end
+end

data/lib/arel/nodes/table_alias.rb

@@ -0,0 +1,21 @@
+module Arel
+  module Nodes
+    class TableAlias
+      attr_reader :name, :relation, :columns
+      alias :table_alias :name
+
+      def initialize name, relation
+        @name     = name
+        @relation = relation
+        @columns  = relation.columns.map { |column|
+          column.dup.tap { |col| col.relation = self }
+        }
+      end
+
+      def [] name
+        name = name.to_sym
+        columns.find { |column| column.name == name }
+      end
+    end
+  end
+end

data/lib/arel/nodes/unqualified_column.rb

@@ -0,0 +1,19 @@
+module Arel
+  module Nodes
+    class UnqualifiedColumn
+      attr_accessor :attribute
+
+      def initialize attribute
+        @attribute = attribute
+      end
+
+      def column
+        @attribute.column
+      end
+
+      def name
+        @attribute.name
+      end
+    end
+  end
+end

data/lib/arel/nodes/update_statement.rb

@@ -0,0 +1,21 @@
+module Arel
+  module Nodes
+    class UpdateStatement
+      attr_accessor :relation, :wheres, :values, :orders, :limit
+
+      def initialize
+        @relation = nil
+        @wheres   = []
+        @values   = []
+        @orders = []
+        @limit  = nil
+      end
+
+      def initialize_copy other
+        super
+        @wheres = @wheres.clone
+        @values = @values.clone
+      end
+    end
+  end
+end

data/lib/arel/nodes/values.rb

@@ -0,0 +1,12 @@
+module Arel
+  module Nodes
+    class Values
+      attr_accessor :expressions, :columns
+
+      def initialize exprs, columns = []
+        @expressions = exprs
+        @columns = columns
+      end
+    end
+  end
+end

data/lib/arel/relation.rb

@@ -0,0 +1,6 @@
+module Arel
+  ###
+  # This is deprecated.  Fix rails, then remove this.
+  module Relation
+  end
+end

data/lib/arel/select_manager.rb

@@ -0,0 +1,203 @@
+module Arel
+  class SelectManager < Arel::TreeManager
+    include Arel::Crud
+
+    def initialize engine, table = nil
+      super(engine)
+      @head   = Nodes::SelectStatement.new
+      @ctx    = @head.cores.last
+      from table
+    end
+
+    def taken
+      @head.limit
+    end
+
+    def constraints
+      @ctx.wheres
+    end
+
+    def skip amount
+      @head.offset = Nodes::Offset.new(amount)
+      self
+    end
+
+    def where_clauses
+      #warn "where_clauses is deprecated" if $VERBOSE
+      to_sql = Visitors::ToSql.new @engine
+      @ctx.wheres.map { |c| to_sql.accept c }
+    end
+
+    def lock locking = true
+      # FIXME: do we even need to store this?  If locking is +false+ shouldn't
+      # we just remove the node from the AST?
+      @head.lock = Nodes::Lock.new
+      self
+    end
+
+    def locked
+      @head.lock
+    end
+
+    def on *exprs
+      @ctx.froms.constraint = Nodes::On.new(collapse(exprs))
+      self
+    end
+
+    def group *columns
+      columns.each do |column|
+        # FIXME: backwards compat
+        column = Nodes::SqlLiteral.new(column) if String === column
+        column = Nodes::SqlLiteral.new(column.to_s) if Symbol === column
+
+        @ctx.groups.push Nodes::Group.new column
+      end
+      self
+    end
+
+    def from table
+      table = Nodes::SqlLiteral.new(table) if String === table
+      # FIXME: this is a hack to support
+      # test_with_two_tables_in_from_without_getting_double_quoted
+      # from the AR tests.
+      if @ctx.froms
+        source = @ctx.froms
+
+        if Nodes::SqlLiteral === table && Nodes::Join === source
+          source.left = table
+          table = source
+        end
+      end
+
+      @ctx.froms = table
+      self
+    end
+
+    def join relation, klass = Nodes::InnerJoin
+      return self unless relation
+
+      case relation
+      when String, Nodes::SqlLiteral
+        raise if relation.blank?
+        from Nodes::StringJoin.new(@ctx.froms, relation)
+      else
+        from klass.new(@ctx.froms, relation, nil)
+      end
+    end
+
+    def having expr
+      expr = Nodes::SqlLiteral.new(expr) if String === expr
+
+      @ctx.having = Nodes::Having.new(expr)
+      self
+    end
+
+    def project *projections
+      # FIXME: converting these to SQLLiterals is probably not good, but
+      # rails tests require it.
+      @ctx.projections.concat projections.map { |x|
+        String == x.class ? SqlLiteral.new(x) : x
+      }
+      self
+    end
+
+    def where expr
+      @ctx.wheres << expr
+      self
+    end
+
+    def order *expr
+      # FIXME: We SHOULD NOT be converting these to SqlLiteral automatically
+      @head.orders.concat expr.map { |x|
+        String === x || Symbol === x ? Nodes::SqlLiteral.new(x.to_s) : x
+      }
+      self
+    end
+
+    def orders
+      @head.orders
+    end
+
+    def wheres
+      Compatibility::Wheres.new @engine, @ctx.wheres
+    end
+
+    def where_sql
+      return if @ctx.wheres.empty?
+
+      viz = Visitors::WhereSql.new @engine
+      Nodes::SqlLiteral.new viz.accept @ctx
+    end
+
+    def take limit
+      @head.limit = limit
+      self
+    end
+
+    def join_sql
+      return nil unless @ctx.froms
+
+      viz = Visitors::JoinSql.new @engine
+      Nodes::SqlLiteral.new viz.accept @ctx
+    end
+
+    def order_clauses
+      Visitors::OrderClauses.new(@engine).accept(@head).map { |x|
+        Nodes::SqlLiteral.new x
+      }
+    end
+
+    def joins manager
+      manager.join_sql
+    end
+
+    class Row < Struct.new(:data) # :nodoc:
+      def id
+        data['id']
+      end
+
+      def method_missing(name, *args)
+        name = name.to_s
+        return data[name] if data.key?(name)
+        super
+      end
+    end
+
+    def to_a # :nodoc:
+      warn "to_a is deprecated. Please remove it from #{caller[0]}"
+      # FIXME: I think `select` should be made public...
+      @engine.connection.send(:select, to_sql, 'AREL').map { |x| Row.new(x) }
+    end
+
+    # FIXME: this method should go away
+    def insert values
+      im = InsertManager.new @engine
+      table = @ctx.froms
+      primary_key_name = (primary_key = table.primary_key) && primary_key.name
+      # FIXME: in AR tests values sometimes were Array and not Hash therefore is_a?(Hash) check is added
+      primary_key_value = primary_key && values.is_a?(Hash) && values[primary_key]
+      im.into table
+      im.insert values
+      # Oracle adapter needs primary key name to generate RETURNING ... INTO ... clause
+      # for tables which assign primary key value using trigger.
+      # RETURNING ... INTO ... clause will be added only if primary_key_value is nil
+      # therefore it is necessary to pass primary key value as well
+      @engine.connection.insert im.to_sql, 'AREL', primary_key_name, primary_key_value
+    end
+
+    private
+    def collapse exprs
+      return exprs.first if exprs.length == 1
+
+      right = exprs.pop
+      left  = exprs.pop
+
+      right = Nodes::SqlLiteral.new(right) if String === right
+
+      right = Nodes::And.new left, right
+      exprs.reverse.inject(right) { |memo,expr|
+        Nodes::And.new(expr, memo)
+      }
+    end
+  end
+end