org.apache.ojb.broker.accesslayer.BasePrefetcher Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of db-ojb Show documentation
ObJectRelationalBridge (OJB) is an Object/Relational mapping tool that allows transparent persistence for Java Objects against relational databases.
The newest version!
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 Oleg Nitz
 * @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 

     */
    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;
    }
}