511 lines
21 KiB
Java
511 lines
21 KiB
Java
/*
|
|
* Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation. Oracle designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
package com.sun.rowset.internal;
|
|
|
|
import java.sql.*;
|
|
import javax.sql.*;
|
|
import javax.naming.*;
|
|
import java.io.*;
|
|
import java.lang.reflect.*;
|
|
|
|
import com.sun.rowset.*;
|
|
import javax.sql.rowset.*;
|
|
import javax.sql.rowset.spi.*;
|
|
|
|
/**
|
|
* The facility called by the <code>RIOptimisticProvider</code> object
|
|
* internally to read data into it. The calling <code>RowSet</code> object
|
|
* must have implemented the <code>RowSetInternal</code> interface
|
|
* and have the standard <code>CachedRowSetReader</code> object set as its
|
|
* reader.
|
|
* <P>
|
|
* This implementation always reads all rows of the data source,
|
|
* and it assumes that the <code>command</code> property for the caller
|
|
* is set with a query that is appropriate for execution by a
|
|
* <code>PreparedStatement</code> object.
|
|
* <P>
|
|
* Typically the <code>SyncFactory</code> manages the <code>RowSetReader</code> and
|
|
* the <code>RowSetWriter</code> implementations using <code>SyncProvider</code> objects.
|
|
* Standard JDBC RowSet implementations provide an object instance of this
|
|
* reader by invoking the <code>SyncProvider.getRowSetReader()</code> method.
|
|
*
|
|
* @author Jonathan Bruce
|
|
* @see javax.sql.rowset.spi.SyncProvider
|
|
* @see javax.sql.rowset.spi.SyncFactory
|
|
* @see javax.sql.rowset.spi.SyncFactoryException
|
|
*/
|
|
public class CachedRowSetReader implements RowSetReader, Serializable {
|
|
|
|
/**
|
|
* The field that keeps track of whether the writer associated with
|
|
* this <code>CachedRowSetReader</code> object's rowset has been called since
|
|
* the rowset was populated.
|
|
* <P>
|
|
* When this <code>CachedRowSetReader</code> object reads data into
|
|
* its rowset, it sets the field <code>writerCalls</code> to 0.
|
|
* When the writer associated with the rowset is called to write
|
|
* data back to the underlying data source, its <code>writeData</code>
|
|
* method calls the method <code>CachedRowSetReader.reset</code>,
|
|
* which increments <code>writerCalls</code> and returns <code>true</code>
|
|
* if <code>writerCalls</code> is 1. Thus, <code>writerCalls</code> equals
|
|
* 1 after the first call to <code>writeData</code> that occurs
|
|
* after the rowset has had data read into it.
|
|
*
|
|
* @serial
|
|
*/
|
|
private int writerCalls = 0;
|
|
|
|
private boolean userCon = false;
|
|
|
|
private int startPosition;
|
|
|
|
private JdbcRowSetResourceBundle resBundle;
|
|
|
|
public CachedRowSetReader() {
|
|
try {
|
|
resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();
|
|
} catch(IOException ioe) {
|
|
throw new RuntimeException(ioe);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Reads data from a data source and populates the given
|
|
* <code>RowSet</code> object with that data.
|
|
* This method is called by the rowset internally when
|
|
* the application invokes the method <code>execute</code>
|
|
* to read a new set of rows.
|
|
* <P>
|
|
* After clearing the rowset of its contents, if any, and setting
|
|
* the number of writer calls to <code>0</code>, this reader calls
|
|
* its <code>connect</code> method to make
|
|
* a connection to the rowset's data source. Depending on which
|
|
* of the rowset's properties have been set, the <code>connect</code>
|
|
* method will use a <code>DataSource</code> object or the
|
|
* <code>DriverManager</code> facility to make a connection to the
|
|
* data source.
|
|
* <P>
|
|
* Once the connection to the data source is made, this reader
|
|
* executes the query in the calling <code>CachedRowSet</code> object's
|
|
* <code>command</code> property. Then it calls the rowset's
|
|
* <code>populate</code> method, which reads data from the
|
|
* <code>ResultSet</code> object produced by executing the rowset's
|
|
* command. The rowset is then populated with this data.
|
|
* <P>
|
|
* This method's final act is to close the connection it made, thus
|
|
* leaving the rowset disconnected from its data source.
|
|
*
|
|
* @param caller a <code>RowSet</code> object that has implemented
|
|
* the <code>RowSetInternal</code> interface and had
|
|
* this <code>CachedRowSetReader</code> object set as
|
|
* its reader
|
|
* @throws SQLException if there is a database access error, there is a
|
|
* problem making the connection, or the command property has not
|
|
* been set
|
|
*/
|
|
public void readData(RowSetInternal caller) throws SQLException
|
|
{
|
|
Connection con = null;
|
|
try {
|
|
CachedRowSet crs = (CachedRowSet)caller;
|
|
|
|
// Get rid of the current contents of the rowset.
|
|
|
|
/**
|
|
* Checking added to verify whether page size has been set or not.
|
|
* If set then do not close the object as certain parameters need
|
|
* to be maintained.
|
|
*/
|
|
|
|
if(crs.getPageSize() == 0 && crs.size() >0 ) {
|
|
// When page size is not set,
|
|
// crs.size() will show the total no of rows.
|
|
crs.close();
|
|
}
|
|
|
|
writerCalls = 0;
|
|
|
|
// Get a connection. This reader assumes that the necessary
|
|
// properties have been set on the caller to let it supply a
|
|
// connection.
|
|
userCon = false;
|
|
|
|
con = this.connect(caller);
|
|
|
|
// Check our assumptions.
|
|
if (con == null || crs.getCommand() == null)
|
|
throw new SQLException(resBundle.handleGetObject("crsreader.connecterr").toString());
|
|
|
|
try {
|
|
con.setTransactionIsolation(crs.getTransactionIsolation());
|
|
} catch (Exception ex) {
|
|
;
|
|
}
|
|
// Use JDBC to read the data.
|
|
PreparedStatement pstmt = con.prepareStatement(crs.getCommand());
|
|
// Pass any input parameters to JDBC.
|
|
|
|
decodeParams(caller.getParams(), pstmt);
|
|
try {
|
|
pstmt.setMaxRows(crs.getMaxRows());
|
|
pstmt.setMaxFieldSize(crs.getMaxFieldSize());
|
|
pstmt.setEscapeProcessing(crs.getEscapeProcessing());
|
|
pstmt.setQueryTimeout(crs.getQueryTimeout());
|
|
} catch (Exception ex) {
|
|
/*
|
|
* drivers may not support the above - esp. older
|
|
* drivers being used by the bridge..
|
|
*/
|
|
throw new SQLException(ex.getMessage());
|
|
}
|
|
|
|
if(crs.getCommand().toLowerCase().indexOf("select") != -1) {
|
|
// can be (crs.getCommand()).indexOf("select")) == 0
|
|
// because we will be getting resultset when
|
|
// it may be the case that some false select query with
|
|
// select coming in between instead of first.
|
|
|
|
// if ((crs.getCommand()).indexOf("?")) does not return -1
|
|
// implies a Prepared Statement like query exists.
|
|
|
|
ResultSet rs = pstmt.executeQuery();
|
|
if(crs.getPageSize() == 0){
|
|
crs.populate(rs);
|
|
}
|
|
else {
|
|
/**
|
|
* If page size has been set then create a ResultSet object that is scrollable using a
|
|
* PreparedStatement handle.Also call the populate(ResultSet,int) function to populate
|
|
* a page of data as specified by the page size.
|
|
*/
|
|
pstmt = con.prepareStatement(crs.getCommand(),ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE);
|
|
decodeParams(caller.getParams(), pstmt);
|
|
try {
|
|
pstmt.setMaxRows(crs.getMaxRows());
|
|
pstmt.setMaxFieldSize(crs.getMaxFieldSize());
|
|
pstmt.setEscapeProcessing(crs.getEscapeProcessing());
|
|
pstmt.setQueryTimeout(crs.getQueryTimeout());
|
|
} catch (Exception ex) {
|
|
/*
|
|
* drivers may not support the above - esp. older
|
|
* drivers being used by the bridge..
|
|
*/
|
|
throw new SQLException(ex.getMessage());
|
|
}
|
|
rs = pstmt.executeQuery();
|
|
crs.populate(rs,startPosition);
|
|
}
|
|
rs.close();
|
|
} else {
|
|
pstmt.executeUpdate();
|
|
}
|
|
|
|
// Get the data.
|
|
pstmt.close();
|
|
try {
|
|
con.commit();
|
|
} catch (SQLException ex) {
|
|
;
|
|
}
|
|
// only close connections we created...
|
|
if (getCloseConnection() == true)
|
|
con.close();
|
|
}
|
|
catch (SQLException ex) {
|
|
// Throw an exception if reading fails for any reason.
|
|
throw ex;
|
|
} finally {
|
|
try {
|
|
// only close connections we created...
|
|
if (con != null && getCloseConnection() == true) {
|
|
try {
|
|
if (!con.getAutoCommit()) {
|
|
con.rollback();
|
|
}
|
|
} catch (Exception dummy) {
|
|
/*
|
|
* not an error condition, we're closing anyway, but
|
|
* we'd like to clean up any locks if we can since
|
|
* it is not clear the connection pool will clean
|
|
* these connections in a timely manner
|
|
*/
|
|
}
|
|
con.close();
|
|
con = null;
|
|
}
|
|
} catch (SQLException e) {
|
|
// will get exception if something already went wrong, but don't
|
|
// override that exception with this one
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks to see if the writer associated with this reader needs
|
|
* to reset its state. The writer will need to initialize its state
|
|
* if new contents have been read since the writer was last called.
|
|
* This method is called by the writer that was registered with
|
|
* this reader when components were being wired together.
|
|
*
|
|
* @return <code>true</code> if writer associated with this reader needs
|
|
* to reset the values of its fields; <code>false</code> otherwise
|
|
* @throws SQLException if an access error occurs
|
|
*/
|
|
public boolean reset() throws SQLException {
|
|
writerCalls++;
|
|
return writerCalls == 1;
|
|
}
|
|
|
|
/**
|
|
* Establishes a connection with the data source for the given
|
|
* <code>RowSet</code> object. If the rowset's <code>dataSourceName</code>
|
|
* property has been set, this method uses the JNDI API to retrieve the
|
|
* <code>DataSource</code> object that it can use to make the connection.
|
|
* If the url, username, and password properties have been set, this
|
|
* method uses the <code>DriverManager.getConnection</code> method to
|
|
* make the connection.
|
|
* <P>
|
|
* This method is used internally by the reader and writer associated with
|
|
* the calling <code>RowSet</code> object; an application never calls it
|
|
* directly.
|
|
*
|
|
* @param caller a <code>RowSet</code> object that has implemented
|
|
* the <code>RowSetInternal</code> interface and had
|
|
* this <code>CachedRowSetReader</code> object set as
|
|
* its reader
|
|
* @return a <code>Connection</code> object that represents a connection
|
|
* to the caller's data source
|
|
* @throws SQLException if an access error occurs
|
|
*/
|
|
public Connection connect(RowSetInternal caller) throws SQLException {
|
|
|
|
// Get a JDBC connection.
|
|
if (caller.getConnection() != null) {
|
|
// A connection was passed to execute(), so use it.
|
|
// As we are using a connection the user gave us we
|
|
// won't close it.
|
|
userCon = true;
|
|
return caller.getConnection();
|
|
}
|
|
else if (((RowSet)caller).getDataSourceName() != null) {
|
|
// Connect using JNDI.
|
|
try {
|
|
Context ctx = new InitialContext();
|
|
DataSource ds = (DataSource)ctx.lookup
|
|
(((RowSet)caller).getDataSourceName());
|
|
|
|
// Check for username, password,
|
|
// if it exists try getting a Connection handle through them
|
|
// else try without these
|
|
// else throw SQLException
|
|
|
|
if(((RowSet)caller).getUsername() != null) {
|
|
return ds.getConnection(((RowSet)caller).getUsername(),
|
|
((RowSet)caller).getPassword());
|
|
} else {
|
|
return ds.getConnection();
|
|
}
|
|
}
|
|
catch (javax.naming.NamingException ex) {
|
|
SQLException sqlEx = new SQLException(resBundle.handleGetObject("crsreader.connect").toString());
|
|
sqlEx.initCause(ex);
|
|
throw sqlEx;
|
|
}
|
|
} else if (((RowSet)caller).getUrl() != null) {
|
|
// Connect using the driver manager.
|
|
return DriverManager.getConnection(((RowSet)caller).getUrl(),
|
|
((RowSet)caller).getUsername(),
|
|
((RowSet)caller).getPassword());
|
|
}
|
|
else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the parameter placeholders
|
|
* in the rowset's command (the given <code>PreparedStatement</code>
|
|
* object) with the parameters in the given array.
|
|
* This method, called internally by the method
|
|
* <code>CachedRowSetReader.readData</code>, reads each parameter, and
|
|
* based on its type, determines the correct
|
|
* <code>PreparedStatement.setXXX</code> method to use for setting
|
|
* that parameter.
|
|
*
|
|
* @param params an array of parameters to be used with the given
|
|
* <code>PreparedStatement</code> object
|
|
* @param pstmt the <code>PreparedStatement</code> object that is the
|
|
* command for the calling rowset and into which
|
|
* the given parameters are to be set
|
|
* @throws SQLException if an access error occurs
|
|
*/
|
|
@SuppressWarnings("deprecation")
|
|
private void decodeParams(Object[] params,
|
|
PreparedStatement pstmt) throws SQLException {
|
|
// There is a corresponding decodeParams in JdbcRowSetImpl
|
|
// which does the same as this method. This is a design flaw.
|
|
// Update the JdbcRowSetImpl.decodeParams when you update
|
|
// this method.
|
|
|
|
// Adding the same comments to JdbcRowSetImpl.decodeParams.
|
|
|
|
int arraySize;
|
|
Object[] param = null;
|
|
|
|
for (int i=0; i < params.length; i++) {
|
|
if (params[i] instanceof Object[]) {
|
|
param = (Object[])params[i];
|
|
|
|
if (param.length == 2) {
|
|
if (param[0] == null) {
|
|
pstmt.setNull(i + 1, ((Integer)param[1]).intValue());
|
|
continue;
|
|
}
|
|
|
|
if (param[0] instanceof java.sql.Date ||
|
|
param[0] instanceof java.sql.Time ||
|
|
param[0] instanceof java.sql.Timestamp) {
|
|
System.err.println(resBundle.handleGetObject("crsreader.datedetected").toString());
|
|
if (param[1] instanceof java.util.Calendar) {
|
|
System.err.println(resBundle.handleGetObject("crsreader.caldetected").toString());
|
|
pstmt.setDate(i + 1, (java.sql.Date)param[0],
|
|
(java.util.Calendar)param[1]);
|
|
continue;
|
|
}
|
|
else {
|
|
throw new SQLException(resBundle.handleGetObject("crsreader.paramtype").toString());
|
|
}
|
|
}
|
|
|
|
if (param[0] instanceof Reader) {
|
|
pstmt.setCharacterStream(i + 1, (Reader)param[0],
|
|
((Integer)param[1]).intValue());
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* What's left should be setObject(int, Object, scale)
|
|
*/
|
|
if (param[1] instanceof Integer) {
|
|
pstmt.setObject(i + 1, param[0], ((Integer)param[1]).intValue());
|
|
continue;
|
|
}
|
|
|
|
} else if (param.length == 3) {
|
|
|
|
if (param[0] == null) {
|
|
pstmt.setNull(i + 1, ((Integer)param[1]).intValue(),
|
|
(String)param[2]);
|
|
continue;
|
|
}
|
|
|
|
if (param[0] instanceof java.io.InputStream) {
|
|
switch (((Integer)param[2]).intValue()) {
|
|
case CachedRowSetImpl.UNICODE_STREAM_PARAM:
|
|
pstmt.setUnicodeStream(i + 1,
|
|
(java.io.InputStream)param[0],
|
|
((Integer)param[1]).intValue());
|
|
break;
|
|
case CachedRowSetImpl.BINARY_STREAM_PARAM:
|
|
pstmt.setBinaryStream(i + 1,
|
|
(java.io.InputStream)param[0],
|
|
((Integer)param[1]).intValue());
|
|
break;
|
|
case CachedRowSetImpl.ASCII_STREAM_PARAM:
|
|
pstmt.setAsciiStream(i + 1,
|
|
(java.io.InputStream)param[0],
|
|
((Integer)param[1]).intValue());
|
|
break;
|
|
default:
|
|
throw new SQLException(resBundle.handleGetObject("crsreader.paramtype").toString());
|
|
}
|
|
}
|
|
|
|
/*
|
|
* no point at looking at the first element now;
|
|
* what's left must be the setObject() cases.
|
|
*/
|
|
if (param[1] instanceof Integer && param[2] instanceof Integer) {
|
|
pstmt.setObject(i + 1, param[0], ((Integer)param[1]).intValue(),
|
|
((Integer)param[2]).intValue());
|
|
continue;
|
|
}
|
|
|
|
throw new SQLException(resBundle.handleGetObject("crsreader.paramtype").toString());
|
|
|
|
} else {
|
|
// common case - this catches all SQL92 types
|
|
pstmt.setObject(i + 1, params[i]);
|
|
continue;
|
|
}
|
|
} else {
|
|
// Try to get all the params to be set here
|
|
pstmt.setObject(i + 1, params[i]);
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Assists in determining whether the current connection was created by this
|
|
* CachedRowSet to ensure incorrect connections are not prematurely terminated.
|
|
*
|
|
* @return a boolean giving the status of whether the connection has been closed.
|
|
*/
|
|
protected boolean getCloseConnection() {
|
|
if (userCon == true)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* This sets the start position in the ResultSet from where to begin. This is
|
|
* called by the Reader in the CachedRowSetImpl to set the position on the page
|
|
* to begin populating from.
|
|
* @param pos integer indicating the position in the <code>ResultSet</code> to begin
|
|
* populating from.
|
|
*/
|
|
public void setStartPosition(int pos){
|
|
startPosition = pos;
|
|
}
|
|
|
|
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
|
|
// Default state initialization happens here
|
|
ois.defaultReadObject();
|
|
// Initialization of Res Bundle happens here .
|
|
try {
|
|
resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();
|
|
} catch(IOException ioe) {
|
|
throw new RuntimeException(ioe);
|
|
}
|
|
|
|
}
|
|
|
|
static final long serialVersionUID =5049738185801363801L;
|
|
}
|