Class: Arel::Visitors::ToSql

Inherits:
Object
  • Object
show all
Includes:
AttributesAttributeExtension, SelectStatementExtension, TableExtension
Defined in:
lib/arel/extensions/all.rb,
lib/arel/extensions/any.rb,
lib/arel/extensions/row.rb,
lib/arel/extensions/into.rb,
lib/arel/extensions/trim.rb,
lib/arel/extensions/user.rb,
lib/arel/extensions/array.rb,
lib/arel/extensions/infer.rb,
lib/arel/extensions/least.rb,
lib/arel/extensions/table.rb,
lib/arel/extensions/to_sql.rb,
lib/arel/extensions/lateral.rb,
lib/arel/extensions/null_if.rb,
lib/arel/extensions/overlay.rb,
lib/arel/extensions/prepare.rb,
lib/arel/extensions/similar.rb,
lib/arel/extensions/unknown.rb,
lib/arel/extensions/coalesce.rb,
lib/arel/extensions/conflict.rb,
lib/arel/extensions/equality.rb,
lib/arel/extensions/function.rb,
lib/arel/extensions/greatest.rb,
lib/arel/extensions/ordering.rb,
lib/arel/extensions/overlaps.rb,
lib/arel/extensions/position.rb,
lib/arel/extensions/dealocate.rb,
lib/arel/extensions/factorial.rb,
lib/arel/extensions/not_equal.rb,
lib/arel/extensions/substring.rb,
lib/arel/extensions/type_cast.rb,
lib/arel/extensions/assignment.rb,
lib/arel/extensions/bit_string.rb,
lib/arel/extensions/cross_join.rb,
lib/arel/extensions/except_all.rb,
lib/arel/extensions/local_time.rb,
lib/arel/extensions/indirection.rb,
lib/arel/extensions/not_between.rb,
lib/arel/extensions/not_similar.rb,
lib/arel/extensions/select_core.rb,
lib/arel/extensions/transaction.rb,
lib/arel/extensions/at_time_zone.rb,
lib/arel/extensions/current_date.rb,
lib/arel/extensions/current_role.rb,
lib/arel/extensions/current_time.rb,
lib/arel/extensions/current_user.rb,
lib/arel/extensions/extract_from.rb,
lib/arel/extensions/natural_join.rb,
lib/arel/extensions/session_user.rb,
lib/arel/extensions/variable_set.rb,
lib/arel/extensions/intersect_all.rb,
lib/arel/extensions/variable_show.rb,
lib/arel/extensions/current_schema.rb,
lib/arel/extensions/default_values.rb,
lib/arel/extensions/named_argument.rb,
lib/arel/extensions/named_function.rb,
lib/arel/extensions/range_function.rb,
lib/arel/extensions/set_to_default.rb,
lib/arel/extensions/array_subselect.rb,
lib/arel/extensions/current_catalog.rb,
lib/arel/extensions/local_timestamp.rb,
lib/arel/extensions/with_ordinality.rb,
lib/arel/extensions/delete_statement.rb,
lib/arel/extensions/insert_statement.rb,
lib/arel/extensions/select_statement.rb,
lib/arel/extensions/update_statement.rb,
lib/arel/extensions/between_symmetric.rb,
lib/arel/extensions/current_timestamp.rb,
lib/arel/extensions/attributes_attribute.rb,
lib/arel/extensions/current_of_expression.rb,
lib/arel/extensions/not_between_symmetric.rb,
lib/arel/extensions/active_model_attribute_with_cast_value.rb,
lib/arel/extensions/active_record_relation_query_attribute.rb

Defined Under Namespace

Modules: AttributesAttributeExtension, SelectStatementExtension, TableExtension

Instance Method Summary collapse

Methods included from TableExtension

#visit_Arel_Table

Methods included from SelectStatementExtension

#visit_Arel_Nodes_SelectStatement

Instance Method Details

#aggregate(name, o, collector) ⇒ Object

rubocop:disable Metrics/PerceivedComplexity rubocop:disable Metrics/CyclomaticComplexity rubocop:disable Metrics/AbcSize



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/arel/extensions/function.rb', line 35

