Featured White Papers

• Measuring Risk to Improve Java Software Quality
• Do You Really Get Classloaders?
• Pragmatic Continuous Delivery with Jenkins, Nexus, and LiveRebel
• Your Next Java Web App: Less XML, No Long Restarts, Fewer Hassles
• Coding with JRebel, Java Forever Changed
• 2012 Developer Productivity Report: Java Tools, Tech, Devs, and Data

Sponsored Links

• Graph databases are 1000x faster than relational.

  Learn More!

• Career opportunities at Harman- Careers That'll Rock Your Socks Off.

  Learn More!

• Developer-friendly Java PDF libraries by Qoppa Software

  Live Demos

• Stop blaming your app! Diagnose Java performance issues.

  Free tool >

• UrbanCode: Go From Continuous Integration to
  Continuous Delivery

  Learn More!

Sponsored Links

Optimize with a SATA RAID Storage Solution
Range of capacities as low as $1250 per TB. Ideal if you currently rely on servers/disks/JBODs

Server-side Java: Use JDBC for industrial-strength performance, Part 2

Follow these Java server-side data -mining patterns with multiple ResultSets for maximum performance

By Lennart Jorelid, JavaWorld.com, 02/21/00

Page 2 of 4

The code at a glance

The database table structure used by the JDBC calling code is simply a table named test that contains two columns (id:integer and fname:varchar). In addition to the table, a stored procedure is required. The stored procedure simply performs two select statements in the test table. The implementation of the stored procedure in a TransactSQL-oriented database (such as Sybase or MS SQL Server) is:

CREATE PROCEDURE reverseSelectionProcedure AS
BEGIN
        -- First select statement, producing a 1-column JDBC ResultSet
        select fName from testlogin.Test;

        -- Second select statement, producing a 2-column JDBC ResultSet
        select * from testlogin.Test;
END

The structure of all code samples in this article follow the same pattern: they inherit all functionality, except the main() method, from the MultipleResultsets class. The main() method is fully implemented in each subclass. This complete exclusion code is given in favor of the more elegant abstract factory pattern (see the Resources section below for more information) to improve readability.

Figure 2. Scenario for using multiple ResultSets

The following is the method call sequence:

1. main() calls setupConnection(), which creates the Logger and returns a fully set-up JDBC connection to the database.
2. A PreparedStatement is created from appropriate SQL. Note that CallableStatement extends PreparedStatement.
3. processStatement() is called to print out some status data from the given PreparedStatement.
4. main() closes the Statement from step 2 and Connection from step 1.

The only helper class used is the Logger, which logs messages to a file or the standard output stream, depending on its construction. The only relevant method call of the Logger class is the log() method. Below is the code structure for all scenarios.

First, here is the code structure of the Logger class:

import java.io.*;

/**
 * Class that logs messages to a file or the
 * standard output stream.
 */
public class Logger
{
   /** Stream connected to the output file. */
   private PrintWriter out;

   /**
    * Constructor to invoke if all messages of
    * this Logger should be directed to the file
    * with the supplied filename.
    * <br>NOTE! The contents of the given file is
    * erased before any message is written to it.
    *
    * @param logFileName Name of the logfile.
    */
   public Logger(String logFileName)
   {
      try
      {
         // Create the log stream
         out = new PrintWriter(new FileWriter(logFileName), true);
      }
      catch(IOException ex)
      {
         System.out.println(" [Logger Constructor]: " + 
                   "Could not create the logFile (" + logFileName + ").");
         System.out.println(" [Logger Constructor]: " + 
                   "Reason is " + ex);
      }
   }

   /**
    * Constructor to invoke if all messages of this Logger should
    * be redirected to the standard output stream.
    */
   public Logger()
   { }

   /**
    * Prints the given message to the log stream, and
    * appends a newline character.
    *
    * @param msg Message to log.
    */
   public void log(String msg)
   {
      // Log the message
      if(out == null) System.out.println(msg);
      else out.println(msg);
   }
}

The common superclass of the examples used in this article is MultipleResultsets, as seen below. It provides two services: setting up the database connection (including loading the drivers) and processing the results of the entire PreparedStatement, which holds the SQL query to the database.