package org.apache.ojb.broker.accesslayer;
/* Copyright 2003-2004 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.10.2.1 2005/01/13 19:20:03 arminw Exp $
*/
public abstract class BasePrefetcher implements RelationshipPrefetcher
{
private Logger logger;
private PersistenceBrokerImpl broker;
protected ClassDescriptor itemClassDesc;
protected final int pkLimit; // max number of pk's in one query
protected static final int IN_LIMIT = getPrefetchInLimit();
/**
* read the prefetchInLimit from Config based on OJB.properties
*/
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;
}
}