def aggregate(name, o, collector)
  collector << "#{o.schema_name}." if o.schema_name
  collector << "#{name}("
  collector << 'DISTINCT ' if o.distinct
  collector << 'VARIADIC ' if o.variardic

  collector = inject_join(o.expressions, collector, ', ')

  if o.within_group
    collector << ')'
    collector << ' WITHIN GROUP ('
  end

  if o.orders.any?
    collector << ' ' unless o.within_group
    collector << 'ORDER BY '
    collector = inject_join o.orders, collector, ', '
  end

  collector << ')'

  if o.filter
    collector << ' FILTER(WHERE '
    visit o.filter, collector
    collector << ')'
  end

  if o.alias
    collector << ' AS '
    visit o.alias, collector
  else
    collector
  end
end

#apply_ordering_nulls(o, collector) ⇒ Object 



36
37
38
39
40
41
42
43
44
45
 
# File 'lib/arel/extensions/ordering.rb', line 36

def apply_ordering_nulls(o, collector)
  case o.nulls
  when 1
    collector << ' NULLS FIRST'
  when 2
    collector << ' NULLS LAST'
  else
    collector
  end
end

#grouping_parentheses(o, collector) ⇒ Object

github.com/mvgijssel/arel_toolkit/issues/46



20
21
22
23
24
25
26
27
28
 
# File 'lib/arel/extensions/lateral.rb', line 20

def grouping_parentheses(o, collector)
  if o.expr.is_a? Nodes::SelectStatement
    collector << '('
    visit o.expr, collector
    collector << ')'
  else
    visit o.expr, collector
  end
end

#old_visit_Arel_Nodes_Ascending ⇒ Object 



24
 
# File 'lib/arel/extensions/ordering.rb', line 24

alias old_visit_Arel_Nodes_Ascending visit_Arel_Nodes_Ascending

#old_visit_Arel_Nodes_Descending ⇒ Object 



30
 
# File 'lib/arel/extensions/ordering.rb', line 30

alias old_visit_Arel_Nodes_Descending visit_Arel_Nodes_Descending

#visit_ActiveModel_Attribute_WithCastValue(_o, collector) ⇒ Object 



14
15
16
 
# File 'lib/arel/extensions/active_model_attribute_with_cast_value.rb', line 14

def visit_ActiveModel_Attribute_WithCastValue(_o, collector)
  collector
end

#visit_ActiveRecord_Relation_QueryAttribute(_o, collector) ⇒ Object 



14
15
16
 
# File 'lib/arel/extensions/active_record_relation_query_attribute.rb', line 14

def visit_ActiveRecord_Relation_QueryAttribute(_o, collector)
  collector
end

#visit_Arel_Attributes_Attribute(o, collector) ⇒ Object Also known as: visit_Arel_Attributes_Integer, visit_Arel_Attributes_Float, visit_Arel_Attributes_Decimal, visit_Arel_Attributes_String, visit_Arel_Attributes_Time, visit_Arel_Attributes_Boolean 



7
8
9
10
11
12
13
14
 
# File 'lib/arel/extensions/to_sql.rb', line 7

def visit_Arel_Attributes_Attribute(o, collector)
  if o.relation
    join_name = o.relation.table_alias || o.relation.name
    collector << "#{quote_table_name join_name}.#{quote_column_name o.name}"
  else
    visit_Arel_Nodes_UnqualifiedColumn o, collector
  end
end

#visit_Arel_Nodes_All(o, collector) ⇒ Object 



13
14
15
16
17
 
# File 'lib/arel/extensions/all.rb', line 13

def visit_Arel_Nodes_All(o, collector)
  collector << 'ALL('
  visit o.expr, collector
  collector << ')'
end

#visit_Arel_Nodes_Any(o, collector) ⇒ Object 



13
14
15
16
17
 
# File 'lib/arel/extensions/any.rb', line 13

def visit_Arel_Nodes_Any(o, collector)
  collector << 'ANY('
  visit o.expr, collector
  collector << ')'
end

#visit_Arel_Nodes_Array(o, collector) ⇒ Object 



12
13
14
15
16
 
# File 'lib/arel/extensions/array.rb', line 12

def visit_Arel_Nodes_Array(o, collector)
  collector << 'ARRAY['
  inject_join(o.expr, collector, ', ')
  collector << ']'
end

#visit_Arel_Nodes_ArraySubselect(o, collector) ⇒ Object 



13
14
15
16
17
 
# File 'lib/arel/extensions/array_subselect.rb', line 13

