Arel::SqlCompiler::OracleCompiler

    # File lib/arel/engines/sql/compilers/oracle_compiler.rb, line 65
65:       def delete_sql
66:         where_clauses = relation.wheres.collect(&:to_sql)
67:         taken = relation.taken
68:         where_clauses << "ROWNUM <= #{taken}" unless taken.blank?
69:         build_query            "DELETE",
70:           "FROM #{relation.table_sql}",
71:           ("WHERE #{where_clauses.join(' AND ')}" unless where_clauses.blank? )
72:       end

    # File lib/arel/engines/sql/compilers/oracle_compiler.rb, line 5
 5:       def select_sql
 6:         select_clauses = relation.select_clauses
 7:         from_clauses = relation.from_clauses
 8:         joins = relation.joins(self)
 9:         where_clauses = relation.where_clauses
10:         order_clauses = relation.order_clauses
11:         group_clauses = relation.group_clauses
12:         having_clauses = relation.having_clauses
13:         taken = relation.taken
14:         skipped = relation.skipped
15:         if limit_or_offset = !taken.blank? || !skipped.blank?
16:           # if need to select first records without ORDER BY and GROUP BY and without DISTINCT
17:           # then can use simple ROWNUM in WHERE clause
18:           if skipped.blank? && group_clauses.blank? && order_clauses.blank? && select_clauses[0] !~ /^DISTINCT /
19:             where_clauses << "ROWNUM <= #{taken}" if !taken.blank? && skipped.blank? && group_clauses.blank? && order_clauses.blank?
20:             limit_or_offset = false
21:           end
22:         end
23: 
24:         # when limit or offset subquery is used then cannot use FOR UPDATE directly
25:         # and need to construct separate subquery for primary key
26:         if use_subquery_for_lock = limit_or_offset && !locked.blank?
27:           quoted_primary_key = engine.connection.quote_column_name(relation.primary_key)
28:         end
29:         select_attributes_string = use_subquery_for_lock ? quoted_primary_key : select_clauses.join(', ')
30: 
31:         # OracleEnhanced adapter workaround when ORDER BY is used with columns not
32:         # present in DISTINCT columns list
33:         order_clauses_array = if select_attributes_string =~ /DISTINCT.*FIRST_VALUE/ && !order_clauses.blank?
34:           order = order_clauses.join(', ').split(',').map { |s| s.strip }.reject(&:blank?)
35:           order = order.zip((0...order.size).to_a).map { |s,i| "alias_#{i}__ #{'DESC' if s =~ /\bdesc$/i}" }
36:         else
37:           order_clauses
38:         end
39: 
40:         query = build_query            "SELECT     #{select_attributes_string}",
41:           "FROM       #{from_clauses}",
42:           (joins                                         unless joins.blank?               ),
43:           ("WHERE     #{where_clauses.join(' AND ')}"    unless where_clauses.blank?       ),
44:           ("GROUP BY  #{group_clauses.join(', ')}"       unless group_clauses.blank?       ),
45:           ("HAVING    #{having_clauses.join(' AND ')}"   unless having_clauses.blank?      ),
46:           ("ORDER BY  #{order_clauses_array.join(', ')}" unless order_clauses_array.blank? )
47: 
48:         # Use existing method from oracle_enhanced adapter to implement limit and offset using subqueries
49:         engine.connection.add_limit_offset!(query, :limit => taken, :offset => skipped) if limit_or_offset
50: 
51:         if use_subquery_for_lock
52:           build_query              "SELECT     #{select_clauses.join(', ')}",
53:             "FROM       #{from_clauses}",
54:             "WHERE      #{quoted_primary_key} IN (#{query})",
55:             "#{locked}"
56:         elsif !locked.blank?
57:           build_query query, "#{locked}"
58:         else
59:           query
60:         end
61:       end

    # File lib/arel/engines/sql/compilers/oracle_compiler.rb, line 77
77:       def build_update_conditions_sql
78:         conditions = ""
79:         where_clauses = relation.wheres.collect(&:to_sql)
80:         taken = relation.taken
81:         # if need to select first records without ORDER BY
82:         # then can use simple ROWNUM in WHERE clause
83:         if !taken.blank? && relation.orders.blank?
84:           where_clauses << "ROWNUM <= #{taken}"
85:         end
86:         conditions << " WHERE #{where_clauses.join(' AND ')}" unless where_clauses.blank?
87:         unless taken.blank?
88:           conditions = limited_update_conditions(conditions, taken)
89:         end
90:         conditions
91:       end

     # File lib/arel/engines/sql/compilers/oracle_compiler.rb, line 93
 93:       def limited_update_conditions(conditions, taken)
 94:         order_clauses = relation.order_clauses
 95:         # need to add ORDER BY only if just taken ones should be updated
 96:         conditions << " ORDER BY #{order_clauses.join(', ')}" unless order_clauses.blank?
 97:         quoted_primary_key = engine.connection.quote_column_name(relation.primary_key)
 98:         subquery = "SELECT #{quoted_primary_key} FROM #{engine.connection.quote_table_name relation.table.name} #{conditions}"
 99:         # Use existing method from oracle_enhanced adapter to get taken records when ORDER BY is used
100:         engine.connection.add_limit_offset!(subquery, :limit => taken) unless order_clauses.blank?
101:         "WHERE #{quoted_primary_key} IN (#{subquery})"
102:       end