Module: ActiveRecord::QueryMethods

Defined in:

lib/postgres_ext/active_record/relation/query_methods.rb

Defined Under Namespace

Classes: WhereChain, WithChain

Instance Method Summary

• #build_arel_with_extensions ⇒ Object
• #build_rank(arel, rank_window_options) ⇒ Object
• #build_with(arel) ⇒ Object
• #ranked(options = :order) ⇒ Object
• #ranked!(value) ⇒ Object
• #with(opts = :chain, *rest) ⇒ Object
• #with!(opts = :chain, *rest) ⇒ Object

  :nodoc:.

Instance Method Details

#build_arel_with_extensions ⇒ Object

# File 'lib/postgres_ext/active_record/relation/query_methods.rb', line 204

def build_arel_with_extensions
  arel = build_arel_without_extensions

  build_with(arel)

  build_rank(arel, rank_value) if rank_value

  arel
end

#build_rank(arel, rank_window_options) ⇒ Object

# File 'lib/postgres_ext/active_record/relation/query_methods.rb', line 242

def build_rank(arel, rank_window_options)
  unless arel.projections.count == 1 && Arel::Nodes::Count === arel.projections.first
    rank_window = case rank_window_options
                  when :order
                    arel.orders
                  when Symbol
                    table[rank_window_options].asc
                  when Hash
                    rank_window_options.map { |field, dir| table[field].send(dir) }
                  else
                    Arel::Nodes::SqlLiteral.new "(#{rank_window_options})"
                  end

    unless rank_window.blank?
      rank_node = Arel::Nodes::SqlLiteral.new 'rank()'
      window = Arel::Nodes::Window.new
      if String === rank_window
        window = window.frame rank_window
      else
        window = window.order(rank_window)
      end
      over_node = Arel::Nodes::Over.new rank_node, window

      arel.project(over_node)
    end
  end
end

#build_with(arel) ⇒ Object

# File 'lib/postgres_ext/active_record/relation/query_methods.rb', line 214

def build_with(arel)
  with_statements = with_values.flat_map do |with_value|
    case with_value
    when String
      with_value
    when Hash
      with_value.map  do |name, expression|
        case expression
        when String
          select = Arel::Nodes::SqlLiteral.new "(#{expression})"
        when ActiveRecord::Relation, Arel::SelectManager
          select = Arel::Nodes::SqlLiteral.new "(#{expression.to_sql})"
        end
        Arel::Nodes::As.new Arel::Nodes::SqlLiteral.new("\"#{name.to_s}\""), select
      end
    when Arel::Nodes::As
      with_value
    end
  end
  unless with_statements.empty?
    if recursive_value
      arel.with :recursive, with_statements
    else
      arel.with with_statements
    end
  end
end

#ranked(options = :order) ⇒ Object

# File 'lib/postgres_ext/active_record/relation/query_methods.rb', line 195

def ranked(options = :order)
  spawn.ranked! options
end

#ranked!(value) ⇒ Object

# File 'lib/postgres_ext/active_record/relation/query_methods.rb', line 199

def ranked!(value)
  self.rank_value = value
  self
end

#with(opts = :chain, *rest) ⇒ Object

# File 'lib/postgres_ext/active_record/relation/query_methods.rb', line 176

def with(opts = :chain, *rest)
  if opts == :chain
    WithChain.new(spawn)
  elsif opts.blank?
    self
  else
    spawn.with!(opts, *rest)
  end
end

#with!(opts = :chain, *rest) ⇒ Object

:nodoc:

# File 'lib/postgres_ext/active_record/relation/query_methods.rb', line 186

def with!(opts = :chain, *rest) # :nodoc:
  if opts == :chain
    WithChain.new(self)
  else
    self.with_values += [opts] + rest
    self
  end
end