def visit_Arel_Nodes_ArraySubselect(o, collector)
  collector << 'ARRAY('
  visit o.expr, collector
  collector << ')'
end

#visit_Arel_Nodes_Ascending(o, collector) ⇒ Object 



25
26
27
28
 
# File 'lib/arel/extensions/ordering.rb', line 25

def visit_Arel_Nodes_Ascending(o, collector)
  old_visit_Arel_Nodes_Ascending(o, collector)
  apply_ordering_nulls(o, collector)
end

#visit_Arel_Nodes_Assignment(o, collector) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
 
# File 'lib/arel/extensions/assignment.rb', line 6

def visit_Arel_Nodes_Assignment(o, collector)
  collector = visit o.left, collector
  collector << ' = '

  case o.right
  when Arel::Nodes::Node, Arel::Attributes::Attribute
    visit o.right, collector
  else
    collector << quote(o.right).to_s
  end
end

#visit_Arel_Nodes_AtTimeZone(o, collector) ⇒ Object 



20
21
22
23
24
 
# File 'lib/arel/extensions/at_time_zone.rb', line 20

def visit_Arel_Nodes_AtTimeZone(o, collector)
  visit o.expr, collector
  collector << ' AT TIME ZONE '
  visit o.timezone, collector
end

#visit_Arel_Nodes_BetweenSymmetric(o, collector) ⇒ Object 



13
14
15
16
17
 
# File 'lib/arel/extensions/between_symmetric.rb', line 13

def visit_Arel_Nodes_BetweenSymmetric(o, collector)
  collector = visit o.left, collector
  collector << ' BETWEEN SYMMETRIC '
  visit o.right, collector
end

#visit_Arel_Nodes_BitString(o, collector) ⇒ Object 



12
13
14
 
# File 'lib/arel/extensions/bit_string.rb', line 12

def visit_Arel_Nodes_BitString(o, collector)
  collector << "B'#{o.expr[1..-1]}'"
end

#visit_Arel_Nodes_Coalesce(o, collector) ⇒ Object 



13
14
15
16
17
 
# File 'lib/arel/extensions/coalesce.rb', line 13

def visit_Arel_Nodes_Coalesce(o, collector)
  collector << 'COALESCE('
  collector = inject_join(o.expr, collector, ', ')
  collector << ')'
end

#visit_Arel_Nodes_Conflict(o, collector) ⇒ Object

rubocop:disable Metrics/AbcSize



18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/arel/extensions/conflict.rb', line 18

def visit_Arel_Nodes_Conflict(o, collector)
  collector << ' ON CONFLICT '

  visit(o.infer, collector) if o.infer

  case o.action
  when :ONCONFLICT_NOTHING
    collector << 'DO NOTHING'
  when :ONCONFLICT_UPDATE
    collector << 'DO UPDATE SET '
  else
    raise "Unknown conflict clause `#{o.action}`"
  end

  o.values.any? && (inject_join o.values, collector, ', ')

  if o.wheres.any?
    collector << ' WHERE '
    collector = inject_join o.wheres, collector, ' AND '
  end

  collector
end

#visit_Arel_Nodes_CrossJoin(o, collector) ⇒ Object 



12
13
14
15
 
# File 'lib/arel/extensions/cross_join.rb', line 12

def visit_Arel_Nodes_CrossJoin(o, collector)
  collector << 'CROSS JOIN '
  visit o.left, collector
end

#visit_Arel_Nodes_CurrentCatalog(_o, collector) ⇒ Object 



12
13
14
 
# File 'lib/arel/extensions/current_catalog.rb', line 12

def visit_Arel_Nodes_CurrentCatalog(_o, collector)
  collector << 'current_catalog'
end

#visit_Arel_Nodes_CurrentDate(_o, collector) ⇒ Object 



12
13
14
 
# File 'lib/arel/extensions/current_date.rb', line 12

def visit_Arel_Nodes_CurrentDate(_o, collector)
  collector << 'current_date'
end

#visit_Arel_Nodes_CurrentOfExpression(o, collector) ⇒ Object 



13
14
15
16
 
# File 'lib/arel/extensions/current_of_expression.rb', line 13

def visit_Arel_Nodes_CurrentOfExpression(o, collector)
  collector << 'CURRENT OF '
  collector << o.expr
end

#visit_Arel_Nodes_CurrentRole(_o, collector) ⇒ Object 



12
13
14
 
