/*

 * 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;

}