Module: Torque::PostgreSQL::Relation

Extended by:
ActiveSupport::Concern
Includes:
AuxiliaryStatement, DistinctOn, Inheritance
Defined in:
lib/torque/postgresql/relation.rb,
lib/torque/postgresql/relation/merger.rb,
lib/torque/postgresql/relation/distinct_on.rb,
lib/torque/postgresql/relation/inheritance.rb,
lib/torque/postgresql/relation/auxiliary_statement.rb

Defined Under Namespace

Modules: AuxiliaryStatement, ClassMethods, DistinctOn, Inheritance, Initializer, Merger

Constant Summary collapse

SINGLE_VALUE_METHODS = 
[:itself_only]
MULTI_VALUE_METHODS = 
[:distinct_on, :auxiliary_statements, :cast_records, :select_extra]
VALUE_METHODS = 
SINGLE_VALUE_METHODS + MULTI_VALUE_METHODS
ARColumn = 
::ActiveRecord::ConnectionAdapters::PostgreSQL::Column

Instance Method Summary collapse

Methods included from Inheritance

#cast_records, #cast_records!, #cast_records_value, #cast_records_value=, #itself_only, #itself_only!, #itself_only_value, #itself_only_value=

Methods included from AuxiliaryStatement

#auxiliary_statements_values, #auxiliary_statements_values=, #bound_attributes, #with, #with!

Methods included from DistinctOn

#distinct_on, #distinct_on!, #distinct_on_values, #distinct_on_values=

Instance Method Details

#calculate(operation, column_name) ⇒ Object

Resolve column name when calculating models, allowing the column name to be more complex while keeping the query selection quality



31
32
33
34
 
# File 'lib/torque/postgresql/relation.rb', line 31

def calculate(operation, column_name)
  column_name = resolve_column(column_name).first if column_name.is_a?(Hash)
  super(operation, column_name)
end

#cast_for_condition(column, value) ⇒ Object

Serialize the given value so it can be used in a condition tha involves the given column



81
82
83
84
85
 
# File 'lib/torque/postgresql/relation.rb', line 81

def cast_for_condition(column, value)
  column = columns_hash[column.to_s] unless column.is_a?(ARColumn)
  caster = connection.lookup_cast_type_from_column(column)
  connection.type_cast(caster.serialize(value))
end

#resolve_base_table(relation) ⇒ Object

Get the TableMetadata from a relation



68
69
70
71
72
73
74
75
76
77
 
# File 'lib/torque/postgresql/relation.rb', line 68

def resolve_base_table(relation)
  return unless relation

  table = predicate_builder.send(:table)
  if table.associated_with?(relation.to_s)
    table.associated_table(relation.to_s).send(:klass)
  else
    raise ArgumentError, "Relation for #{relation} not found on #{klass}"
  end
end

#resolve_column(list, base = false) ⇒ Object

Resolve column definition up to second value. For example, based on Post model:

resolve_column(['name', :title])
# Returns ['name', '"posts"."title"']

resolve_column([:title, {authors: :name}])
# Returns ['"posts"."title"', '"authors"."name"']

resolve_column([{authors: [:name, :age]}])
# Returns ['"authors"."name"', '"authors"."age"']



47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/torque/postgresql/relation.rb', line 47

def resolve_column(list, base = false)
  base = resolve_base_table(base)

  Array.wrap(list).map do |item|
    case item
    when String
      ::Arel.sql(klass.send(:sanitize_sql, item.to_s))
    when Symbol
      base ? base.arel_table[item] : klass.arel_table[item]
    when Array
      resolve_column(item, base)
    when Hash
      raise ArgumentError, 'Unsupported Hash for attributes on third level' if base
      item.map { |key, other_list| resolve_column(other_list, key) }
    else
      raise ArgumentError, "Unsupported argument type: #{value} (#{value.class})"
    end
  end.flatten
end

#select_extra_values ⇒ Object

:nodoc:



25
 
# File 'lib/torque/postgresql/relation.rb', line 25

def select_extra_values; get_value(:select_extra); end

#select_extra_values=(value) ⇒ Object

:nodoc:



27
 
# File 'lib/torque/postgresql/relation.rb', line 27

def select_extra_values=(value); set_value(:select_extra, value); end