Class: Arel::SqlCompiler::OracleCompiler

Inherits:
GenericCompiler show all
Defined in:
lib/arel/engines/sql/compilers/oracle_compiler.rb

Instance Attribute Summary

Attributes inherited from GenericCompiler

#engine, #relation

Instance Method Summary collapse

Methods inherited from GenericCompiler

#add_limit_on_delete, #build_clauses, #christener, #initialize, #insert_sql, #supports_insert_with_returning?, #update_sql

Constructor Details

This class inherits a constructor from Arel::SqlCompiler::GenericCompiler

Instance Method Details

#delete_sql ⇒ Object 



65
66
67
68
69
70
71
72
73
 
# File 'lib/arel/engines/sql/compilers/oracle_compiler.rb', line 65

def delete_sql
  where_clauses = relation.wheres.collect(&:to_sql)
  taken = relation.taken
  where_clauses << "ROWNUM <= #{taken}" unless taken.blank?
  build_query \
    "DELETE",
    "FROM #{relation.table_sql}",
    ("WHERE #{where_clauses.join(' AND ')}" unless where_clauses.blank? )
end

#select_sql ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/arel/engines/sql/compilers/oracle_compiler.rb', line 5

def select_sql
  select_clauses = relation.select_clauses
  from_clauses = relation.from_clauses
  joins = relation.joins(self)
  where_clauses = relation.where_clauses
  order_clauses = relation.order_clauses
  group_clauses = relation.group_clauses
  having_clauses = relation.having_clauses
  taken = relation.taken
  skipped = relation.skipped
  if limit_or_offset = !taken.blank? || !skipped.blank?
    # if need to select first records without ORDER BY and GROUP BY and without DISTINCT
    # then can use simple ROWNUM in WHERE clause
    if skipped.blank? && group_clauses.blank? && order_clauses.blank? && select_clauses[0] !~ /^DISTINCT /
      where_clauses << "ROWNUM <= #{taken}" if !taken.blank? && skipped.blank? && group_clauses.blank? && order_clauses.blank?
      limit_or_offset = false
    end
  end

  # when limit or offset subquery is used then cannot use FOR UPDATE directly
  # and need to construct separate subquery for primary key
  if use_subquery_for_lock = limit_or_offset && !locked.blank?
    quoted_primary_key = engine.connection.quote_column_name(relation.primary_key)
  end
  select_attributes_string = use_subquery_for_lock ? quoted_primary_key : select_clauses.join(', ')

  # OracleEnhanced adapter workaround when ORDER BY is used with columns not
  # present in DISTINCT columns list
  order_clauses_array = if select_attributes_string =~ /DISTINCT.*FIRST_VALUE/ && !order_clauses.blank?
    order = order_clauses.join(', ').split(',').map { |s| s.strip }.reject(&:blank?)
    order = order.zip((0...order.size).to_a).map { |s,i| "alias_#{i}__ #{'DESC' if s =~ /\bdesc$/i}" }
  else
    order_clauses
  end

  query = build_query \
    "SELECT     #{select_attributes_string}",
    "FROM       #{from_clauses}",
    (joins                                         unless joins.blank?               ),
    ("WHERE     #{where_clauses.join(' AND ')}"    unless where_clauses.blank?       ),
    ("GROUP BY  #{group_clauses.join(', ')}"       unless group_clauses.blank?       ),
    ("HAVING    #{having_clauses.join(' AND ')}"   unless having_clauses.blank?      ),
    ("ORDER BY  #{order_clauses_array.join(', ')}" unless order_clauses_array.blank? )

  # Use existing method from oracle_enhanced adapter to implement limit and offset using subqueries
  engine.connection.add_limit_offset!(query, :limit => taken, :offset => skipped) if limit_or_offset

  if use_subquery_for_lock
    build_query \
      "SELECT     #{select_clauses.join(', ')}",
      "FROM       #{from_clauses}",
      "WHERE      #{quoted_primary_key} IN (#{query})",
      "#{locked}"
  elsif !locked.blank?
    build_query query, "#{locked}"
  else
    query
  end
end