package org.apache.ojb.broker.accesslayer;
   
   /* Copyright 2003-2005 The Apache Software Foundation
    *
    * 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.util.ArrayList;
  import java.util.Collection;
  import java.util.Iterator;
  
  import org.apache.ojb.broker.Identity;
  import org.apache.ojb.broker.PersistenceBrokerFactory;
  import org.apache.ojb.broker.core.PersistenceBrokerConfiguration;
  import org.apache.ojb.broker.core.PersistenceBrokerImpl;
  import org.apache.ojb.broker.metadata.ClassDescriptor;
  import org.apache.ojb.broker.metadata.DescriptorRepository;
  import org.apache.ojb.broker.metadata.FieldDescriptor;
  import org.apache.ojb.broker.query.Criteria;
  import org.apache.ojb.broker.query.Query;
  import org.apache.ojb.broker.query.QueryByCriteria;
  import org.apache.ojb.broker.query.QueryFactory;
  import org.apache.ojb.broker.util.configuration.ConfigurationException;
  import org.apache.ojb.broker.util.logging.Logger;
  import org.apache.ojb.broker.util.logging.LoggerFactory;
  
  /**
   * Abstract Prefetcher.
   * @author <a href="mailto:olegnitz@apache.org">Oleg Nitz</a>
   * @version $Id: BasePrefetcher.java,v 1.1 2007-08-24 22:17:30 ewestfal Exp $
   */
  public abstract class BasePrefetcher implements RelationshipPrefetcher
  {
      /** The numer of columns to query for. */
      protected static final int IN_LIMIT = getPrefetchInLimit();
  
      private Logger logger;
      private PersistenceBrokerImpl broker;
      /** Class descriptor for the item type. */ 
      protected ClassDescriptor itemClassDesc;
      /** Maximum number of pk's in one query. */ 
      protected final int pkLimit;
  
      /**
       * Returns the number of column to query for, from the configuration.
       * 
       * @return The prefetch limit
       */
      private static int getPrefetchInLimit()
      {
          try
          {
              PersistenceBrokerConfiguration config = (PersistenceBrokerConfiguration) PersistenceBrokerFactory.getConfigurator().getConfigurationFor(null);
  
              return config.getSqlInLimit();
          }
          catch (ConfigurationException e)
          {
              return 200;
          }
      }
  
      /**
       * Constructor for BasePrefetcher.
       */
      public BasePrefetcher(PersistenceBrokerImpl aBroker, Class anItemClass)
      {
          super();
          broker = aBroker;
          itemClassDesc = aBroker.getDescriptorRepository().getDescriptorFor(anItemClass);
          logger = LoggerFactory.getLogger(this.getClass());
          pkLimit = getPrefetchInLimit() / getItemClassDescriptor().getPkFields().length;
      }
  
      /**
       * The limit of objects loaded by one SQL query
       */
      public int getLimit()
      {
          return pkLimit;
      }
  
      /**
       * associate the batched Children with their owner object <br>
       */
      protected abstract void associateBatched(Collection owners, Collection children);
  
      /**
      * @see org.apache.ojb.broker.accesslayer.RelationshipPrefetcher#prefetchRelationship(Collection)
     */
     public void prefetchRelationship(Collection owners)
     {
         Query queries[];
         Collection children = new ArrayList();
 
         queries = buildPrefetchQueries(owners, children);
 
         for (int i = 0; i < queries.length; i++)
         {
             Iterator iter = getBroker().getIteratorByQuery(queries[i]);
             while (iter.hasNext())
             {
                 children.add(iter.next());
             }
         }
 
         // BRJ: performRetrieval of childrens references BEFORE associating with owners
         // TODO: this is a quick fix ! 
         getBroker().getReferenceBroker().performRetrievalTasks();
         
         associateBatched(owners, children);
     }
 
     
     protected QueryByCriteria buildPrefetchQuery(Collection ids, FieldDescriptor[] fields)
     {
         return buildPrefetchQuery(getItemClassDescriptor().getClassOfObject(), ids, fields);
     }
 
     
     /**
      * 
      * @param ids collection of identities
      * @param fields
      * @return
      */
     protected Criteria buildPrefetchCriteria(Collection ids, FieldDescriptor[] fields)
     {
         if (fields.length == 1)
         {
             return buildPrefetchCriteriaSingleKey(ids, fields[0]);
         }
         else
         {
             return buildPrefetchCriteriaMultipleKeys(ids, fields);
         }
         
     }
    
     /**
      * 
      * @param clazz
      * @param ids collection of identities
      * @param fields
      * @return
      */
     protected QueryByCriteria buildPrefetchQuery(Class clazz, Collection ids, FieldDescriptor[] fields)
     {
         return QueryFactory.newQuery(clazz, buildPrefetchCriteria(ids, fields));
     }
 
     /**
      * Build the Criteria using IN(...) for single keys
      * @param ids collection of identities
      * @param field
      * @return Criteria
      */
     private Criteria buildPrefetchCriteriaSingleKey(Collection ids, FieldDescriptor field)
     {
         Criteria crit = new Criteria();
         ArrayList values = new ArrayList(ids.size());
         Iterator iter = ids.iterator();
         Identity id;
 
         while (iter.hasNext())
         {
             id = (Identity) iter.next();
             values.add(id.getPrimaryKeyValues()[0]);
         }
 
         switch (values.size())
         {
             case 0:
                 break;
             case 1:
                 crit.addEqualTo(field.getAttributeName(), values.get(0));
                 break;
             default:
                 // create IN (...) for the single key field
                 crit.addIn(field.getAttributeName(), values);
                 break;
         }
 
         return crit;
     }
 
     /**
      * Build the Criteria using multiple ORs
      * @param ids collection of identities
      * @param fields
      * @return Criteria
      */
     private Criteria buildPrefetchCriteriaMultipleKeys(Collection ids, FieldDescriptor fields[])
     {
         Criteria crit = new Criteria();
         Iterator iter = ids.iterator();
         Object[] val;
         Identity id;
 
         while (iter.hasNext())
         {
             Criteria c = new Criteria();
             id = (Identity) iter.next();
             val = id.getPrimaryKeyValues();
             for (int i = 0; i < val.length; i++)
             {
                 if (val[i] == null)
                 {
                     c.addIsNull(fields[i].getAttributeName());
                 }
                 else
                 {
                     c.addEqualTo(fields[i].getAttributeName(), val[i]);
                 }
             }
             crit.addOrCriteria(c);
         }
 
         return crit;
     }
 
     /**
      * Return the DescriptorRepository
      */
     protected DescriptorRepository getDescriptorRepository()
     {
         return getBroker().getDescriptorRepository();
     }
 
     /**
      * Returns the ClassDescriptor of the item Class
      * @return ClassDescriptor
      */
     public ClassDescriptor getItemClassDescriptor()
     {
         return itemClassDesc;
     }
 
     protected abstract Query[] buildPrefetchQueries(Collection owners, Collection children);
 
     /**
      * Returns the broker.
      * @return PersistenceBrokerImpl
      */
     protected PersistenceBrokerImpl getBroker()
     {
         return broker;
     }
 
     /**
      * Returns the logger.
      * @return Logger
      */
     protected Logger getLogger()
     {
         return logger;
     }
 }