java.sql.SQLException: - ORA-01000: maximum open cursors exceeded

I answered a question on StackExchange about Oracle ORA-01000 errors. The answer raised more questions; the answer to the new questions raised more questions. So, here is a consolidated guide to ORA-010000. It assumes a working knowledge of Java, JDBC and SQL:

ORA-010000

ORA-01000, the maximum-open-cursors error, is an extremely common error in Oracle database development. In the context of Java, it happens when the application attempts to open more ResultSets than there are configured cursors on a database instance.

Common causes are:

1. Configuration mistake
• You have more threads in your application querying the database than cursors on the DB. One case is where you have a connection and thread pool larger than the number of cursors on the database.
• You have many developers or applications connected to the same DB instance (which will probably include many schemas) and together you are using too many connections.
• Solutions:
• Increase the number of cursors on the database (if resources allow) or
• Decrease the number of threads in the application.
2. Cursor leak
• The applications is not closing ResultSets (in JDBC) or cursors (in stored procedures on the database). Cursor leaks are bugs and increasing the number of cursors on the DB simply delays the inevitable failure.
• Solution: Fix the bug. Find leaks can be found using static code analysis, JDBC or application-level logging, and database monitoring.

More below the break...

Background

This section describes some of the theory behind cursors and how JDBC should be used. If you don't need to know the background, you can skip this and go straight to 'Eliminating Leaks'.

What is a cursor?

A cursor is a resource on the database that holds the state of a query, specifically the position where a reader is in a ResultSet. Each SELECT statement has a cursor, and PL/SQL stored procedures can open and use as many cursors as they require. You can find out more about cursors on Orafaq.

A database instance typically serves several different schemas, many different users each with multiple sessions. To do this, it has a fixed number of cursors available for all schemas, users and sessions. When all cursors are open (in use) and request comes in that requires a new cursor, the request fails with an ORA-010000 error.

Finding and setting the number of cursors

The number is normally configured by the DBA on installation. The number of cursors currently in use, the maximum number and the configuration can be accessed in the Administrator functions in Oracle SQL Developer. From SQL it can be set with:

  ALTER SYSTEM SET OPEN_CURSORS=1337 SID='*' SCOPE=BOTH;

Relating JDBC in the JVM to cursors on the DB

The JDBC objects below are tightly coupled to the following database concepts:

• JDBC Connection is the client representation of a database session and provides database transactions. A connection can have only a single transaction open at any one time (but transactions can be nested)
• A JDBC ResultSet is supported by a single cursor on the database. When close() is called on the ResultSet, the cursor is released.
• A JDBC CallableStatement invokes a stored procedure on the database, often written in PL/SQL. The stored procedure can create zero or more cursors, and can return a cursor as a JDBC ResultSet.

JDBC is thread safe: It is quite OK to pass the various JDBC objects between threads.

For example, you can create the connection in one thread; another thread can use this connection to create a PreparedStatement and a third thread can process the result set. The single major restriction is that you cannot have more than one ResultSet open on a single PreparedStatement at any time.

See Does Oracle DB support multiple (parallel) operations per connection?

