package com.explosion.datastream.exql.processes;
   
   /*
    * =============================================================================
    * 
    * Copyright 2004 Stephen Cowx
    * 
    * Licensed under the Apache License, Version 2.0 (the "License"); you may not
    * use this file except in compliance with the License. You may obtain a copy of
   * the License at
   * 
   * http://www.apache.org/licenses/LICENSE-2.0
   * 
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
   * License for the specific language governing permissions and limitations under
   * the License.
   * 
   * =============================================================================
   */
  
  import java.sql.Connection;
  import java.sql.PreparedStatement;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.log4j.LogManager;
  import org.apache.log4j.Logger;
  
  import com.explosion.expfmodules.rdbmsconn.dbom.DBEntity;
  import com.explosion.expfmodules.rdbmsconn.dbom.sql.UpdateStatement;
  import com.explosion.utilities.exception.ExceptionManagerFactory;
  import com.explosion.utilities.process.StackableSimpleProcess;
  import com.explosion.utilities.process.threads.Finishable;
  import com.explosion.utilities.process.threads.ProcessThread;
  
  /***
   * @author Stephen Cowx Date created:@14-Feb-2003 This class executes a series
   *         of delete statements
   */
  public class UpdateProcess extends StackableSimpleProcess
  {
  
      private static Logger log = LogManager.getLogger(UpdateProcess.class);
      private DBEntity entity;
      private List updateValueBindings;
      private List updateRowIdentifierBindings;
      private int connectionIdentifier = -1;
      private Connection conn;
  
      /***
       * Constructor for DeleteProcess.
       */
      public UpdateProcess(StackableSimpleProcess parentProcess, DBEntity entity, List updateValueBindings, List updateRowIdentifierBindings, Connection conn)
      {
          super(parentProcess);
          this.entity = entity;
          this.updateValueBindings = updateValueBindings;
          this.updateRowIdentifierBindings = updateRowIdentifierBindings; 
          this.conn = conn;
          this.setIsUserProcess(true);
      }
  
      /***
       * Constructor for DeleteProcess.
       */
      public UpdateProcess(Finishable finishable, DBEntity entity, List updateValueBindings, List updateRowIdentifierBindings, Connection conn)
      {
          super(finishable, null);
          this.entity = entity;
          this.updateValueBindings = updateValueBindings;
          this.updateRowIdentifierBindings = updateRowIdentifierBindings;
          this.conn = conn;
          this.setIsUserProcess(true);
      }
  
      /***
       * This method loops around the bindVariable sets binding the variables to 
       * a prepared statement and executing them. 
       * @see com.explosion.utilities.process.threads.SimpleProcess#process()
       */
      public void process()
      {
          try
          {
              if (isStopped())
                  return;
              
              if (updateValueBindings.size() < 1)
              {
                  setPercentComplete(100);
                  return;
              }
              
              setPercentComplete(5);
              
             setStatusText("Starting updates");
             int increment = 95 / updateValueBindings.size();
             int index = 1;
             for (int i=0;i<updateValueBindings.size(); i++)
             {
                /* We need a set of columns for each row because each row may be inserting different values into different columns columns */
                Map map = (Map) updateValueBindings.get(i);
                Map identifiers = (Map) updateRowIdentifierBindings.get(i);
                
                List columns = new ArrayList();
                for (Iterator cols = map.keySet().iterator(); cols.hasNext();)
                {
                    columns.add((String)cols.next());
                }
                
                setStatusText("Creating update statement");
                
                UpdateStatement updateStatement = new UpdateStatement(entity, columns); 
                
                String sql = updateStatement.getPreparedStatementString(conn.getMetaData());
                PreparedStatement statement = conn.prepareStatement(sql);
                
                updateStatement.bindVariables(map, identifiers, statement);
                log.debug("Statement: " + sql);
                setStatusText("Executing update " + index);
                statement.executeUpdate();
                setPercentComplete(getPercentComplete() + increment);
                index++;
             }
 
             setStatusText("Done, updates completed successfully.");
 
             this.setPercentComplete(100);
             log.debug(getStatusText());
         }
         catch (Exception e)
         {
             setStatusText("Error, unable to update.");
             setPercentComplete(100);
             if (getProcessControl().getStatus() != ProcessThread.THREAD_STOPPED)
             {
                 //ie, it hasn't been cancelled
                 if (this.getProcessControl().getProcess() != null)
                 {
                     ((StackableSimpleProcess) this.getProcessControl().getProcess()).manageException(e,"Exception caught while updating rows");
                     try {
 						this.getProcessControl().stop();
 					} catch (InterruptedException e1) {
 //						ignore
 						log.error("Interrupted", e);
 					}
                 }
                 else
                 {
                   ExceptionManagerFactory.getExceptionManager().manageException(e, "Exception caught while updating rows.");
                 }
             }
         }
 
     }
 }