# File 'lib/arel/extensions/current_role.rb', line 12

def visit_Arel_Nodes_CurrentRole(_o, collector)
  collector << 'current_role'
end

#visit_Arel_Nodes_CurrentSchema(_o, collector) ⇒ Object 



12
13
14
 
# File 'lib/arel/extensions/current_schema.rb', line 12

def visit_Arel_Nodes_CurrentSchema(_o, collector)
  collector << 'current_schema'
end

#visit_Arel_Nodes_CurrentTime(o, collector) ⇒ Object 



12
13
14
15
16
 
# File 'lib/arel/extensions/current_time.rb', line 12

def visit_Arel_Nodes_CurrentTime(o, collector)
  collector << 'current_time'
  collector << "(#{o.precision.to_i})" if o.precision
  collector
end

#visit_Arel_Nodes_CurrentTimestamp(o, collector) ⇒ Object 



12
13
14
15
16
 
# File 'lib/arel/extensions/current_timestamp.rb', line 12

def visit_Arel_Nodes_CurrentTimestamp(o, collector)
  collector << 'current_timestamp'
  collector << "(#{o.precision.to_i})" if o.precision
  collector
end

#visit_Arel_Nodes_CurrentUser(_o, collector) ⇒ Object 



12
13
14
 
# File 'lib/arel/extensions/current_user.rb', line 12

def visit_Arel_Nodes_CurrentUser(_o, collector)
  collector << 'current_user'
end

#visit_Arel_Nodes_Dealocate(o, collector) ⇒ Object 



13
14
15
 
# File 'lib/arel/extensions/dealocate.rb', line 13

def visit_Arel_Nodes_Dealocate(o, collector)
  collector << 'DEALLOCATE ' << (o.name || 'ALL')
end

#visit_Arel_Nodes_DefaultValues(_o, collector) ⇒ Object 



13
14
15
 
# File 'lib/arel/extensions/default_values.rb', line 13

def visit_Arel_Nodes_DefaultValues(_o, collector)
  collector << 'DEFAULT VALUES'
end

#visit_Arel_Nodes_DeleteStatement(o, collector) ⇒ Object

rubocop:disable Metrics/AbcSize



30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/arel/extensions/delete_statement.rb', line 30

def visit_Arel_Nodes_DeleteStatement(o, collector)
  if o.with
    collector = visit o.with, collector
    collector << ' '
  end

  if Gem.loaded_specs['activerecord'].version >= Gem::Version.new('6.0.0')
    o = prepare_delete_statement(o)

    if has_join_sources?(o)
      collector << 'DELETE '
      visit o.relation.left, collector
      collector << ' FROM '
    else
      collector << 'DELETE FROM '
    end
  else
    collector << 'DELETE FROM '
  end

  collector = visit o.relation, collector

  collect_nodes_for o.using, collector, ' USING ', ', '
  collect_nodes_for o.wheres, collector, ' WHERE ', ' AND '
  collect_nodes_for o.returning, collector, ' RETURNING ', ', '
  collect_nodes_for o.orders, collector, ' ORDER BY '
  maybe_visit o.limit, collector
end

#visit_Arel_Nodes_Descending(o, collector) ⇒ Object 



31
32
33
34
 
# File 'lib/arel/extensions/ordering.rb', line 31

def visit_Arel_Nodes_Descending(o, collector)
  old_visit_Arel_Nodes_Descending(o, collector)
  apply_ordering_nulls(o, collector)
end

#visit_Arel_Nodes_Equality(o, collector) ⇒ Object 



7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
# File 'lib/arel/extensions/equality.rb', line 7

def visit_Arel_Nodes_Equality(o, collector)
  right = o.right
  collector = visit o.left, collector

  if [Arel::Nodes::Unknown, Arel::Nodes::False, Arel::Nodes::True].include?(right.class)
    collector << ' IS '
    visit right, collector

  elsif right.nil?
    collector << ' IS NULL'

  else
    collector << ' = '
    visit right, collector
  end
end

#visit_Arel_Nodes_ExceptAll(o, collector) ⇒ Object 



12
13
14
15
 
# File 'lib/arel/extensions/except_all.rb', line 12

def visit_Arel_Nodes_ExceptAll(o, collector)
  collector << '( '
  infix_value(o, collector, ' EXCEPT ALL ') << ' )'
end

