History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/com/sun/rowset/internal/CachedRowSetReader.java (1 of 18352 files). Show all

Unified · Split

java/pkg/com/sun/rowset/internal/CachedRowSetReader.java+506−0
@@ -0,0 +1,506 @@
1+/*
2+ * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
3+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4+ *
5+ * This code is free software; you can redistribute it and/or modify it
6+ * under the terms of the GNU General Public License version 2 only, as
7+ * published by the Free Software Foundation. Oracle designates this
8+ * particular file as subject to the "Classpath" exception as provided
9+ * by Oracle in the LICENSE file that accompanied this code.
10+ *
11+ * This code is distributed in the hope that it will be useful, but WITHOUT
12+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14+ * version 2 for more details (a copy is included in the LICENSE file that
15+ * accompanied this code).
16+ *
17+ * You should have received a copy of the GNU General Public License version
18+ * 2 along with this work; if not, write to the Free Software Foundation,
19+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20+ *
21+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22+ * or visit www.oracle.com if you need additional information or have any
23+ * questions.
24+ */
25+
26+package com.sun.rowset.internal;
27+
28+import java.sql.*;
29+import javax.sql.*;
30+import javax.naming.*;
31+import java.io.*;
32+import java.lang.reflect.*;
33+
34+import com.sun.rowset.*;
35+import javax.sql.rowset.*;
36+import javax.sql.rowset.spi.*;
37+
38+/**
39+ * The facility called by the <code>RIOptimisticProvider</code> object
40+ * internally to read data into it. The calling <code>RowSet</code> object
41+ * must have implemented the <code>RowSetInternal</code> interface
42+ * and have the standard <code>CachedRowSetReader</code> object set as its
43+ * reader.
44+ * <P>
45+ * This implementation always reads all rows of the data source,
46+ * and it assumes that the <code>command</code> property for the caller
47+ * is set with a query that is appropriate for execution by a
48+ * <code>PreparedStatement</code> object.
49+ * <P>
50+ * Typically the <code>SyncFactory</code> manages the <code>RowSetReader</code> and
51+ * the <code>RowSetWriter</code> implementations using <code>SyncProvider</code> objects.
52+ * Standard JDBC RowSet implementations provide an object instance of this
53+ * reader by invoking the <code>SyncProvider.getRowSetReader()</code> method.
54+ *
55+ * @author Jonathan Bruce
56+ * @see javax.sql.rowset.spi.SyncProvider
57+ * @see javax.sql.rowset.spi.SyncFactory
58+ * @see javax.sql.rowset.spi.SyncFactoryException
59+ */
60+public class CachedRowSetReader implements RowSetReader, Serializable {
61+
62+ /**
63+ * The field that keeps track of whether the writer associated with
64+ * this <code>CachedRowSetReader</code> object's rowset has been called since
65+ * the rowset was populated.
66+ * <P>
67+ * When this <code>CachedRowSetReader</code> object reads data into
68+ * its rowset, it sets the field <code>writerCalls</code> to 0.
69+ * When the writer associated with the rowset is called to write
70+ * data back to the underlying data source, its <code>writeData</code>
71+ * method calls the method <code>CachedRowSetReader.reset</code>,
72+ * which increments <code>writerCalls</code> and returns <code>true</code>
73+ * if <code>writerCalls</code> is 1. Thus, <code>writerCalls</code> equals
74+ * 1 after the first call to <code>writeData</code> that occurs
75+ * after the rowset has had data read into it.
76+ *
77+ * @serial
78+ */
79+ private int writerCalls = 0;
80+
81+ private boolean userCon = false;
82+
83+ private int startPosition;
84+
85+ private JdbcRowSetResourceBundle resBundle;
86+
87+ public CachedRowSetReader() {
88+ try {
89+ resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();
90+ } catch(IOException ioe) {
91+ throw new RuntimeException(ioe);
92+ }
93+ }
94+
95+
96+ /**
97+ * Reads data from a data source and populates the given
98+ * <code>RowSet</code> object with that data.
99+ * This method is called by the rowset internally when
100+ * the application invokes the method <code>execute</code>
101+ * to read a new set of rows.
102+ * <P>
103+ * After clearing the rowset of its contents, if any, and setting
104+ * the number of writer calls to <code>0</code>, this reader calls
105+ * its <code>connect</code> method to make
106+ * a connection to the rowset's data source. Depending on which
107+ * of the rowset's properties have been set, the <code>connect</code>
108+ * method will use a <code>DataSource</code> object or the
109+ * <code>DriverManager</code> facility to make a connection to the
110+ * data source.
111+ * <P>
112+ * Once the connection to the data source is made, this reader
113+ * executes the query in the calling <code>CachedRowSet</code> object's
114+ * <code>command</code> property. Then it calls the rowset's
115+ * <code>populate</code> method, which reads data from the
116+ * <code>ResultSet</code> object produced by executing the rowset's
117+ * command. The rowset is then populated with this data.
118+ * <P>
119+ * This method's final act is to close the connection it made, thus
120+ * leaving the rowset disconnected from its data source.
121+ *
122+ * @param caller a <code>RowSet</code> object that has implemented
123+ * the <code>RowSetInternal</code> interface and had
124+ * this <code>CachedRowSetReader</code> object set as
125+ * its reader
126+ * @throws SQLException if there is a database access error, there is a
127+ * problem making the connection, or the command property has not
128+ * been set
129+ */
130+ public void readData(RowSetInternal caller) throws SQLException
131+ {
132+ Connection con = null;
133+ try {
134+ CachedRowSet crs = (CachedRowSet)caller;
135+
136+ // Get rid of the current contents of the rowset.
137+
138+ /**
139+ * Checking added to verify whether page size has been set or not.
140+ * If set then do not close the object as certain parameters need
141+ * to be maintained.
142+ */
143+
144+ if(crs.getPageSize() == 0 && crs.size() >0 ) {
145+ // When page size is not set,
146+ // crs.size() will show the total no of rows.
147+ crs.close();
148+ }
149+
150+ writerCalls = 0;
151+
152+ // Get a connection. This reader assumes that the necessary
153+ // properties have been set on the caller to let it supply a
154+ // connection.
155+ userCon = false;
156+
157+ con = this.connect(caller);
158+
159+ // Check our assumptions.
160+ if (con == null || crs.getCommand() == null)
161+ throw new SQLException(resBundle.handleGetObject("crsreader.connecterr").toString());
162+
163+ try {
164+ con.setTransactionIsolation(crs.getTransactionIsolation());
165+ } catch (Exception ex) {
166+ ;
167+ }
168+ // Use JDBC to read the data.
169+ PreparedStatement pstmt = con.prepareStatement(crs.getCommand());
170+ // Pass any input parameters to JDBC.
171+
172+ decodeParams(caller.getParams(), pstmt);
173+ try {
174+ pstmt.setMaxRows(crs.getMaxRows());
175+ pstmt.setMaxFieldSize(crs.getMaxFieldSize());
176+ pstmt.setEscapeProcessing(crs.getEscapeProcessing());
177+ pstmt.setQueryTimeout(crs.getQueryTimeout());
178+ } catch (Exception ex) {
179+ /*
180+ * drivers may not support the above - esp. older
181+ * drivers being used by the bridge..
182+ */
183+ throw new SQLException(ex.getMessage());
184+ }
185+
186+ if(crs.getCommand().toLowerCase().indexOf("select") != -1) {
187+ // can be (crs.getCommand()).indexOf("select")) == 0
188+ // because we will be getting resultset when
189+ // it may be the case that some false select query with
190+ // select coming in between instead of first.
191+
192+ // if ((crs.getCommand()).indexOf("?")) does not return -1
193+ // implies a Prepared Statement like query exists.
194+
195+ ResultSet rs = pstmt.executeQuery();
196+ if(crs.getPageSize() == 0){
197+ crs.populate(rs);
198+ }
199+ else {
200+ /**
201+ * If page size has been set then create a ResultSet object that is scrollable using a
202+ * PreparedStatement handle.Also call the populate(ResultSet,int) function to populate
203+ * a page of data as specified by the page size.
204+ */
205+ pstmt = con.prepareStatement(crs.getCommand(),ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE);
206+ decodeParams(caller.getParams(), pstmt);
207+ try {
208+ pstmt.setMaxRows(crs.getMaxRows());
209+ pstmt.setMaxFieldSize(crs.getMaxFieldSize());
210+ pstmt.setEscapeProcessing(crs.getEscapeProcessing());
211+ pstmt.setQueryTimeout(crs.getQueryTimeout());
212+ } catch (Exception ex) {
213+ /*
214+ * drivers may not support the above - esp. older
215+ * drivers being used by the bridge..
216+ */
217+ throw new SQLException(ex.getMessage());
218+ }
219+ rs = pstmt.executeQuery();
220+ crs.populate(rs,startPosition);
221+ }
222+ rs.close();
223+ } else {
224+ pstmt.executeUpdate();
225+ }
226+
227+ // Get the data.
228+ pstmt.close();
229+ try {
230+ con.commit();
231+ } catch (SQLException ex) {
232+ ;
233+ }
234+ // only close connections we created...
235+ if (getCloseConnection() == true)
236+ con.close();
237+ }
238+ catch (SQLException ex) {
239+ // Throw an exception if reading fails for any reason.
240+ throw ex;
241+ } finally {
242+ try {
243+ // only close connections we created...
244+ if (con != null && getCloseConnection() == true) {
245+ try {
246+ if (!con.getAutoCommit()) {
247+ con.rollback();
248+ }
249+ } catch (Exception dummy) {
250+ /*
251+ * not an error condition, we're closing anyway, but
252+ * we'd like to clean up any locks if we can since
253+ * it is not clear the connection pool will clean
254+ * these connections in a timely manner
255+ */
256+ }
257+ con.close();
258+ con = null;
259+ }
260+ } catch (SQLException e) {
261+ // will get exception if something already went wrong, but don't
262+ // override that exception with this one
263+ }
264+ }
265+ }
266+
267+ /**
268+ * Checks to see if the writer associated with this reader needs
269+ * to reset its state. The writer will need to initialize its state
270+ * if new contents have been read since the writer was last called.
271+ * This method is called by the writer that was registered with
272+ * this reader when components were being wired together.
273+ *
274+ * @return <code>true</code> if writer associated with this reader needs
275+ * to reset the values of its fields; <code>false</code> otherwise
276+ * @throws SQLException if an access error occurs
277+ */
278+ public boolean reset() throws SQLException {
279+ writerCalls++;
280+ return writerCalls == 1;
281+ }
282+
283+ /**
284+ * Establishes a connection with the data source for the given
285+ * <code>RowSet</code> object. If the rowset's <code>dataSourceName</code>
286+ * property has been set, this method uses the JNDI API to retrieve the
287+ * <code>DataSource</code> object that it can use to make the connection.
288+ * If the url, username, and password properties have been set, this
289+ * method uses the <code>DriverManager.getConnection</code> method to
290+ * make the connection.
291+ * <P>
292+ * This method is used internally by the reader and writer associated with
293+ * the calling <code>RowSet</code> object; an application never calls it
294+ * directly.
295+ *
296+ * @param caller a <code>RowSet</code> object that has implemented
297+ * the <code>RowSetInternal</code> interface and had
298+ * this <code>CachedRowSetReader</code> object set as
299+ * its reader
300+ * @return a <code>Connection</code> object that represents a connection
301+ * to the caller's data source
302+ * @throws SQLException if an access error occurs
303+ */
304+ public Connection connect(RowSetInternal caller) throws SQLException {
305+
306+ // Get a JDBC connection.
307+ if (caller.getConnection() != null) {
308+ // A connection was passed to execute(), so use it.
309+ // As we are using a connection the user gave us we
310+ // won't close it.
311+ userCon = true;
312+ return caller.getConnection();
313+ }
314+ else if (((RowSet)caller).getDataSourceName() != null) {
315+ // Connect using JNDI.
316+ try {
317+ Context ctx = new InitialContext();
318+ DataSource ds = (DataSource)ctx.lookup
319+ (((RowSet)caller).getDataSourceName());
320+
321+ // Check for username, password,
322+ // if it exists try getting a Connection handle through them
323+ // else try without these
324+ // else throw SQLException
325+
326+ if(((RowSet)caller).getUsername() != null) {
327+ return ds.getConnection(((RowSet)caller).getUsername(),
328+ ((RowSet)caller).getPassword());
329+ } else {
330+ return ds.getConnection();
331+ }
332+ }
333+ catch (javax.naming.NamingException ex) {
334+ SQLException sqlEx = new SQLException(resBundle.handleGetObject("crsreader.connect").toString());
335+ sqlEx.initCause(ex);
336+ throw sqlEx;
337+ }
338+ } else if (((RowSet)caller).getUrl() != null) {
339+ // Connect using the driver manager.
340+ return DriverManager.getConnection(((RowSet)caller).getUrl(),
341+ ((RowSet)caller).getUsername(),
342+ ((RowSet)caller).getPassword());
343+ }
344+ else {
345+ return null;
346+ }
347+ }
348+
349+ /**
350+ * Sets the parameter placeholders
351+ * in the rowset's command (the given <code>PreparedStatement</code>
352+ * object) with the parameters in the given array.
353+ * This method, called internally by the method
354+ * <code>CachedRowSetReader.readData</code>, reads each parameter, and
355+ * based on its type, determines the correct
356+ * <code>PreparedStatement.setXXX</code> method to use for setting
357+ * that parameter.
358+ *
359+ * @param params an array of parameters to be used with the given
360+ * <code>PreparedStatement</code> object
361+ * @param pstmt the <code>PreparedStatement</code> object that is the
362+ * command for the calling rowset and into which
363+ * the given parameters are to be set
364+ * @throws SQLException if an access error occurs
365+ */
366+ private void decodeParams(Object[] params,
367+ PreparedStatement pstmt) throws SQLException {
368+ // There is a corresponding decodeParams in JdbcRowSetImpl
369+ // which does the same as this method. This is a design flaw.
370+ // Update the JdbcRowSetImpl.decodeParams when you update
371+ // this method.
372+
373+ // Adding the same comments to JdbcRowSetImpl.decodeParams.
374+
375+ int arraySize;
376+ Object[] param = null;
377+
378+ for (int i=0; i < params.length; i++) {
379+ if (params[i] instanceof Object[]) {
380+ param = (Object[])params[i];
381+
382+ if (param.length == 2) {
383+ if (param[0] == null) {
384+ pstmt.setNull(i + 1, ((Integer)param[1]).intValue());
385+ continue;
386+ }
387+
388+ if (param[0] instanceof java.sql.Date ||
389+ param[0] instanceof java.sql.Time ||
390+ param[0] instanceof java.sql.Timestamp) {
391+ System.err.println(resBundle.handleGetObject("crsreader.datedetected").toString());
392+ if (param[1] instanceof java.util.Calendar) {
393+ System.err.println(resBundle.handleGetObject("crsreader.caldetected").toString());
394+ pstmt.setDate(i + 1, (java.sql.Date)param[0],
395+ (java.util.Calendar)param[1]);
396+ continue;
397+ }
398+ else {
399+ throw new SQLException(resBundle.handleGetObject("crsreader.paramtype").toString());
400+ }
401+ }
402+
403+ if (param[0] instanceof Reader) {
404+ pstmt.setCharacterStream(i + 1, (Reader)param[0],
405+ ((Integer)param[1]).intValue());
406+ continue;
407+ }
408+
409+ /*
410+ * What's left should be setObject(int, Object, scale)
411+ */
412+ if (param[1] instanceof Integer) {
413+ pstmt.setObject(i + 1, param[0], ((Integer)param[1]).intValue());
414+ continue;
415+ }
416+
417+ } else if (param.length == 3) {
418+
419+ if (param[0] == null) {
420+ pstmt.setNull(i + 1, ((Integer)param[1]).intValue(),
421+ (String)param[2]);
422+ continue;
423+ }
424+
425+ if (param[0] instanceof java.io.InputStream) {
426+ switch (((Integer)param[2]).intValue()) {
427+ case CachedRowSetImpl.UNICODE_STREAM_PARAM:
428+ pstmt.setUnicodeStream(i + 1,
429+ (java.io.InputStream)param[0],
430+ ((Integer)param[1]).intValue());
431+ case CachedRowSetImpl.BINARY_STREAM_PARAM:
432+ pstmt.setBinaryStream(i + 1,
433+ (java.io.InputStream)param[0],
434+ ((Integer)param[1]).intValue());
435+ case CachedRowSetImpl.ASCII_STREAM_PARAM:
436+ pstmt.setAsciiStream(i + 1,
437+ (java.io.InputStream)param[0],
438+ ((Integer)param[1]).intValue());
439+ default:
440+ throw new SQLException(resBundle.handleGetObject("crsreader.paramtype").toString());
441+ }
442+ }
443+
444+ /*
445+ * no point at looking at the first element now;
446+ * what's left must be the setObject() cases.
447+ */
448+ if (param[1] instanceof Integer && param[2] instanceof Integer) {
449+ pstmt.setObject(i + 1, param[0], ((Integer)param[1]).intValue(),
450+ ((Integer)param[2]).intValue());
451+ continue;
452+ }
453+
454+ throw new SQLException(resBundle.handleGetObject("crsreader.paramtype").toString());
455+
456+ } else {
457+ // common case - this catches all SQL92 types
458+ pstmt.setObject(i + 1, params[i]);
459+ continue;
460+ }
461+ } else {
462+ // Try to get all the params to be set here
463+ pstmt.setObject(i + 1, params[i]);
464+
465+ }
466+ }
467+ }
468+
469+ /**
470+ * Assists in determining whether the current connection was created by this
471+ * CachedRowSet to ensure incorrect connections are not prematurely terminated.
472+ *
473+ * @return a boolean giving the status of whether the connection has been closed.
474+ */
475+ protected boolean getCloseConnection() {
476+ if (userCon == true)
477+ return false;
478+
479+ return true;
480+ }
481+
482+ /**
483+ * This sets the start position in the ResultSet from where to begin. This is
484+ * called by the Reader in the CachedRowSetImpl to set the position on the page
485+ * to begin populating from.
486+ * @param pos integer indicating the position in the <code>ResultSet</code> to begin
487+ * populating from.
488+ */
489+ public void setStartPosition(int pos){
490+ startPosition = pos;
491+ }
492+
493+ private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
494+ // Default state initialization happens here
495+ ois.defaultReadObject();
496+ // Initialization of Res Bundle happens here .
497+ try {
498+ resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();
499+ } catch(IOException ioe) {
500+ throw new RuntimeException(ioe);
501+ }
502+
503+ }
504+
505+ static final long serialVersionUID =5049738185801363801L;
506+}