Aggregate.java #2

/*
// $Id: //guest/julian_hyde/saffron/src/main/saffron/rel/Aggregate.java#2 $
// Saffron preprocessor and data engine
// Copyright (C) 2002 Julian Hyde <julian.hyde@mail.com>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Library General Public
// License as published by the Free Software Foundation; either
// version 2 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public
// License along with this library; if not, write to the
// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
// Boston, MA  02111-1307, USA.
//
// See the COPYING file located in the top-level-directory of
// the archive of this library for complete text of license.
*/

package saffron.rel;
import openjava.mop.OJClass;
import openjava.ptree.Expression;
import openjava.ptree.util.SyntheticClass;
import saffron.Planner;
import saffron.opt.CallingConvention;
import saffron.opt.Cluster;
import saffron.opt.Cost;
import saffron.opt.Implementor;
import saffron.rel.java.JavaAggregate;
import saffron.util.Util;

/**
 * <code>Aggregate</code> is a relational operator which eliminates duplicates
 * and computes totals.
 *
 * @author jhyde
 * @since 3 February, 2002
 * @version $Id: //guest/julian_hyde/saffron/src/main/saffron/rel/Aggregate.java#2 $
 **/
public class Aggregate extends SingleRel {
	protected int groupCount;
	protected Call[] aggCalls;

	public Aggregate(
		Cluster cluster, Rel child, int groupCount, Call[] aggCalls)
	{
		super(cluster, child);
		this.groupCount = groupCount;
		this.aggCalls = aggCalls;
	}

	public Object clone() {
		return new Aggregate(cluster, Util.clone(child), groupCount, aggCalls);
	}

	// implement Rel
	protected OJClass deriveRowType()
	{
		OJClass childType = child.getRowType();
		OJClass[] types = new OJClass[groupCount + aggCalls.length];
		for (int i = 0; i < groupCount; i++) {
			types[i] = childType.getDeclaredFields()[i].getType();
		}
		for (int i = 0; i < aggCalls.length; i++) {
			types[groupCount + i] = aggCalls[i].aggregation.getReturnType();
		}
		return SyntheticClass.createProject(getTempClass(), types, null);
	}

	// implement Plan
	public Cost computeSelfCost(Planner planner)
	{
		return planner.makeZeroCost();
	}

	// override Rel
	public Rel changeConvention(Planner planner, int convention)
	{
		switch (convention) {
		case CallingConvention.JAVA:
			Rel convertedChild = planner.convert(child, convention);
			if (convertedChild == null) {
				return null;
			}
			return new JavaAggregate(
				cluster, convertedChild, groupCount, aggCalls);
		default:
			return null;
		}
	}

	public static class Call
	{
        Aggregation aggregation;
		int[] args;

		public Call(Aggregation aggregation, int[] args)
		{
			this.aggregation = aggregation;
			this.args = args;
		}

        public Aggregation getAggregation() {
            return aggregation;
        }
        public int[] getArgs() {
            return args;
        }
		// override Object
		public boolean equals(Object o)
		{
			if (!(o instanceof Call)) {
				return false;
			}
			Call other = (Call) o;
			return aggregation.equals(other.aggregation) &&
				Util.equals(args, other.args);
		}

		public Expression implementStart(Implementor implementor, Rel rel) {
			return aggregation.implementStart(implementor, rel, args);
		}
		public Expression implementStartAndNext(
				Implementor implementor, Rel rel) {
			return aggregation.implementStartAndNext(implementor, rel, args);
		}
		public void implementNext(
				Implementor implementor, Rel rel, Expression accumulator) {
			aggregation.implementNext(implementor, rel, accumulator, args);
		}
		/**
		 * Generates the expression to retrieve the result of this
		 * aggregation.
		 **/
		public Expression implementResult(Expression accumulator)
		{
			return aggregation.implementResult(accumulator);
		}
	};
}

// End Aggregate.java