Note that a database commit occurs on a Connection, and so all DML (INSERT, UPDATE and DELETE's) on that connection will commit together. Therefore, if you want to support multiple transactions at the same time, you must have at least one Connection for each concurrent Transaction.

Closing JDBC objects

A typical example of executing a ResultSet is:

    Statement stmt = conn.createStatement();
    try {
        ResultSet rs = stmt.executeQuery( "SELECT FULL_NAME FROM EMP" );
        try {
            while ( rs.next() ) {
                System.out.println( rs.getString("FULL_NAME") );
            }
        } finally {
            try { rs.close(); } catch (Exception ignore) { }
        } finally {
            try { stmt.close(); } catch (Exception ignore) { }
        }
    }

> Note how the finally clause ignores any exception raised by the close():

• If you simply close the ResultSet without the try {} catch {}, it might fail and prevent the Statement being closed
• We want to allow any exception raised in the body of the try to propagate to the caller.

If you have a loop over, for example, creating and executing Statements, remember to close each Statement within the loop.

In Java 7, Oracle has introduced the AutoCloseable interface which replaces most of the Java 6 boilerplate with some nice syntactic sugar.

Holding JDBC objects

JDBC objects can be safely held in local variables, object instance and class members. It is generally better practice to:

• Use object instance or class members to hold JDBC objects that are reused multiple times over a longer period, such as Connections and PreparedStatements
• Use local variables for ResultSets since these are obtained, looped over and then closed typically within the scope of a single function.

There is, however, an important exception: If you are using EJBs, or a Servlet/JSP container, you have to follow a strict threading model:

• Do not create threads: Only the Application Server creates threads (with which it handles incoming requests)
• Do not create connections, retrieve them from the connection pool. Only the Application Server creates connections (which you obtain from the connection pool)
• When saving values (state) between calls, you have to be very careful. Never store values in your own caches or static members - this is not safe across clusters and other weird conditions, and the Application Server may do terrible things to your data. Instead use stateful beans or a database.
• In particular, never hold JDBC objects (Connections, ResultSets, PreparedStatements, etc) over different remote invocations - let the Application Server manage this. The Application Server not only provides a connection pool, it also caches your PreparedStatements.

Eliminating leaks

There are a number of processes and tools available for helping detect and eliminating JDBC leaks:

1. During development - catching bugs early is by far the best approach:
1. Development practices: Good development practices should reduce the number of bugs in your software before it leaves the developer's desk. Specific practices include:
1. Pair programming, to educate those without sufficient experience
2. Code reviews because many eyes are better than one
3. Unit testing which means you can exercise any and all of your code base from a test tool which makes reproducing leaks trivial
4. Use existing libraries for connection pooling rather than building your own
2. Static Code Analysis: Use a tool like the excellent Findbugs to perform a static code analysis. This picks up many places where the close() has not been correctly handled. Findbugs has a plugin for Eclipse, but it also runs standalone for one-offs, has integrations into Jenkins CI and other build tools
2. At runtime:
1. Holdability and commit
1. If the ResultSet holdability is ResultSet.CLOSE_CURSORS_OVER_COMMIT, then the ResultSet is closed when the Connection.commit() method is called. This can be set using Connection.setHoldability() or by using the overloaded Connection.createStatement() method.
2. Logging at runtime.
1. Put good log statements in your code. These should be clear and understandable so your customer, support staff and teammates can grok what's going on without training. They values of key variables and attributes so that you can trace processing logic. Good logging is fundamental to debugging applications, especially those that have been deployed.
2. You can add a debugging JDBC driver to your project (for debugging - don't actually deploy it). One example (disclaimer: I have not used this one) is log4jdbc. You then need to do some simple analysis on this file to see which executes don't have a corresponding close. Counting the open and closes should highlight if there is a potential problem
3. Monitoring the database. Monitor your running application using the tools such as the SQL Developer 'Monitor SQL' function or TOAD. Monitoring is described in this article. During monitoring, you query the open cursors (eg from table v$sesstat) and review their SQL. If the number of cursors is increasing, and (most importantly) becoming dominated by one identical SQL statement, you know you have a leak with that SQL. Search your code and review.

Other thoughts

Some other ideas were explored, but were not found useful:

Can you use WeakReferences to handle closing connections?

Weak and soft references are ways of allowing you to reference an object in a way that allows the JVM to garbage collect the referent at any time it deems fit (assuming there are no strong reference chains to that object).

If you pass a ReferenceQueue in the constructor to the soft or weak Reference, the object is placed in the ReferenceQueue when the object is GC'ed when it occurs (if it occurs at all). With this approach, you can interact with the object's finalization and you could close or finalize the object at that moment.

Phantom references are a bit weirder; their purpose is only to control finalization, but you can never get a reference to the original object, so it's going to be hard to call the close() method on it.

However, it is rarely a good idea to attempt to control when the GC is run (Weak, Soft and PhantomReferences let you know after the fact that the object is enqueued for GC). In fact, if the amount of memory in the JVM is large (eg -Xmx2000m) you might never GC the object, and you will still experience the ORA-01000. If the JVM memory is small relative to your program's requirements, you may find that the ResultSet and PreparedStatement objects are GCed immediately after creation (before you can read from them), which will likely fail your program.

In summary, the weak reference mechanism is not a good way to manage and close Statement and ResultSet objects.