#visit_Arel_Nodes_ExtractFrom(o, collector) ⇒ Object 



13
14
15
16
17
18
19
 
# File 'lib/arel/extensions/extract_from.rb', line 13

def visit_Arel_Nodes_ExtractFrom(o, collector)
  collector << 'extract('
  visit o.right, collector
  collector << ' from '
  visit o.left, collector
  collector << ')'
end

#visit_Arel_Nodes_Factorial(o, collector) ⇒ Object 



20
21
22
23
24
25
26
27
28
 
# File 'lib/arel/extensions/factorial.rb', line 20

def visit_Arel_Nodes_Factorial(o, collector)
  if o.prefix
    collector << '!! '
    visit o.expr, collector
  else
    visit o.expr, collector
    collector << ' !'
  end
end

#visit_Arel_Nodes_Greatest(o, collector) ⇒ Object 



13
14
15
16
17
 
# File 'lib/arel/extensions/greatest.rb', line 13

def visit_Arel_Nodes_Greatest(o, collector)
  collector << 'GREATEST('
  collector = inject_join(o.expr, collector, ', ')
  collector << ')'
end

#visit_Arel_Nodes_Indirection(o, collector) ⇒ Object 



12
13
14
15
16
17
 
# File 'lib/arel/extensions/indirection.rb', line 12

def visit_Arel_Nodes_Indirection(o, collector)
  visit(o.left, collector)
  collector << '['
  visit(o.right, collector)
  collector << ']'
end

#visit_Arel_Nodes_Infer(o, collector) ⇒ Object 



15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
# File 'lib/arel/extensions/infer.rb', line 15

def visit_Arel_Nodes_Infer(o, collector)
  if o.name.present?
    collector << 'ON CONSTRAINT '
    collector << o.left
    collector << ' '
  end

  if o.right.present?
    collector << '('
    inject_join o.right, collector, ', '
    collector << ') '
  end

  collector
end

#visit_Arel_Nodes_InsertStatement(o, collector) ⇒ Object

rubocop:disable Metrics/CyclomaticComplexity rubocop:disable Metrics/AbcSize rubocop:disable Metrics/PerceivedComplexity



30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/arel/extensions/insert_statement.rb', line 30

def visit_Arel_Nodes_InsertStatement(o, collector)
  if o.with
    collector = visit o.with, collector
    collector << ' '
  end

  collector << 'INSERT INTO '
  collector = visit o.relation, collector
  if o.columns.any?
    collector << " (#{o.columns.map do |x|
      quote_column_name x.name
    end.join ', '})"
  end

  case o.override
  when :OVERRIDING_KIND_UNDEFINED, :OVERRIDING_NOT_SET, nil
    collector << ''
  when :OVERRIDING_USER_VALUE
    collector << ' OVERRIDING USER VALUE'
  when :OVERRIDING_SYSTEM_VALUE
    collector << ' OVERRIDING SYSTEM VALUE'
  else
    raise "Unknown override `#{o.override}`"
  end

  collector = if o.values
                maybe_visit o.values, collector
              elsif o.select
                maybe_visit o.select, collector
              else
                collector
              end

  visit(o.conflict, collector) if o.conflict

  unless o.returning.empty?
    collector << ' RETURNING '
    collector = inject_join o.returning, collector, ', '
  end

  collector
end

#visit_Arel_Nodes_IntersectAll(o, collector) ⇒ Object 



12
13
14
15
 
# File 'lib/arel/extensions/intersect_all.rb', line 12

def visit_Arel_Nodes_IntersectAll(o, collector)
  collector << '( '
  infix_value(o, collector, ' INTERSECT ALL ') << ' )'
end

#visit_Arel_Nodes_Into(o, collector) ⇒ Object 



12
13
14
15
 
# File 'lib/arel/extensions/into.rb', line 12

def visit_Arel_Nodes_Into(o, collector)
  collector << 'INTO '
  visit o.expr, collector
end

#visit_Arel_Nodes_Lateral(o, collector) ⇒ Object

github.com/mvgijssel/arel_toolkit/issues/46



14
15
16
17
 
# File 'lib/arel/extensions/lateral.rb', line 14

def visit_Arel_Nodes_Lateral(o, collector)
  collector << 'LATERAL '
  grouping_parentheses o, collector
end

#visit_Arel_Nodes_Least(o, collector) ⇒ Object 



13
14
15
16
17
 
