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.lang.reflect.Array;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.Iterator;

 import java.util.List;

 import org.apache.ojb.broker.Identity;

 import org.apache.ojb.broker.ManageableCollection;

 import org.apache.ojb.broker.PersistenceBroker;

 import org.apache.ojb.broker.accesslayer.conversions.FieldConversion;

 import org.apache.ojb.broker.core.PersistenceBrokerImpl;

 import org.apache.ojb.broker.core.proxy.CollectionProxyDefaultImpl;

 import org.apache.ojb.broker.metadata.ClassDescriptor;

 import org.apache.ojb.broker.metadata.CollectionDescriptor;

 import org.apache.ojb.broker.metadata.FieldDescriptor;

 import org.apache.ojb.broker.metadata.FieldHelper;

 import org.apache.ojb.broker.metadata.ObjectReferenceDescriptor;

 import org.apache.ojb.broker.metadata.fieldaccess.PersistentField;

 import org.apache.ojb.broker.query.Criteria;

 import org.apache.ojb.broker.query.Query;

 import org.apache.ojb.broker.query.QueryByMtoNCriteria;

 import org.apache.ojb.broker.query.ReportQueryByMtoNCriteria;

 /**

  * Relationship Prefetcher for MtoN-Collections.

  * 

  * @author <a href="mailto:jbraeuchi@gmx.ch">Jakob Braeuchi</a>

  * @version $Id: MtoNCollectionPrefetcher.java,v 1.1 2007-08-24 22:17:30 ewestfal Exp $

  */

 public class MtoNCollectionPrefetcher extends CollectionPrefetcher

 {

     /**

      * @param aBroker the PersistenceBroker

      * @param anOrd the CollectionDescriptor

      */

     public MtoNCollectionPrefetcher(PersistenceBrokerImpl aBroker, ObjectReferenceDescriptor anOrd)

     {

         super(aBroker, anOrd);

     }

     /**

      * @see org.apache.ojb.broker.accesslayer.RelationshipPrefetcher#prefetchRelationship(Collection)

      */

     public void prefetchRelationship(Collection owners)

     {

         Query[] queries;

         Query[] mnQueries;

         Collection children = new ArrayList();

         Collection mnImplementors = new ArrayList();

         queries = buildPrefetchQueries(owners, children);

         mnQueries = buildMtoNImplementorQueries(owners, children);

         for (int i = 0; i < queries.length; i++)

         {

             Iterator iter = getBroker().getIteratorByQuery(queries[i]);

             while (iter.hasNext())

             {

                 Object aChild = iter.next();

                 // BRJ: simulate the distinct removed from the query

                 if (!children.contains(aChild))

                 {

                     children.add(aChild);

                 }

             }

             Iterator mnIter = getBroker().getReportQueryIteratorByQuery(mnQueries[i]);

             while (mnIter.hasNext())

             {

                 mnImplementors.add(mnIter.next());

             }

         }

         associateBatched(owners, children, mnImplementors);

     }

     /**

      * Build the prefetch query for a M-N relationship, The query looks like the following sample :

      * <br>

      * <pre>

      *       crit = new Criteria();

      *       crit.addIn("PERSON_PROJECT.PROJECT_ID", ids);

      *       crit.addEqualToField("id","PERSON_PROJECT.PERSON_ID");

      *       qry = new QueryByMtoNCriteria(Person.class, "PERSON_PROJECT", crit, true);

      * </pre>

      *

      * @param ids Collection containing all identities of objects of the M side

      * @return the prefetch Query

      */

     protected Query buildPrefetchQuery(Collection ids)

     {

         CollectionDescriptor cds = getCollectionDescriptor();

         String[] indFkCols = getFksToThisClass();

         String[] indItemFkCols = getFksToItemClass();

         FieldDescriptor[] itemPkFields = getItemClassDescriptor().getPkFields();

         Criteria crit = buildPrefetchCriteria(ids, indFkCols, indItemFkCols, itemPkFields);

         // BRJ: do not use distinct:

         //

         // ORA-22901 cannot compare nested table or VARRAY or LOB attributes of an object type

         // Cause: Comparison of nested table or VARRAY or LOB attributes of an

         // object type was attempted in the absence of a MAP or ORDER method.

         // Action: Define a MAP or ORDER method for the object type.

         //

         // Without the distinct the resultset may contain duplicate rows

         return new QueryByMtoNCriteria(cds.getItemClass(), cds.getIndirectionTable(), crit, false);

     }

     /**

      * Build a query to read the mn-implementors

      * @param ids

      */

     protected Query buildMtoNImplementorQuery(Collection ids)

     {

         String[] indFkCols = getFksToThisClass();

         String[] indItemFkCols = getFksToItemClass();

         FieldDescriptor[] pkFields = getOwnerClassDescriptor().getPkFields();

         FieldDescriptor[] itemPkFields = getItemClassDescriptor().getPkFields();

         String[] cols = new String[indFkCols.length + indItemFkCols.length];

         int[] jdbcTypes = new int[indFkCols.length + indItemFkCols.length];

         // concatenate the columns[]

         System.arraycopy(indFkCols, 0, cols, 0, indFkCols.length);

         System.arraycopy(indItemFkCols, 0, cols, indFkCols.length, indItemFkCols.length);

         Criteria crit = buildPrefetchCriteria(ids, indFkCols, indItemFkCols, itemPkFields);

         // determine the jdbcTypes of the pks

         for (int i = 0; i < pkFields.length; i++)

         {

             jdbcTypes[i] = pkFields[i].getJdbcType().getType();

         }

         for (int i = 0; i < itemPkFields.length; i++)

         {

             jdbcTypes[pkFields.length + i] = itemPkFields[i].getJdbcType().getType();

         }

         ReportQueryByMtoNCriteria q = new ReportQueryByMtoNCriteria(getItemClassDescriptor().getClassOfObject(), cols,

                 crit, false);

         q.setIndirectionTable(getCollectionDescriptor().getIndirectionTable());

         q.setJdbcTypes(jdbcTypes);

         CollectionDescriptor cds = getCollectionDescriptor();

         //check if collection must be ordered

         if (!cds.getOrderBy().isEmpty())

         {

             Iterator iter = cds.getOrderBy().iterator();

             while (iter.hasNext())

             {

                 q.addOrderBy((FieldHelper) iter.next());

             }

         }

         return q;

     }

     /**

      * prefix the this class fk columns with the indirection table

      */

     private String[] getFksToThisClass()

     {

         String indTable = getCollectionDescriptor().getIndirectionTable();

         String[] fks = getCollectionDescriptor().getFksToThisClass();

         String[] result = new String[fks.length];

         for (int i = 0; i < result.length; i++)

         {

             result[i] = indTable + "." + fks[i];

         }

         return result;

     }

     /**

      * prefix the item class fk columns with the indirection table

      */

     private String[] getFksToItemClass()

     {

         String indTable = getCollectionDescriptor().getIndirectionTable();

         String[] fks = getCollectionDescriptor().getFksToItemClass();

         String[] result = new String[fks.length];

         for (int i = 0; i < result.length; i++)

         {

             result[i] = indTable + "." + fks[i];

         }

         return result;

     }

     /**

      * Build the multiple queries for one relationship because of limitation of IN(...)

      * 

      * @param owners Collection containing all objects of the ONE side

      */

     protected Query[] buildMtoNImplementorQueries(Collection owners, Collection children)

     {

         ClassDescriptor cld = getOwnerClassDescriptor();

         PersistenceBroker pb = getBroker();

         //Class topLevelClass = pb.getTopLevelClass(cld.getClassOfObject());

         //BrokerHelper helper = pb.serviceBrokerHelper();

         Collection queries = new ArrayList(owners.size());

         Collection idsSubset = new HashSet(owners.size());

         //Object[] fkValues;

         Object owner;

         Identity id;

         Iterator iter = owners.iterator();

         while (iter.hasNext())

         {

             owner = iter.next();

             id = pb.serviceIdentity().buildIdentity(cld, owner);

             idsSubset.add(id);

             if (idsSubset.size() == pkLimit)

             {

                 queries.add(buildMtoNImplementorQuery(idsSubset));

                 idsSubset.clear();

             }

         }

         if (idsSubset.size() > 0)

         {

             queries.add(buildMtoNImplementorQuery(idsSubset));

         }

         return (Query[]) queries.toArray(new Query[queries.size()]);

     }

     /**

      * Build the prefetch criteria

      *

      * @param ids Collection of identities of M side

      * @param fkCols indirection table fks to this class

      * @param itemFkCols indirection table fks to item class

      * @param itemPkFields

      */

     private Criteria buildPrefetchCriteria(Collection ids, String[] fkCols, String[] itemFkCols,

             FieldDescriptor[] itemPkFields)

     {

         if (fkCols.length == 1 && itemFkCols.length == 1)

         {

             return buildPrefetchCriteriaSingleKey(ids, fkCols[0], itemFkCols[0], itemPkFields[0]);

         }

         else

         {

             return buildPrefetchCriteriaMultipleKeys(ids, fkCols, itemFkCols, itemPkFields);

         }

     }

     /**

      * Build the prefetch criteria

      *

      * @param ids Collection of identities of M side

      * @param fkCol indirection table fks to this class

      * @param itemFkCol indirection table fks to item class

      * @param itemPkField

      * @return the Criteria 

      */

     private Criteria buildPrefetchCriteriaSingleKey(Collection ids, String fkCol, String itemFkCol,

             FieldDescriptor itemPkField)

     {

         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(fkCol, values.get(0));

                 break;

             default :

                 // create IN (...) for the single key field

                 crit.addIn(fkCol, values);

                 break;

         }

         crit.addEqualToField(itemPkField.getAttributeName(), itemFkCol);

         return crit;

     }

     /**

      * Build the prefetch criteria

      *

      * @param ids Collection of identities of M side

      * @param fkCols indirection table fks to this class

      * @param itemFkCols indirection table fks to item class

      * @param itemPkFields

      * @return the Criteria

      */

     private Criteria buildPrefetchCriteriaMultipleKeys(Collection ids, String[] fkCols, String[] itemFkCols,

             FieldDescriptor[] itemPkFields)

     {

         Criteria crit = new Criteria();

         Criteria critValue = new Criteria();

         Iterator iter = ids.iterator();

         for (int i = 0; i < itemPkFields.length; i++)

         {

             crit.addEqualToField(itemPkFields[i].getAttributeName(), itemFkCols[i]);

         }

         while (iter.hasNext())

         {

             Criteria c = new Criteria();

             Identity id = (Identity) iter.next();

             Object[] val = id.getPrimaryKeyValues();

             for (int i = 0; i < val.length; i++)

             {

                 if (val[i] == null)

                 {

                     c.addIsNull(fkCols[i]);

                 }

                 else

                 {

                     c.addEqualTo(fkCols[i], val[i]);

                 }

             }

             critValue.addOrCriteria(c);

         }

         crit.addAndCriteria(critValue);

         return crit;

     }

     /**

      * Answer the FieldConversions for the PkFields 

      * @param cld

      * @return the pk FieldConversions

      */

     private FieldConversion[] getPkFieldConversion(ClassDescriptor cld)

     {

         FieldDescriptor[] pks = cld.getPkFields();

         FieldConversion[] fc = new FieldConversion[pks.length]; 

         for (int i= 0; i < pks.length; i++)

         {

             fc[i] = pks[i].getFieldConversion();

         }

         return fc;

     }

     /**

      * Convert the Values using the FieldConversion.sqlToJava

      * @param fcs

      * @param values

      */

     private Object[] convert(FieldConversion[] fcs, Object[] values)

     {

         Object[] convertedValues = new Object[values.length];

         for (int i= 0; i < values.length; i++)

         {

             convertedValues[i] = fcs[i].sqlToJava(values[i]);

         }

         return convertedValues;

     }

     /**

      * associate the batched Children with their owner object loop over children

      * <br><br>

      * BRJ: There is a potential problem with the type of the pks used to build the Identities.

      * When creating an Identity for the owner, the type of pk is defined by the instvars 

      * representing the pk. When creating the Identity based on the mToNImplementor the

      * type of the pk is defined by the jdbc-type of field-descriptor of the referenced class.

      * This type mismatch results in Identities not being equal.

      * Integer[] {10,20,30} is not equal Long[] {10,20,30} 

      * <br><br>

      * This problem is documented in defect OJB296. 

      * The conversion of the keys of the mToNImplementor should solve this problem.

      */

     protected void associateBatched(Collection owners, Collection children, Collection mToNImplementors)

     {

         CollectionDescriptor cds = getCollectionDescriptor();

         PersistentField field = cds.getPersistentField();

         PersistenceBroker pb = getBroker();

         Class ownerTopLevelClass = pb.getTopLevelClass(getOwnerClassDescriptor().getClassOfObject());

         Class childTopLevelClass = pb.getTopLevelClass(getItemClassDescriptor().getClassOfObject());

         Class collectionClass = cds.getCollectionClass(); // this collection type will be used:

         HashMap childMap = new HashMap();

         HashMap ownerIdsToLists = new HashMap();

         FieldConversion[] ownerFc = getPkFieldConversion(getOwnerClassDescriptor()); 

         FieldConversion[] childFc = getPkFieldConversion(getItemClassDescriptor());  

         // initialize the owner list map

         for (Iterator it = owners.iterator(); it.hasNext();)

         {

             Object owner = it.next();

             Identity oid = pb.serviceIdentity().buildIdentity(owner);

             ownerIdsToLists.put(oid, new ArrayList());

         }

         // build the children map

         for (Iterator it = children.iterator(); it.hasNext();)

         {

             Object child = it.next();

             Identity oid = pb.serviceIdentity().buildIdentity(child);

             childMap.put(oid, child);

         }

         int ownerPkLen = getOwnerClassDescriptor().getPkFields().length;

         int childPkLen = getItemClassDescriptor().getPkFields().length;

         Object[] ownerPk = new Object[ownerPkLen];

         Object[] childPk = new Object[childPkLen];

         // build list of children based on m:n implementors

         for (Iterator it = mToNImplementors.iterator(); it.hasNext();)

         {

             Object[] mToN = (Object[]) it.next();

             System.arraycopy(mToN, 0, ownerPk, 0, ownerPkLen);

             System.arraycopy(mToN, ownerPkLen, childPk, 0, childPkLen);

             // BRJ: apply the FieldConversions, OJB296

             ownerPk = convert(ownerFc, ownerPk);

             childPk = convert(childFc, childPk);

             Identity ownerId = pb.serviceIdentity().buildIdentity(null, ownerTopLevelClass, ownerPk);

             Identity childId = pb.serviceIdentity().buildIdentity(null, childTopLevelClass, childPk);

             // Identities may not be equal due to type-mismatch

             Collection list = (Collection) ownerIdsToLists.get(ownerId);

             Object child = childMap.get(childId);

             list.add(child);

         }

         // connect children list to owners

         for (Iterator it = owners.iterator(); it.hasNext();)

         {

             Object result;

             Object owner = it.next();

             Identity ownerId = pb.serviceIdentity().buildIdentity(owner);

             List list = (List) ownerIdsToLists.get(ownerId);

             if ((collectionClass == null) && field.getType().isArray())

             {

                 int length = list.size();

                 Class itemtype = field.getType().getComponentType();

                 result = Array.newInstance(itemtype, length);

                 for (int j = 0; j < length; j++)

                 {

                     Array.set(result, j, list.get(j));

                 }

             }

             else

             {

                 ManageableCollection col = createCollection(cds, collectionClass);

                 for (Iterator it2 = list.iterator(); it2.hasNext();)

                 {

                     col.ojbAdd(it2.next());

                 }

                 result = col;

             }

             Object value = field.get(owner);

             if ((value instanceof CollectionProxyDefaultImpl) && (result instanceof Collection))

             {

                 ((CollectionProxyDefaultImpl) value).setData((Collection) result);

             }

             else

             {

                 field.set(owner, result);

             }

         }

     }

 }