com.bigdata.bop.aggregate.AggregateBase Maven / Gradle / Ivy

Go to download
package com.bigdata.bop.aggregate;

import java.util.Map;

import org.openrdf.model.Literal;
import org.openrdf.model.impl.LiteralImpl;

import com.bigdata.bop.BOp;
import com.bigdata.bop.IBindingSet;
import com.bigdata.bop.IValueExpression;
import com.bigdata.bop.ImmutableBOp;
import com.bigdata.bop.NV;
import com.bigdata.bop.Var;
import com.bigdata.rdf.internal.impl.literal.NumericIV;
import com.bigdata.rdf.internal.impl.literal.XSDNumericIV;
import com.bigdata.rdf.model.BigdataLiteral;

/**
 * Abstract base class for aggregate functions.
 * 
 * @author thompsonbry
 *
 * @param 
 */
abstract public class AggregateBase extends ImmutableBOp implements IAggregate {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	
//	/**
//	 * A type safe enumeration of well known aggregate functions.
//	 */
//	static public enum FunctionCode {
//
//		/**
//		 * The count of the #of computed value expressions within the solution
//		 * group. In combination with the special keyword DISTINCT, this is the
//		 * #of distinct values from the computed value expression within the
//		 * solution group. When given with the special variable *,
//		 * this is the count of the #of solutions (or distinct solutions if also
//		 * combined with DISTINCT) within the group.
//		 */
//		COUNT(0),
//
//		/**
//		 * The sum of the computed value expressions within the solution group.
//		 * In combination with the special keyword DISTINCT, this is the sum of
//		 * the distinct values from the computed value expressions within the
//		 * solution group.
//		 */
//		SUM(1),
//
//		/**
//		 * The average is defined as
//		 * AVG(expr) := SUM(expr)/COUNT(expr). Note that both SUM
//		 * and COUNT can be hash partitioned over a cluster, so it often makes
//		 * sense to rewrite AVG(expr) internally in terms of COUNT and SUM. This
//		 * may be combined with DISTINCT.
//		 */
//		AVG(2),
//
//		/**
//		 * MIN(expr) is the minimum observed value for the computed value
//		 * expressions according to the ordering semantics of
//		 * ORDER BY expr ASC. This may be combined with DISTINCT.
//		 */
//		MIN(3), 
//		
//		/**
//		 * MAX(expr) is the maximum observed value for the computed value
//		 * expressions according to the ordering semantics of
//		 * ORDER BY expr ASC. This may be combined with DISTINCT.
//		 */
//		MAX(4),
//		
//		/**
//		 * The combined values of the computed value expressions as a string.
//		 * This may be combined with DISTINCT. 
//		 */
//		GROUP_CONCAT(5),
//
//		/**
//		 * This evaluates to an arbitrary value of the computed value
//		 * expressions. This may be combined with DISTINCT to sample from the
//		 * distinct computed values. While the implementation is not required to
//		 * choose randomly among the values to be sampled, random sampling may
//		 * prove more useful to some applications.
//		 */
//		SAMPLE(6);
//		
//		private FunctionCode(int code) {
//			this.code = code;
//		}
//
//		final private int code;
//
//		public int getCode() {
//			return code;
//		}
//		
//	}
	
	public interface Annotations extends ImmutableBOp.Annotations {

//        /**
//         * The aggregate function identifier ({@link FunctionCode#COUNT},
//         * {@link FunctionCode#SUM}, etc).
//         */
//        String FUNCTION_CODE = AggregateBase.class.getName() + ".functionCode";

        /**
         * Optional boolean property indicates whether the aggregate applies to
         * the distinct within group solutions (default
         * {@value #DEFAULT_DISTINCT}).
         */
        String DISTINCT = AggregateBase.class.getName() + ".distinct";

		boolean DEFAULT_DISTINCT = false;
		
	}

	public AggregateBase(AggregateBase op) {
		super(op);
	}

	/**
	 * Core shallow copy constructor. The distinct option is modeled
	 * using {@link Annotations#DISTINCT}. The expr is modeled as the
	 * first argument for the aggregate function.
	 * 
	 * @param args
	 * @param annotations
	 */
	public AggregateBase(BOp[] args, Map annotations) {

		super(args, annotations);

	}

	/**
	 * @param distinct
	 *            true iff the keyword DISTINCT was used, for
	 *            example COUNT(DISTINCT y)
	 * @param expr
	 *            The value expression to be computed, for example
	 *            x in COUNT(DISTINCT x) or
	 *            y+x in MIN(x+y). Note that only
	 *            COUNT may be used with the special variable *.
	 */
//    * @param functionCode
//    *            The type safe value identifying the desired aggregate
//    *            function.
	public AggregateBase(//final FunctionCode functionCode,
			final boolean distinct, final IValueExpression...expr) {

		this(expr, NV.asMap(//
//				new NV(Annotations.FUNCTION_CODE, functionCode), //
				new NV(Annotations.DISTINCT, distinct))//
		);

	}

	final public boolean isDistinct() {

		return getProperty(Annotations.DISTINCT, Annotations.DEFAULT_DISTINCT);

	}

    public boolean isWildcard() {

        return get(0).equals(Var.var("*"));

    }

    /**
     * {@inheritDoc}
     * 
     * Operation is not implemented by this class and must be overridden if the
     * {@link AggregateBase} is to be directly evaluated. However, note that the
     * computation of aggregate functions is often based on hard coded
     * recognition of the appropriate function code.
     * 
     * Note: DISTINCT is merely carried as a marker on COUNT (and the other
     * aggregate functions). The application of DISTINCT to the inner expression
     * to form a column projection is handled by the driving evaluation logic
     * rather than by {@link #get(IBindingSet)}.
     */
	public E get(IBindingSet bset) {
		throw new UnsupportedOperationException();
	}
	

    /** A ZERO. */
    protected static final transient NumericIV ZERO = new XSDNumericIV(0);

    /** An empty string. */
    protected static final transient Literal EMPTY_LITERAL = new LiteralImpl("");

}