# File 'lib/arel/extensions/least.rb', line 13

def visit_Arel_Nodes_Least(o, collector)
  collector << 'LEAST('
  collector = inject_join(o.expr, collector, ', ')
  collector << ')'
end

#visit_Arel_Nodes_LocalTime(o, collector) ⇒ Object 



12
13
14
15
16
 
# File 'lib/arel/extensions/local_time.rb', line 12

def visit_Arel_Nodes_LocalTime(o, collector)
  collector << 'localtime'
  collector << "(#{o.precision.to_i})" if o.precision
  collector
end

#visit_Arel_Nodes_LocalTimestamp(o, collector) ⇒ Object 



12
13
14
15
16
 
# File 'lib/arel/extensions/local_timestamp.rb', line 12

def visit_Arel_Nodes_LocalTimestamp(o, collector)
  collector << 'localtimestamp'
  collector << "(#{o.precision.to_i})" if o.precision
  collector
end

#visit_Arel_Nodes_NamedArgument(o, collector) ⇒ Object 



14
15
16
17
18
 
# File 'lib/arel/extensions/named_argument.rb', line 14

def visit_Arel_Nodes_NamedArgument(o, collector)
  collector << o.name
  collector << ' => '
  visit(o.value, collector)
end

#visit_Arel_Nodes_NamedFunction(o, collector) ⇒ Object 



7
8
9
 
# File 'lib/arel/extensions/named_function.rb', line 7

def visit_Arel_Nodes_NamedFunction(o, collector)
  aggregate(o.name, o, collector)
end

#visit_Arel_Nodes_NaturalJoin(o, collector) ⇒ Object 



12
13
14
15
 
# File 'lib/arel/extensions/natural_join.rb', line 12

def visit_Arel_Nodes_NaturalJoin(o, collector)
  collector << 'NATURAL JOIN '
  visit o.left, collector
end

#visit_Arel_Nodes_NotBetween(o, collector) ⇒ Object 



12
13
14
15
16
 
# File 'lib/arel/extensions/not_between.rb', line 12

def visit_Arel_Nodes_NotBetween(o, collector)
  collector = visit o.left, collector
  collector << ' NOT BETWEEN '
  visit o.right, collector
end

#visit_Arel_Nodes_NotBetweenSymmetric(o, collector) ⇒ Object 



13
14
15
16
17
 
# File 'lib/arel/extensions/not_between_symmetric.rb', line 13

def visit_Arel_Nodes_NotBetweenSymmetric(o, collector)
  collector = visit o.left, collector
  collector << ' NOT BETWEEN SYMMETRIC '
  visit o.right, collector
end

#visit_Arel_Nodes_NotEqual(o, collector) ⇒ Object 



7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
# File 'lib/arel/extensions/not_equal.rb', line 7

def visit_Arel_Nodes_NotEqual(o, collector)
  right = o.right
  collector = visit o.left, collector

  if [Arel::Nodes::Unknown, Arel::Nodes::False, Arel::Nodes::True].include?(right.class)
    collector << ' IS NOT '
    visit right, collector

  elsif right.nil?
    collector << ' IS NOT NULL'

  else
    collector << ' != '
    visit right, collector
  end
end

#visit_Arel_Nodes_NotSimilar(o, collector) ⇒ Object 



13
14
15
16
17
18
19
20
21
22
23
 
# File 'lib/arel/extensions/not_similar.rb', line 13

def visit_Arel_Nodes_NotSimilar(o, collector)
  visit o.left, collector
  collector << ' NOT SIMILAR TO '
  visit o.right, collector
  if o.escape
    collector << ' ESCAPE '
    visit o.escape, collector
  else
    collector
  end
end

#visit_Arel_Nodes_NullIf(o, collector) ⇒ Object 



12
13
14
15
16
17
18
 
# File 'lib/arel/extensions/null_if.rb', line 12

def visit_Arel_Nodes_NullIf(o, collector)
  collector << 'NULLIF('
  visit o.left, collector
  collector << ', '
  visit o.right, collector
  collector << ')'
end

#visit_Arel_Nodes_Overlaps(o, collector) ⇒ Object 



30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/arel/extensions/overlaps.rb', line 30

def visit_Arel_Nodes_Overlaps(o, collector)
  collector << '('
  visit o.start1, collector
  collector << ', '
  visit o.end1, collector
  collector << ') OVERLAPS ('
  visit o.start2, collector
  collector << ', '
  visit o.end2, collector
  collector << ')'
