Quadcap Embeddable Database

com/quadcap/sql/AggregateExpression.java

Go to the documentation of this file.

package com.quadcap.sql;

/* Copyright 1999 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

import java.util.Enumeration;
import java.util.Vector;

import java.sql.SQLException;

import com.quadcap.sql.types.Op;
import com.quadcap.sql.types.Type;
import com.quadcap.sql.types.TypeInt;
import com.quadcap.sql.types.Value;
import com.quadcap.sql.types.ValueDouble;
import com.quadcap.sql.types.ValueInteger;
import com.quadcap.sql.types.ValueNull;

import com.quadcap.sql.index.Btree;

import com.quadcap.util.Debug;

/**
 * Expression implementing one of <b>AVG</b>, <b>SUM</b>,
 * <b>MIN</b>, or <b>MAX</b>.
 *
 * @author Stan Bailes
 */
public class AggregateExpression
    extends Expression implements Externalizable
{
    public static final int             AVG             = 0;
    public static final int             SUM             = 1;
    public static final int             MIN             = 2;
    public static final int             MAX             = 3;
    public static final int             COUNT           = 4;
    
    int                                 op              = -1;
    boolean                             all             = false;
    Expression                          expr            = null;

    static String[] ops = {"AVG","SUM","MIN","MAX","COUNT"};

    static String toString(int op) {
        try {
            return ops[op];
        } catch (Throwable y) {
            return "bad op<" + op + ">";
        }
    }

    static final byte[]         aByte           = { 0 };

    /**
     * Default constructor
     */
    public AggregateExpression() {}

    /**
     * Explicit constructor
     */
    public AggregateExpression(int op, boolean all, Expression expr) {
        this.op = op;
        this.all = all;
        this.expr = expr;
    }

    Expression getInnerExpression() {
        return expr;
    }

    boolean isMin() { return op == MIN; }
    boolean isMax() { return op == MAX; }
    boolean isCount() { return op == COUNT; }

    /**
     * Private class to maintain per-session state for this expression
     */
    class AggregateSessionState implements StatementContext {
        Session                         session;
        Btree                           distinct        = null;

        Value                           accum           = null;
        int                             count           = 0;

        public AggregateSessionState(Session session) {
            this.session = session;
        }

        /** Whenever you get around to finishing me is fine. */
        public int priority() { return 4; }

        /** Girl I believe I got to move on down the line. */
        public void finish(boolean abort) throws IOException {
            try {
                if (distinct != null) {
                    distinct.free();
                }
            } finally {
                if (distinct != null) session.getDatabase().releaseTempFile();
                distinct = null;
            }
        }

        /** Get ready for another day */
        public void reset() throws IOException {        
            count = 0;
            accum = null;
            finish(false);
        }
    }
        
    public void reset(Session session) throws IOException {        
        AggregateSessionState s = getSessionState(session);
        if (s != null) s.reset();
    }

    AggregateSessionState getSessionState(Session session) {
        return getSessionState(session, true);
    }
    
    AggregateSessionState getSessionState(Session session, boolean mk) {
        AggregateSessionState s = (AggregateSessionState)
            session.getContext(this, false);
        if (s == null && mk) {
            s = new AggregateSessionState(session);
            session.putContext(this, false, s);
        }
        return s;
    }
    
    public int rank() { return 0; }

    public Type getType(Session session, Cursor cursor)
        throws SQLException
    {
        switch (op) {
        case COUNT:
            return TypeInt.typeInt;
        default:
            return expr.getType(session, cursor);
        }
    }

    public Value getValue(Session session, Cursor cursor)
        throws SQLException
    {
        AggregateSessionState s = getSessionState(session);
        switch (op) {
        case AVG:
            if (s.accum == null) {
                return ValueNull.valueNull;
            }
            return Value.binop(Op.DIVIDE, s.accum,
                               new ValueInteger(s.count));
        case SUM:
        case MIN:
        case MAX:
            if (s.accum == null) return ValueNull.valueNull;
            return s.accum;
        case COUNT:
            return new ValueInteger(s.count);
        default:
            throw new SQLException("Bad aggregate type: " + op, "42000");
        }
    }
    
    public void updateAggregate(Session session, Cursor cursor)
        throws SQLException
    {
        AggregateSessionState s = getSessionState(session);
        Value v1 = null;
        if (cursor != null) {
            if (expr !=  null) {
                v1 = expr.getValue(session, cursor);
            }
            if (!Value.isNull(v1)) {
                if (all) {
                    s.count++;
                } else {
                    try {
                        if (s.distinct == null) {
                            s.distinct = session.makeTempTree();
                        }
                        byte[] key = Value.bytes(v1);                    
                        if (!s.distinct.set(key, key.length,
                                            aByte, 0, 1)) {
                            s.count++;
                        } else {
                            v1 = ValueNull.valueNull;
                        }
                    } catch (IOException e) {
                        throw DbException.wrapThrowable(e);
                    }
                }
            }
        } else {
            v1 = ValueNull.valueNull;
        }
        switch (op) {
        case AVG:
        case SUM:
            if (!Value.isNull(v1)) {
                if (s.accum == null) {
                    s.accum = v1;
                } else {
                    s.accum = Value.binop(Op.PLUS, v1, s.accum);
                }
            }
            break;
        case MIN:
            if (!Value.isNull(v1)) {
                if (s.accum == null || Value.boolOp(Op.LT, v1, s.accum)) {
                    s.accum = v1;
                }
            }
            break;
        case MAX:
            if (!Value.isNull(v1)) {
                if (s.accum == null || Value.boolOp(Op.GT, v1, s.accum)) {
                    s.accum = v1;
                }
            }
            break;
        case COUNT:
            break;
        default:
            throw new SQLException("Bad aggregate type: " + op, "42000");
        }           
    }
    
    public void invert() {
    }

    public String toString() {
        StringBuffer sb = new StringBuffer(toString(op));
        if (!all) sb.append(" DISTINCT");
        sb.append(' ');
        sb.append(String.valueOf(expr));
        return sb.toString();
    }

    public void visitSubExpressions(ExpressionVisitor ev) {
        ev.visit(expr);
    }

    public void readExternal(ObjectInput in)
        throws IOException, ClassNotFoundException
    {
        expr = (Expression)in.readObject();
        op = in.readInt();
        all = (in.read() == 1);
    }
    
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(expr);
        out.writeInt(op);
        out.write(all ? 1 : 0);
    }
}