/*

 * 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 java.util.*;

import java.io.*;

import com.sun.rowset.*;

import javax.sql.rowset.*;

import javax.sql.rowset.spi.*;

/**

 * The facility called on internally by the <code>RIOptimisticProvider</code> implementation to

 * propagate changes back to the data source from which the rowset got its data.

 * <P>

 * A <code>CachedRowSetWriter</code> object, called a writer, has the public

 * method <code>writeData</code> for writing modified data to the underlying data source.

 * This method is invoked by the rowset internally and is never invoked directly by an application.

 * A writer also has public methods for setting and getting

 * the <code>CachedRowSetReader</code> object, called a reader, that is associated

 * with the writer. The remainder of the methods in this class are private and

 * are invoked internally, either directly or indirectly, by the method

 * <code>writeData</code>.

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

 * writer by invoking the <code>SyncProvider.getRowSetWriter()</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 CachedRowSetWriter implements TransactionalWriter, Serializable {

/**

 * The <code>Connection</code> object that this writer will use to make a

 * connection to the data source to which it will write data.

 *

 */

    private transient Connection con;

/**

 * The SQL <code>SELECT</code> command that this writer will call

 * internally. The method <code>initSQLStatements</code> builds this

 * command by supplying the words "SELECT" and "FROM," and using

 * metadata to get the table name and column names .

 *

 * @serial

 */

    private String selectCmd;

/**

 * The SQL <code>UPDATE</code> command that this writer will call

 * internally to write data to the rowset's underlying data source.

 * The method <code>initSQLStatements</code> builds this <code>String</code>

 * object.

 *

 * @serial

 */

    private String updateCmd;

/**

 * The SQL <code>WHERE</code> clause the writer will use for update

 * statements in the <code>PreparedStatement</code> object

 * it sends to the underlying data source.

 *

 * @serial

 */

    private String updateWhere;

/**

 * The SQL <code>DELETE</code> command that this writer will call

 * internally to delete a row in the rowset's underlying data source.

 *

 * @serial

 */

    private String deleteCmd;

/**

 * The SQL <code>WHERE</code> clause the writer will use for delete

 * statements in the <code>PreparedStatement</code> object

 * it sends to the underlying data source.

 *

 * @serial

 */

    private String deleteWhere;

/**

 * The SQL <code>INSERT INTO</code> command that this writer will internally use

 * to insert data into the rowset's underlying data source.  The method

 * <code>initSQLStatements</code> builds this command with a question

 * mark parameter placeholder for each column in the rowset.

 *

 * @serial

 */

    private String insertCmd;

/**

 * An array containing the column numbers of the columns that are

 * needed to uniquely identify a row in the <code>CachedRowSet</code> object

 * for which this <code>CachedRowSetWriter</code> object is the writer.

 *

 * @serial

 */

    private int[] keyCols;

/**

 * An array of the parameters that should be used to set the parameter

 * placeholders in a <code>PreparedStatement</code> object that this

 * writer will execute.

 *

 * @serial

 */

    private Object[] params;

/**

 * The <code>CachedRowSetReader</code> object that has been

 * set as the reader for the <code>CachedRowSet</code> object

 * for which this <code>CachedRowSetWriter</code> object is the writer.

 *

 * @serial

 */

    private CachedRowSetReader reader;

/**

 * The <code>ResultSetMetaData</code> object that contains information

 * about the columns in the <code>CachedRowSet</code> object

 * for which this <code>CachedRowSetWriter</code> object is the writer.

 *

 * @serial

 */

    private ResultSetMetaData callerMd;

/**

 * The number of columns in the <code>CachedRowSet</code> object

 * for which this <code>CachedRowSetWriter</code> object is the writer.

 *

 * @serial

 */

    private int callerColumnCount;

/**

 * This <code>CachedRowSet<code> will hold the conflicting values

 *  retrieved from the db and hold it.

 */

    private CachedRowSetImpl crsResolve;

