Fetching limited records SQL

Question

Hi All,
Need all your valuable advise again.
The ISSUE is :-
Rightnow, the SELECT below , the inner query will fetch all the records from the database. Outer query will fetch the exact block of records from the inner query results(total available).
Example:- Lets consider a person search query is used to filter the records by department. Assume this query yields 30K records
Whatwe do today is,
SELECT * FROM(
SELECT
rownumrownumber,deptname
FROM person
WHERE department = 'Electronics' // Assume this inner query fetches 30K records
) WHERE rownumberbetween 100 and 125;// out of 30K we just need the 25 results
Solution:
How do we make the Inner query to limit the maximum records we wanted? Presently,its fetching all records.
SELECT * FROM(
SELECT
rownum rownumber,deptname
FROM person
WHERE department = 'Electronics' ANDrownum<=125 // now the inner query will fetch only 125 records
) WHERE rownumber between 100 and 125;// out of 30K we just need the 25 results

Answer 1

Take a look at these two articles:
[On Top-N and Pagination Queries|http://www.oracle.com/technology/oramag/oracle/07-jan/o17asktom.html]
[On Rownum and Limiting Results|http://www.oracle.com/technology/oramag/oracle/06-sep/o56asktom.html]
These show how to handle all sorts of situation (e.g. if you care about ordering or not). In any case the simple solution is:
Pagination with ROWNUM
My all-time-favorite use of ROWNUM is pagination. In this case, I use ROWNUM to get rows N through M of a result set. The general form is as follows:
select *
  from ( select /*+ FIRST_ROWS(n) */
  a.*, ROWNUM rnum
      from ( your_query_goes_here,
      with order by ) a
      where ROWNUM <=
      :MAX_ROW_TO_FETCH )
where rnum  >= :MIN_ROW_TO_FETCH;
where
    * FIRST_ROWS(N) tells the optimizer, "Hey, I'm interested in getting the first rows, and I'll get N of them as fast as possible."
    * :MAX_ROW_TO_FETCH is set to the last row of the result set to fetch—if you wanted rows 50 to 60 of the result set, you would set this to 60.
    * :MIN_ROW_TO_FETCH is set to the first row of the result set to fetch, so to get rows 50 to 60, you would set this to 50.
The concept behind this scenario is that an end user with a Web browser has done a search and is waiting for the results. It is imperative to return the first result page (and second page, and so on) as fast as possible. If you look at that query closely, you'll notice that it incorporates a top-N query (get the first :MAX_ROW_TO_FETCH rows from your query) and hence benefits from the top-N query optimization I just described. Further, it returns over the network to the client only the specific rows of interest—it removes any leading rows from the result set that are not of interest. Just plug your query (without trying to worry about the number or rows returned) into the template query. The articles explain how to do more complex things.