end

#visit_Arel_Nodes_Overlay(o, collector) ⇒ Object 



25
26
27
28
29
30
31
32
33
34
35
36
37
 
# File 'lib/arel/extensions/overlay.rb', line 25

def visit_Arel_Nodes_Overlay(o, collector)
  collector << 'overlay('
  visit o.string, collector
  collector << ' placing '
  visit o.substring, collector
  collector << ' from '
  visit o.start, collector
  unless o.length.nil?
    collector << ' for '
    visit o.length, collector
  end
  collector << ')'
end

#visit_Arel_Nodes_Position(o, collector) ⇒ Object 



15
16
17
18
19
20
21
 
# File 'lib/arel/extensions/position.rb', line 15

def visit_Arel_Nodes_Position(o, collector)
  collector << 'position('
  visit o.substring, collector
  collector << ' in '
  visit o.string, collector
  collector << ')'
end

#visit_Arel_Nodes_Prepare(o, collector) ⇒ Object 



15
16
17
18
19
20
21
 
# File 'lib/arel/extensions/prepare.rb', line 15

def visit_Arel_Nodes_Prepare(o, collector)
  collector << "PREPARE #{o.name}"
  collector << " (#{o.argtypes.join(', ')})" if o.argtypes
  collector << ' AS ('
  visit(o.query, collector)
  collector << ')'
end

#visit_Arel_Nodes_RangeFunction(o, collector) ⇒ Object 



19
20
21
22
23
24
25
 
# File 'lib/arel/extensions/range_function.rb', line 19

def visit_Arel_Nodes_RangeFunction(o, collector)
  collector << 'ROWS FROM (' if o.is_rowsfrom
  visit o.expr, collector
  collector << ')' if o.is_rowsfrom

  collector
end

#visit_Arel_Nodes_Row(o, collector) ⇒ Object 



15
16
17
18
19
 
# File 'lib/arel/extensions/row.rb', line 15

def visit_Arel_Nodes_Row(o, collector)
  collector << 'ROW('
  visit o.expr, collector
  collector << ')'
end

#visit_Arel_Nodes_SelectCore(o, collector) ⇒ Object 



30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/arel/extensions/select_core.rb', line 30

def visit_Arel_Nodes_SelectCore(o, collector)
  collector << 'SELECT'

  collector = maybe_visit o.set_quantifier, collector

  collect_nodes_for o.projections, collector, ' '

  maybe_visit o.into, collector

  if o.source && !o.source.empty?
    collector << ' FROM '
    collector = visit o.source, collector
  end

  collect_nodes_for o.wheres, collector, ' WHERE ', ' AND '
  collect_nodes_for o.groups, collector, ' GROUP BY '
  unless o.havings.empty?
    collector << ' HAVING '
    inject_join o.havings, collector, ' AND '
  end
  collect_nodes_for o.windows, collector, ' WINDOW '

  collector
end

#visit_Arel_Nodes_SessionUser(_o, collector) ⇒ Object 



12
13
14
 
# File 'lib/arel/extensions/session_user.rb', line 12

def visit_Arel_Nodes_SessionUser(_o, collector)
  collector << 'session_user'
end

#visit_Arel_Nodes_SetToDefault(_o, collector) ⇒ Object 



13
14
15
 
# File 'lib/arel/extensions/set_to_default.rb', line 13

def visit_Arel_Nodes_SetToDefault(_o, collector)
  collector << 'DEFAULT'
end

#visit_Arel_Nodes_Similar(o, collector) ⇒ Object 



16
17
18
19
20
21
22
23
24
25
26
 
# File 'lib/arel/extensions/similar.rb', line 16

def visit_Arel_Nodes_Similar(o, collector)
  visit o.left, collector
  collector << ' SIMILAR TO '
  visit o.right, collector
  if o.escape
    collector << ' ESCAPE '
    visit o.escape, collector
  else
    collector
  end
end

#visit_Arel_Nodes_Substring(o, collector) ⇒ Object 



22
23
24
25
26
27
28
29
30
31
32
 
# File 'lib/arel/extensions/substring.rb', line 22

