square-arel 2.0.9.20110222133018

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,237 @@
+module Arel
+  class SelectManager < Arel::TreeManager
+    include Arel::Crud
+
+    def initialize engine, table = nil
+      super(engine)
+      @ast   = Nodes::SelectStatement.new
+      @ctx    = @ast.cores.last
+      from table
+    end
+
+    def taken
+      @ast.limit && @ast.limit.expr
+    end
+
+    def constraints
+      @ctx.wheres
+    end
+
+    def skip amount
+      @ast.offset = Nodes::Offset.new(amount)
+      self
+    end
+
+    ###
+    # Produces an Arel::Nodes::Exists node
+    def exists
+      Arel::Nodes::Exists.new @ast
+    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 = Arel.sql('FOR UPDATE')
+      case locking
+      when true
+        locking = Arel.sql('FOR UPDATE')
+      when Arel::Nodes::SqlLiteral
+      when String
+        locking = Arel.sql locking
+      end
+
+      @ast.lock = Nodes::Lock.new(locking)
+      self
+    end
+
+    def locked
+      @ast.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|
+        [Symbol, String].include?(x.class) ? SqlLiteral.new(x.to_s) : x
+      }
+      self
+    end
+
+    def order *expr
+      # FIXME: We SHOULD NOT be converting these to SqlLiteral automatically
+      @ast.orders.concat expr.map { |x|
+        String === x || Symbol === x ? Nodes::SqlLiteral.new(x.to_s) : x
+      }
+      self
+    end
+
+    def orders
+      @ast.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 union operation, other = nil
+      if other
+        node_class = Nodes.const_get("Union#{operation.to_s.capitalize}")
+      else
+        other = operation
+        node_class = Nodes::Union
+      end
+
+      node_class.new self.ast, other.ast
+    end
+
+    def intersect other
+      Nodes::Intersect.new ast, other.ast
+    end
+
+    def except other
+      Nodes::Except.new ast, other.ast
+    end
+    alias :minus :except
+
+    def take limit
+      @ast.limit = Nodes::Limit.new(limit)
+      @ctx.top   = Nodes::Top.new(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(@ast).map { |x|
+        Nodes::SqlLiteral.new x
+      }
+    end
+
+    def joins manager
+      if $VERBOSE
+        warn "joins is deprecated and will be removed in 2.2"
+        warn "please remove your call to joins from #{caller.first}"
+      end
+      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
+      exprs.map! { |x| x.class == ::String ? Arel.sql(x) : x }
+
+      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

data/lib/arel/sql/engine.rb

@@ -0,0 +1,10 @@
+module Arel
+  module Sql
+    class Engine
+      def self.new thing
+        #warn "#{caller.first} -- Engine will be removed"
+        thing
+      end
+    end
+  end
+end

data/lib/arel/sql_literal.rb

@@ -0,0 +1,4 @@
+module Arel
+  class SqlLiteral < Nodes::SqlLiteral
+  end
+end

data/lib/arel/table.rb

@@ -0,0 +1,134 @@
+module Arel
+  class Table
+    include Arel::Crud
+
+    @engine = nil
+    class << self; attr_accessor :engine; end
+
+    attr_accessor :name, :engine, :aliases, :table_alias
+
+    def initialize name, engine = Table.engine
+      @name    = name.to_s
+      @engine  = engine
+      @columns = nil
+      @aliases = []
+      @table_alias = nil
+      @primary_key = nil
+
+      if Hash === engine
+        @engine  = engine[:engine] || Table.engine
+        @columns = attributes_for engine[:columns]
+
+        # Sometime AR sends an :as parameter to table, to let the table know
+        # that it is an Alias.  We may want to override new, and return a
+        # TableAlias node?
+        @table_alias = engine[:as] unless engine[:as].to_s == @name
+      end
+    end
+
+    def primary_key
+      @primary_key ||= begin
+        primary_key_name = @engine.connection.primary_key(name)
+        # some tables might be without primary key
+        primary_key_name && self[primary_key_name]
+      end
+    end
+
+    def alias name = "#{self.name}_2"
+      Nodes::TableAlias.new(name, self).tap do |node|
+        @aliases << node
+      end
+    end
+
+    def from table
+      SelectManager.new(@engine, table)
+    end
+
+    def joins manager
+      if $VERBOSE
+        warn "joins is deprecated and will be removed in 2.2"
+        warn "please remove your call to joins from #{caller.first}"
+      end
+      nil
+    end
+
+    def join relation, klass = Nodes::InnerJoin
+      return from(self) unless relation
+
+      case relation
+      when String, Nodes::SqlLiteral
+        raise if relation.blank?
+        from Nodes::StringJoin.new(self, relation)
+      else
+        from klass.new(self, relation, nil)
+      end
+    end
+
+    def group *columns
+      from(self).group(*columns)
+    end
+
+    def order *expr
+      from(self).order(*expr)
+    end
+
+    def where condition
+      from(self).where condition
+    end
+
+    def project *things
+      from(self).project(*things)
+    end
+
+    def take amount
+      from(self).take amount
+    end
+
+    def skip amount
+      from(self).skip amount
+    end
+
+    def having expr
+      from(self).having expr
+    end
+
+    def columns
+      @columns ||=
+        attributes_for @engine.connection.columns(@name, "#{@name} Columns")
+    end
+
+    def [] name
+      return nil unless table_exists?
+
+      name = name.to_sym
+      columns.find { |column| column.name == name }
+    end
+
+    def select_manager
+      SelectManager.new(@engine)
+    end
+
+    private
+
+    def attributes_for columns
+      return nil unless columns
+
+      columns.map do |column|
+        Attributes.for(column).new self, column.name.to_sym, column
+      end
+    end
+
+    def table_exists?
+      @table_exists ||= tables.key?(@name) || engine.connection.table_exists?(name)
+    end
+
+    def tables
+      self.class.table_cache(@engine)
+    end
+
+    @@table_cache = nil
+    def self.table_cache engine # :nodoc:
+      @@table_cache ||= Hash[engine.connection.tables.map { |x| [x,true] }]
+    end
+  end
+end

data/lib/arel/tree_manager.rb

@@ -0,0 +1,36 @@
+module Arel
+  class TreeManager
+    # FIXME: Remove this.
+    include Arel::Relation
+
+    attr_accessor :visitor
+    attr_reader :ast, :engine
+
+    def initialize engine
+      @engine  = engine
+      @visitor = Visitors.visitor_for @engine
+      @ctx     = nil
+    end
+
+    def to_dot
+      Visitors::Dot.new.accept @ast
+    end
+
+    def to_sql
+      @visitor.accept @ast
+    end
+
+    def initialize_copy other
+      super
+      @ast = @ast.clone
+    end
+
+    def where expr
+      if Arel::TreeManager === expr
+        expr = expr.ast
+      end
+      @ctx.wheres << expr
+      self
+    end
+  end
+end

data/lib/arel/update_manager.rb

@@ -0,0 +1,49 @@
+module Arel
+  class UpdateManager < Arel::TreeManager
+    def initialize engine
+      super
+      @ast = Nodes::UpdateStatement.new
+      @ctx = @ast
+    end
+
+    def take limit
+      @ast.limit = Nodes::Limit.new(limit) if limit
+      self
+    end
+
+    def order *expr
+      @ast.orders = expr
+      self
+    end
+
+    ###
+    # UPDATE +table+
+    def table table
+      @ast.relation = table
+      self
+    end
+
+    def wheres= exprs
+      @ast.wheres = exprs
+    end
+
+    def where expr
+      @ast.wheres << expr
+      self
+    end
+
+    def set values
+      if String === values
+        @ast.values = [values]
+      else
+        @ast.values = values.map { |column,value|
+          Nodes::Assignment.new(
+            Nodes::UnqualifiedColumn.new(column),
+            value
+          )
+        }
+      end
+      self
+    end
+  end
+end