/**

 * This <code>ArrayList<code> will hold the values of SyncResolver.*

 */

    private ArrayList status;

/**

 * This will check whether the same field value has changed both

 * in database and CachedRowSet.

 */

    private int iChangedValsInDbAndCRS;

/**

 * This will hold the number of cols for which the values have

 * changed only in database.

 */

    private int iChangedValsinDbOnly ;

    private JdbcRowSetResourceBundle resBundle;

    public CachedRowSetWriter() {

       try {

               resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();

       } catch(IOException ioe) {

               throw new RuntimeException(ioe);

       }

    }

/**

 * Propagates changes in the given <code>RowSet</code> object

 * back to its underlying data source and returns <code>true</code>

 * if successful. The writer will check to see if

 * the data in the pre-modified rowset (the original values) differ

 * from the data in the underlying data source.  If data in the data

 * source has been modified by someone else, there is a conflict,

 * and in that case, the writer will not write to the data source.

 * In other words, the writer uses an optimistic concurrency algorithm:

 * It checks for conflicts before making changes rather than restricting

 * access for concurrent users.

 * <P>

 * This method is called by the rowset internally when

 * the application invokes the method <code>acceptChanges</code>.

 * The <code>writeData</code> method in turn calls private methods that

 * it defines internally.

 * The following is a general summary of what the method

 * <code>writeData</code> does, much of which is accomplished

 * through calls to its own internal methods.

 * <OL>

 * <LI>Creates a <code>CachedRowSet</code> object from the given

 *     <code>RowSet</code> object

 * <LI>Makes a connection with the data source

 *   <UL>

 *      <LI>Disables autocommit mode if it is not already disabled

 *      <LI>Sets the transaction isolation level to that of the rowset

 *   </UL>

 * <LI>Checks to see if the reader has read new data since the writer

 *     was last called and, if so, calls the method

 *    <code>initSQLStatements</code> to initialize new SQL statements

 *   <UL>

 *       <LI>Builds new <code>SELECT</code>, <code>UPDATE</code>,

 *           <code>INSERT</code>, and <code>DELETE</code> statements

 *       <LI>Uses the <code>CachedRowSet</code> object's metadata to

 *           determine the table name, column names, and the columns

 *           that make up the primary key

 *   </UL>

 * <LI>When there is no conflict, propagates changes made to the

 *     <code>CachedRowSet</code> object back to its underlying data source

 *   <UL>

 *      <LI>Iterates through each row of the <code>CachedRowSet</code> object

 *          to determine whether it has been updated, inserted, or deleted

 *      <LI>If the corresponding row in the data source has not been changed

 *          since the rowset last read its

 *          values, the writer will use the appropriate command to update,

 *          insert, or delete the row

 *      <LI>If any data in the data source does not match the original values

 *          for the <code>CachedRowSet</code> object, the writer will roll

 *          back any changes it has made to the row in the data source.

 *   </UL>

 * </OL>

 *

 * @return <code>true</code> if changes to the rowset were successfully

 *         written to the rowset's underlying data source;

 *         <code>false</code> otherwise

 */

    public boolean writeData(RowSetInternal caller) throws SQLException {

        boolean conflict = false;

        boolean showDel = false;

        PreparedStatement pstmtIns = null;

        iChangedValsInDbAndCRS = 0;

        iChangedValsinDbOnly = 0;

        // We assume caller is a CachedRowSet

        CachedRowSetImpl crs = (CachedRowSetImpl)caller;

        // crsResolve = new CachedRowSetImpl();

        this.crsResolve = new CachedRowSetImpl();;

        // The reader is registered with the writer at design time.

        // This is not required, in general.  The reader has logic

        // to get a JDBC connection, so call it.

        con = reader.connect(caller);

        if (con == null) {

            throw new SQLException(resBundle.handleGetObject("crswriter.connect").toString());

        }

        /*

         // Fix 6200646.

         // Don't change the connection or transaction properties. This will fail in a

         // J2EE container.

        if (con.getAutoCommit() == true)  {

            con.setAutoCommit(false);

        }

        con.setTransactionIsolation(crs.getTransactionIsolation());

        */

        initSQLStatements(crs);

        int iColCount;

        RowSetMetaDataImpl rsmdWrite = (RowSetMetaDataImpl)crs.getMetaData();

        RowSetMetaDataImpl rsmdResolv = new RowSetMetaDataImpl();

        iColCount = rsmdWrite.getColumnCount();

        int sz= crs.size()+1;

        status = new ArrayList(sz);

        status.add(0,null);

        rsmdResolv.setColumnCount(iColCount);

        for(int i =1; i <= iColCount; i++) {

            rsmdResolv.setColumnType(i, rsmdWrite.getColumnType(i));

            rsmdResolv.setColumnName(i, rsmdWrite.getColumnName(i));

            rsmdResolv.setNullable(i, ResultSetMetaData.columnNullableUnknown);

        }

        this.crsResolve.setMetaData(rsmdResolv);

        // moved outside the insert inner loop

        //pstmtIns = con.prepareStatement(insertCmd);

        if (callerColumnCount < 1) {

            // No data, so return success.

            if (reader.getCloseConnection() == true)

                    con.close();

            return true;

        }

        // We need to see rows marked for deletion.

        showDel = crs.getShowDeleted();

        crs.setShowDeleted(true);

        // Look at all the rows.

        crs.beforeFirst();

        int rows =1;

        while (crs.next()) {

            if (crs.rowDeleted()) {

                // The row has been deleted.

                if (conflict = (deleteOriginalRow(crs, this.crsResolve)) == true) {

                       status.add(rows, new Integer(SyncResolver.DELETE_ROW_CONFLICT));

                } else {

                      // delete happened without any occurrence of conflicts

                      // so update status accordingly

                       status.add(rows, new Integer(SyncResolver.NO_ROW_CONFLICT));

                }

           } else if (crs.rowInserted()) {

                // The row has been inserted.

                pstmtIns = con.prepareStatement(insertCmd);

                if ( (conflict = insertNewRow(crs, pstmtIns, this.crsResolve)) == true) {

                          status.add(rows, new Integer(SyncResolver.INSERT_ROW_CONFLICT));

                } else {

                      // insert happened without any occurrence of conflicts

                      // so update status accordingly

                       status.add(rows, new Integer(SyncResolver.NO_ROW_CONFLICT));

                }

            } else  if (crs.rowUpdated()) {

                  // The row has been updated.

                       if ( conflict = (updateOriginalRow(crs)) == true) {

                             status.add(rows, new Integer(SyncResolver.UPDATE_ROW_CONFLICT));

               } else {

                      // update happened without any occurrence of conflicts

                      // so update status accordingly

                      status.add(rows, new Integer(SyncResolver.NO_ROW_CONFLICT));

               }

            } else {

               /** The row is neither of inserted, updated or deleted.

                *  So set nulls in the this.crsResolve for this row,

                *  as nothing is to be done for such rows.

                *  Also note that if such a row has been changed in database

                *  and we have not changed(inserted, updated or deleted)

                *  that is fine.

                **/

                int icolCount = crs.getMetaData().getColumnCount();

                status.add(rows, new Integer(SyncResolver.NO_ROW_CONFLICT));

                this.crsResolve.moveToInsertRow();

                for(int cols=0;cols<iColCount;cols++) {

                   this.crsResolve.updateNull(cols+1);

                } //end for

                this.crsResolve.insertRow();

                this.crsResolve.moveToCurrentRow();

                } //end if

         rows++;

      } //end while

        // close the insert statement

        if(pstmtIns!=null)

        pstmtIns.close();

        // reset

        crs.setShowDeleted(showDel);

      boolean boolConf = false;

      for (int j=1;j<status.size();j++){

          // ignore status for index = 0 which is set to null

          if(! ((status.get(j)).equals(new Integer(SyncResolver.NO_ROW_CONFLICT)))) {

              // there is at least one conflict which needs to be resolved

              boolConf = true;

             break;

          }

      }

        crs.beforeFirst();

        this.crsResolve.beforeFirst();

    if(boolConf) {

        SyncProviderException spe = new SyncProviderException(status.size() - 1+resBundle.handleGetObject("crswriter.conflictsno").toString());

        //SyncResolver syncRes = spe.getSyncResolver();

         SyncResolverImpl syncResImpl = (SyncResolverImpl) spe.getSyncResolver();

         syncResImpl.setCachedRowSet(crs);

         syncResImpl.setCachedRowSetResolver(this.crsResolve);

         syncResImpl.setStatus(status);

         syncResImpl.setCachedRowSetWriter(this);

        throw spe;

    } else {

         return true;

    }

       /*

       if (conflict == true) {

            con.rollback();

            return false;

        } else {

            con.commit();

                if (reader.getCloseConnection() == true) {

                       con.close();

                }

            return true;

        }

        */

  } //end writeData