def visit_Arel_Nodes_Substring(o, collector)
  collector << 'substring('
  visit o.string, collector
  collector << ' from '
  visit o.pattern, collector
  unless o.escape.nil?
    collector << ' for '
    visit o.escape, collector
  end
  collector << ')'
end

#visit_Arel_Nodes_Transaction(o, collector) ⇒ Object 



17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
# File 'lib/arel/extensions/transaction.rb', line 17

def visit_Arel_Nodes_Transaction(o, collector)
  case o.type
  when 1
    collector << 'BEGIN'
  when 3
    collector << 'COMMIT'
  when 4
    collector << 'ROLLBACK'
  when 5
    collector << 'SAVEPOINT '
    collector << o.right
  when 6
    collector << 'RELEASE SAVEPOINT '
    collector << o.right
  when 7
    collector << 'ROLLBACK TO '
    collector << o.right
  else
    raise "Unknown transaction type `#{o.type}`"
  end
end

#visit_Arel_Nodes_Trim(o, collector) ⇒ Object 



22
23
24
25
26
27
28
29
30
 
# File 'lib/arel/extensions/trim.rb', line 22

def visit_Arel_Nodes_Trim(o, collector)
  collector << "trim(#{o.type} "
  if o.substring
    visit o.substring, collector
    collector << ' from '
  end
  visit o.string, collector
  collector << ')'
end

#visit_Arel_Nodes_TypeCast(o, collector) ⇒ Object 



24
25
26
27
28
 
# File 'lib/arel/extensions/type_cast.rb', line 24

def visit_Arel_Nodes_TypeCast(o, collector)
  visit o.arg, collector
  collector << '::'
  collector << o.type_name
end

#visit_Arel_Nodes_Unknown(_o, collector) ⇒ Object 



12
13
14
 
# File 'lib/arel/extensions/unknown.rb', line 12

def visit_Arel_Nodes_Unknown(_o, collector)
  collector << 'UNKNOWN'
end

#visit_Arel_Nodes_UpdateStatement(o, collector) ⇒ Object

rubocop:disable Metrics/AbcSize



28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/arel/extensions/update_statement.rb', line 28

def visit_Arel_Nodes_UpdateStatement(o, collector)
  if o.with
    collector = visit o.with, collector
    collector << ' '
  end

  wheres = if Gem.loaded_specs['activerecord'].version >= Gem::Version.new('6.0.0')
             o = prepare_update_statement(o)
             o.wheres
           elsif o.orders.empty? && o.limit.nil?
             o.wheres
           else
             [Nodes::In.new(o.key, [build_subselect(o.key, o)])]
           end

  collector << 'UPDATE '
  collector = visit o.relation, collector

  collect_nodes_for o.values, collector, ' SET '
  collect_nodes_for o.froms, collector, ' FROM ', ', '

  collect_nodes_for wheres, collector, ' WHERE ', ' AND '
  collect_nodes_for o.returning, collector, ' RETURNING ', ', '

  collector
end

#visit_Arel_Nodes_User(_o, collector) ⇒ Object 



12
13
14
 
# File 'lib/arel/extensions/user.rb', line 12

def visit_Arel_Nodes_User(_o, collector)
  collector << 'user'
end

#visit_Arel_Nodes_VariableSet(o, collector) ⇒ Object 



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/arel/extensions/variable_set.rb', line 24

def visit_Arel_Nodes_VariableSet(o, collector)
  collector << 'SET '
  collector << 'LOCAL ' if o.local

  if o.name == 'timezone'
    collector << 'TIME ZONE '
  else
    collector << o.name
    collector << ' TO '
  end

  if o.args.empty?
    collector << 'DEFAULT'
  else
    inject_join(o.args, collector, ', ')
  end
end

#visit_Arel_Nodes_VariableShow(o, collector) ⇒ Object 



13
14
15
16
17
18
19
20
 
# File 'lib/arel/extensions/variable_show.rb', line 13

def visit_Arel_Nodes_VariableShow(o, collector)
  collector << 'SHOW '
  collector << if o.expr == 'timezone'
                 'TIME ZONE'
               else
                 o.expr
               end
end

#visit_Arel_Nodes_WithOrdinality(o, collector) ⇒ Object 



13
14
15
16
 
# File 'lib/arel/extensions/with_ordinality.rb', line 13

def visit_Arel_Nodes_WithOrdinality(o, collector)
  visit o.expr, collector
  collector << ' WITH ORDINALITY'
end