package com.explosion.expfmodules.rdbmsconn.dbom.sql;
   
   
   /* =============================================================================
    *       
    *     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.DatabaseMetaData;
  import java.sql.PreparedStatement;
  import java.sql.SQLException;
  import java.text.ParseException;
  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.DBEntityColumn;
  import com.explosion.expfmodules.rdbmsconn.dbom.utils.MetadataUtils;
  import com.explosion.expfmodules.rdbmsconn.dbom.utils.SQLEngine;
  import com.explosion.expfmodules.rdbmsconn.dbom.utils.UnconvertableDataTypeException;
  import com.explosion.expfmodules.rdbmsconn.dbom.utils.UnrecognisedTypeException;
  import com.explosion.expfmodules.rdbmsconn.dbom.utils.UnsupportedTypeException;
  import com.explosion.utilities.exception.ExceptionManagerFactory;
  
  
  /***
   * This class represents an SQL insert statement
   * @author Stephen
   * Created on Apr 22, 2004
   */
  public class UpdateStatement
  {
      private DBEntity entity;
      private static final String BIND_STRING = "?";
      private List columnsToUpdate;
      private List primaryKeyColumns;
      private static Logger log = LogManager.getLogger(UpdateStatement.class);
      private MetadataUtils utils = new MetadataUtils();
      
      /***
       * @param entity The entity into which the data is being inserted
       * @param columnsToUpdate A list of columnsToUpdate which will be updated in the database row 
       * @param entity
       * @param bindings
       */
      public UpdateStatement(DBEntity entity, List columnsToUpdate)
      {
          this.entity = entity;
          this.columnsToUpdate = columnsToUpdate;
      }
      
      /***
       * Creates and returns the SQL required for a prepared statement 
       * by creating a delete statement string which reads 
       * "update full.tablename set full.columnname1 = ?, full.columnname2 = ? where full.columnname = ? and full.col....."
       * 
       * It first to looks to see if there are any primary key columnsToUpdate.  If there are,
       * it will only use those in the where clause.  If there are none, it will use
       * all of the columnsToUpdate in the table.  
       * by createing the SQL command string
       */
      public String getPreparedStatementString(DatabaseMetaData meta) throws SQLException
      {
          try
          {
              /* First build up the update part */
              StringBuffer statement = new StringBuffer("update " + utils.getFullEntityName(entity, meta) + " set ");
              for (Iterator i = columnsToUpdate.iterator(); i.hasNext();)
              {
                  DBEntityColumn column = entity.getColumn((String) i.next());
  
                  /* Exclusions and errors */
                  if (column.isAutoIncrement() || !column.isWritable())
                      throw new InvalidUpdateException("Cannot update value in column " + utils.getFullColumnName(column.getColumnName(), entity.getEntityName(), meta));
  
                  statement.append(column.getColumnName() + " = ?"+ (i.hasNext() ? ", " : ""));
              }
  
              /* Then build up the where part */
              statement.append(" where ");
              primaryKeyColumns = entity.getDerivedIdentityColumns();
             
             for (Iterator i = primaryKeyColumns.iterator(); i.hasNext();)
             {
             	DBEntityColumn column = (DBEntityColumn) i.next();
             	statement.append(utils.getFullColumnName(column.getColumnName(),entity.getEntityName(), meta) + " = ?" );
             	if (i.hasNext() )
             	    statement.append(" and ");  
             }
             
             return statement.toString();
             
         } catch (Exception e)
         {
             ExceptionManagerFactory.getExceptionManager().manageException(e,"Exception caught while creating update statement.");
         }   
         return null;
     }
     
     /***
      * This method will bind the variables provided to the statement
      * provided
      * @param bindVariablesForUpdate A map containing the columnNames (Strings) and the appropriate values for those columns to be updated in the database
      *                 				e.g. columnName=value.  Value must be an object of the correct type otherwise an error will be thrown when the 
      *  			               statement gets executed.
      * @param bindVariablesForSelection A map containing the columnNames (Strings) and the appropriate values required to select the row which is to be updated
      * @param statement Prepared Statement.  Note: this statement needs to have been prepared from the 
      * 					string produced from getPreparedStatementString()  method from this instanceof the 
      *                  class 
      * @throws UnconvertableDataTypeException
      * @throws SQLException
      * @throws ParseException
      * @throws UnsupportedTypeException
      * @throws UnrecognisedTypeException
      */
     public void bindVariables(Map bindVariablesForUpdate, Map bindVariablesForSelection, PreparedStatement statement) throws UnconvertableDataTypeException, UnrecognisedTypeException, UnsupportedTypeException, SQLException, ParseException
     {
         /* Once again, break this up into two sections ,
          * First bind the update parameters */
         SQLEngine engine = new SQLEngine();
         int index = 1;
         for (int i=0;i<columnsToUpdate.size(); i++)
         {
             String columnName = (String) columnsToUpdate.get(i);
             DBEntityColumn column = entity.getColumn(columnName);
             engine.bind(bindVariablesForUpdate.get(columnName),statement, column, i+1);
             index++;
         }   
                 
         /* Then bind the where parameters */
         for (Iterator i = primaryKeyColumns.iterator(); i.hasNext();)
         {
         	DBEntityColumn column = (DBEntityColumn) i.next();
         	Object data = bindVariablesForSelection.get(column.getColumnName());
         	engine.bind(data, statement, column, index);
         }
         
     }
     
     /***
      * This method will tell you if the column will be included in an update statement or not
      * It also outputs a debug level message if not
      * @param column
      */
     public static boolean includeInUpdate(DBEntityColumn column)
     {
         boolean include = true;
         
         if (column == null)
             return false;
         
         /* Exclusions and errors */
         if (column.isAutoIncrement())
         {
                log.debug("Not adding column " + column.getColumnName()+ " into update statement because it is an autoIncrement column.");
                include = false;
         }
         
         return include;
     }    
 }