/**

 * Updates the given <code>CachedRowSet</code> object's underlying data

 * source so that updates to the rowset are reflected in the original

 * data source, and returns <code>false</code> if the update was successful.

 * A return value of <code>true</code> indicates that there is a conflict,

 * meaning that a value updated in the rowset has already been changed by

 * someone else in the underlying data source.  A conflict can also exist

 * if, for example, more than one row in the data source would be affected

 * by the update or if no rows would be affected.  In any case, if there is

 * a conflict, this method does not update the underlying data source.

 * <P>

 * This method is called internally by the method <code>writeData</code>

 * if a row in the <code>CachedRowSet</code> object for which this

 * <code>CachedRowSetWriter</code> object is the writer has been updated.

 *

 * @return <code>false</code> if the update to the underlying data source is

 *         successful; <code>true</code> otherwise

 * @throws SQLException if a database access error occurs

 */

    private boolean updateOriginalRow(CachedRowSet crs)

        throws SQLException {

        PreparedStatement pstmt;

        int i = 0;

        int idx = 0;

        // Select the row from the database.

        ResultSet origVals = crs.getOriginalRow();

        origVals.next();

        try {

            updateWhere = buildWhereClause(updateWhere, origVals);

             /**

              *  The following block of code is for checking a particular type of

              *  query where in there is a where clause. Without this block, if a

              *  SQL statement is built the "where" clause will appear twice hence

              *  the DB errors out and a SQLException is thrown. This code also

              *  considers that the where clause is in the right place as the

              *  CachedRowSet object would already have been populated with this

              *  query before coming to this point.

              **/

            String tempselectCmd = selectCmd.toLowerCase();

            int idxWhere = tempselectCmd.indexOf("where");

            if(idxWhere != -1)

            {

               String tempSelect = selectCmd.substring(0,idxWhere);

               selectCmd = tempSelect;

            }

            pstmt = con.prepareStatement(selectCmd + updateWhere,

                        ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);

            for (i = 0; i < keyCols.length; i++) {

                if (params[i] != null) {

                    pstmt.setObject(++idx, params[i]);

                } else {

                    continue;

                }

            }

            try {

                pstmt.setMaxRows(crs.getMaxRows());

                pstmt.setMaxFieldSize(crs.getMaxFieldSize());

                pstmt.setEscapeProcessing(crs.getEscapeProcessing());

                pstmt.setQueryTimeout(crs.getQueryTimeout());

            } catch (Exception ex) {

                // Older driver don't support these operations.

            }

            ResultSet rs = null;

            rs = pstmt.executeQuery();

                if (rs.next()) {

                    *  If rs has only one row we are able to

                    *  uniquely identify the row where update

                    *  have to happen else if more than one

                    *  row implies we cannot uniquely identify the row