FileDocCategorySizeDatePackage
ResultImpl.javaAPI DocGlassfish v2 API6820Sat May 05 19:17:14 BST 2007javax.servlet.jsp.jstl.sql

ResultImpl

public class ResultImpl extends Object implements Serializable, Result

This class creates a cached version of a ResultSet. It's represented as a Result implementation, capable of returing an array of Row objects containing a Column instance for each column in the row. It is not part of the JSTL API; it serves merely as a back-end to ResultSupport's static methods. Thus, we scope its access to the package.

author
Hans Bergsten
author
Justyna Horwat

Fields Summary
private List
rowMap
private List
rowByIndex
private String[]
columnNames
private boolean
isLimited
Constructors Summary
public ResultImpl(ResultSet rs, int startRow, int maxRows)
This constructor reads the ResultSet and saves a cached copy. It's important to note that this object will be serializable only if the objects returned by the ResultSet are serializable too.

param
rs an open ResultSet, positioned before the first row
param
startRow beginning row to be cached
param
maxRows query maximum rows limit
exception
java.sql.SQLException if a database error occurs

        rowMap = new ArrayList();
        rowByIndex = new ArrayList();

        ResultSetMetaData rsmd = rs.getMetaData();
        int noOfColumns = rsmd.getColumnCount();

        // Create the column name array
        columnNames = new String[noOfColumns];
        for (int i = 1; i <= noOfColumns; i++) {
            columnNames[i-1] = rsmd.getColumnName(i);
        }

        // Throw away all rows upto startRow
        for (int i = 0; i < startRow; i++) {
            rs.next();
        }

        // Process the remaining rows upto maxRows
        int processedRows = 0;
        while (rs.next()) {
            if ((maxRows != -1) && (processedRows == maxRows)) {
                isLimited = true; 
                break;
            }
            Object[] columns = new Object[noOfColumns];
            SortedMap columnMap = 
                new TreeMap(String.CASE_INSENSITIVE_ORDER);

            // JDBC uses 1 as the lowest index!
            for (int i = 1; i <= noOfColumns; i++) {
                Object value =  rs.getObject(i);
                if (rs.wasNull()) {
                    value = null;
                }
                columns[i-1] = value;
                columnMap.put(columnNames[i-1], value);
            }
            rowMap.add(columnMap);
            rowByIndex.add(columns);
            processedRows++;
        }
    
Methods Summary
public java.lang.String[]getColumnNames()
Returns an array of String objects. The array represents the names of the columns arranged in the same order as in the getRowsByIndex() method.

return
an array of String[]

        return columnNames;
    
public intgetRowCount()
Returns the number of rows in the cached ResultSet

return
the number of cached rows, or -1 if the Result could not be initialized due to SQLExceptions

        if (rowMap == null) {
            return -1;
        }
        return rowMap.size();
    
public java.util.SortedMap[]getRows()
Returns an array of SortedMap objects. The SortedMap object key is the ColumnName and the value is the ColumnValue. SortedMap was created using the CASE_INSENSITIVE_ORDER Comparator so the key is the case insensitive representation of the ColumnName.

return
an array of Map, or null if there are no rows

        if (rowMap == null) {
            return null;
        }

        //should just be able to return SortedMap[] object
        return (SortedMap []) rowMap.toArray(new SortedMap[0]);
    
public java.lang.Object[][]getRowsByIndex()
Returns an array of Object[] objects. The first index designates the Row, the second the Column. The array stores the value at the specified row and column.

return
an array of Object[], or null if there are no rows

        if (rowByIndex == null) {
            return null;
        }

        //should just be able to return Object[][] object
        return (Object [][])rowByIndex.toArray(new Object[0][0]);
    
public booleanisLimitedByMaxRows()
Returns true if the query was limited by a maximum row setting

return
true if the query was limited by a MaxRows attribute

        return isLimited;