package org.apache.torque.util.functions;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you 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 org.apache.torque.adapter.DB;
  
  /***
   * <p>A container for classes that will generate SQL for the SQL99 Standard 
   * Aggregate functions. These can be used via the Criteria.addAsColumn
   * method to produce SQL statements that can be called via the 
   * BasePeer.doSelect methods.</p>  
   * <p>
   * Note database servers that use non-standard function names  
   * can be supported by using the setFunction(String) method.</p>
   * <p>
   * E.g., older MySQL servers use LEAST instead of MIN. This can be 
   * supported by creating a Aggregate.Min instance and then calling
   * the setFunction("LEAST") method.</p>
   * 
   * @see org.apache.torque.util.SummaryHelper
   * @author <a href="mailto:greg.monroe@dukece.com">Greg Monroe</a>
   * @version $Id
   */
  public class Aggregate
  {
  
      /***
       * The base class for all the standard aggregate function classes.
       */
      public abstract class AgregateFunction 
                          extends AbstractFunction 
                          implements SQLFunction
      {
          /*** Should the column have DISTINCT added before it */
          private boolean distinct;
          /*** The function to use */
          private String function;
          /*** Flag to determine if arguments have been set */
          private boolean argumentsSet = false;
          
          /***
           * Base constructor for aggregate functions which must be created
           * via the FunctionFactory / DB classes.<p>  
           * 
           * @see FunctionFactory
           * @see DB
           */
          protected AgregateFunction ( ) 
          {
              super();
          }
          
         /***
          * Assumes that there are one or two arguments being specified.  The
          * first being a column identifier. (TODO: handle expressions) 
          * and the second being an optional boolean indicating if DISTINCT 
          * needs to be added.
          * 
          * @param args The column to apply the function to.
          * @throws IllegalArgumentException If at least one argument has not 
          *                              been supplied or the second argument 
          *                              object is not Boolean.
          */                              
          public void setArguments( Object[] args )
                                              throws IllegalArgumentException
          {
  
              if ( args.length < 1 ) 
              {
                  throw new IllegalArgumentException(
                        "There must be at least one argument object specified!");
              }
              if ( args.length < 2 ) 
              {
                  this.distinct = false;
              } 
              else 
              {
                  if ( ! ( args[1] instanceof Boolean ) ) 
                  {
                      throw new IllegalArgumentException(
                             "Second argument object is not type Boolean!");
                 }
                 this.distinct = ((Boolean) args[1]).booleanValue();
             }
             addArgument( args[0].toString() );
             this.argumentsSet = true;
         }
         
         /***
          * Should the column have DISTINCT added in front of it?
          * 
          * @return True if DISTINCT is needed.
          */
         public boolean isDistinct() 
         {
             return this.distinct;
         }
         
         /***
          * Get the function name to use, e.g. AVG, MIN, LEAST.
          * 
          * @return The function.
          */
         protected String getFunction() 
         {
             return this.function;
         }
         
         /***
          * Set the function to use.
          *  
          * @param value The function to use.
          */
         public void setFunction( String value ) 
         {
             this.function = value;
         }
         
         /***
          * Generate the SQL for this function.
          */
         public String toSQL() 
                     throws IllegalStateException
         {
             if ( ! argumentsSet ) 
             {
                 throw new IllegalStateException ( 
                                "Function arguments have not been set!");
             }
             StringBuffer sb = new StringBuffer();
             sb.append(getFunction()).append("(");
             if ( isDistinct() ) 
             {
                 sb.append("DISTINCT ");
             }
             sb.append( getArgument(0).toString() ).append( ")" );
             return sb.toString();
         }
 
         /* (non-Javadoc)
          * @see org.apache.torque.util.functions.AbstractFunction#getArgument(int)
          */
         public String getArgument(int index)
         {
             return (String) getArgumentObject(index);
         }
         
     }
 
     /***
      * SQL99 Standard Average a column function.
      */
     public class Avg extends Aggregate.AgregateFunction
     {
         /***
          * Construct an AVG function class.
          * 
          * @see Aggregate.AgregateFunction
          * @see FunctionFactory
          */
         protected Avg() 
         {
             super();
             setFunction("AVG");
         }
     }
 
     /***
      * SQL99 Standard Count records function.
      */
     public class Count extends Aggregate.AgregateFunction 
     {
         /***
          * Construct a COUNT function class.
          * 
          * @see Aggregate.AgregateFunction
          * @see FunctionFactory
          */
         protected Count() 
         {
             super();
             setFunction("COUNT");
         }
     }
 
     /***
      * SQL99 Standard Minimum value of column function.
      */
     public class Min extends Aggregate.AgregateFunction 
     {
         /***
          * Construct a MIN function class.
          * 
          * @see Aggregate.AgregateFunction
          * @see FunctionFactory
          */
         protected Min() 
         {
             super();
             setFunction("MIN");
         }
     }
 
     /***
      * SQL99 Standard maximum value of column function.
      */
     public class Max extends Aggregate.AgregateFunction 
     {
         /***
          * Construct a MAX function class.
          * 
          * @see FunctionFactory
          * @see Aggregate.AgregateFunction
          */
         protected Max( ) 
         {
             super();
             setFunction("MAX");
         }
     }
 
     /***
      * SQL99 Standard sum column values function.
      */
     public class Sum extends Aggregate.AgregateFunction 
     {
         /***
          * Construct a SUM function class.
          * 
          * @see FunctionFactory
          * @see Aggregate.AgregateFunction
          */
         protected Sum( ) 
         {
             super();
             setFunction("SUM");
         }
     }
 }