# 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