Quadcap Embeddable Database

com/quadcap/sql/GroupByCursor.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.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

import java.util.Vector;

import java.sql.SQLException;

import com.quadcap.sql.io.ObjectInputStream;
import com.quadcap.sql.io.ObjectOutputStream;

import com.quadcap.sql.index.BCursor;
import com.quadcap.sql.index.Btree;

import com.quadcap.sql.file.BlockFile;
import com.quadcap.sql.file.PageManager;

import com.quadcap.sql.types.Op;
import com.quadcap.sql.types.Value;

import com.quadcap.util.Debug;
import com.quadcap.util.Util;

/**
 * Cursor to support SQL <b>GROUP BY</b>.
 *
 * @author Stan Bailes
 */

public class GroupByCursor extends FilterCursor {
    Vector              groupBy                         = null;
    int                 currentRowNum                   = 0;
    byte[]              prevKey                         = new byte[32];
    int                 prevKeyLen                      = -1;
    int[]               gMap                            = null;
    BCursor             bc                              = null;
    LazyRow             prevRow                         = null;
    LazyRow             currRow                         = null;
    boolean             sameGroup                       = false;
    boolean             prev                            = false;
    Key                 compare                         = null;
    TempTable           tempTable                       = null;

    public GroupByCursor(Session session, Cursor cursor, Vector groupBy)
        throws SQLException
    {
        super(session, cursor);
        
        this.currRow = new LazyRow(cursor.getColumnCount());
        this.prevRow = new LazyRow(cursor.getColumnCount());
        this.groupBy = groupBy;
        this.gMap = new int[groupBy.size()];
        this.compare = new Key(gMap.length);
        for (int i = 0; i < gMap.length; i++) {
            Column c = cursor.getColumn((String)groupBy.elementAt(i));
            gMap[i] = c.getColumn();
        }
        try {
            this.tempTable = new TempTable(session, new Key(gMap.length+1),
                                           gMap);
            tempTable.addRows(cursor);
            this.bc = tempTable.getCursor();
            beforeFirst();
        } catch (IOException e) {
            throw DbException.wrapThrowable(e);
        }
    }

    public Row getRow() throws SQLException {
        //Debug.println("getRow: " + prevRow);
        return prevRow;
    }

    public void updateRow(Row row) throws SQLException {
        throw new SQLException("GroupBy expressions aren't updateable",
                               "42000");
    }

    public void deleteRow() throws SQLException {
        throw new SQLException("GroupBy expressions aren't updateable",
                               "42000");
    }
    
    public void beforeFirst() throws SQLException {
        try {
            bc.beforeFirst();
            prev = nextRow();
        } catch (IOException e) {
            throw DbException.wrapThrowable(e);
        } catch (ClassNotFoundException e) {
            throw DbException.wrapThrowable(e);
        }
    }

    public boolean lastRowOfGroup() {
        //Debug.println("lastRow: " + !sameGroup);
        return !sameGroup;
    }

    public boolean next() throws SQLException {
        try {
            boolean ret = prev;
            prev = nextRow();
            return ret;
        } catch (IOException e) {
            throw DbException.wrapThrowable(e);
        } catch (ClassNotFoundException e) {
            throw DbException.wrapThrowable(e);
        }
    }
    
    public boolean nextRow()
        throws SQLException, IOException, ClassNotFoundException
    {
        swapRows();
        sameGroup = false;
        if (!bc.next()) {
            return false;
        }
        final byte[] key = bc.getKeyBuf();
        final int len = bc.getKeyLen();
        
        if (prevKeyLen != -1) {
            sameGroup = compare.compare(key, 0, len,
                                        prevKey, 0, prevKeyLen) == 0;
        }
        prevKey = (byte[])Util.checkCapacity(prevKey, len);
        prevKeyLen = len;
        
        System.arraycopy(key, 0, prevKey, 0, len);

        tempTable.getRow(bc.getValBuf(), currRow);
        return true;
    }

    final void swapRows() {
        LazyRow temp = prevRow;
        prevRow = currRow;
        currRow = temp;

    }

    public boolean isWritable(int col) throws SQLException {
        return false;
    }

    /**
     * I honestly have no idea.
     */
    public long size() { return -1; }

    public void close() throws SQLException {
        try {
            super.close();
        } finally {
            try {
                if (bc != null) bc.release();
            } finally {
                bc = null;
                try {
                    if (tempTable != null) tempTable.release();
                } catch (IOException e2) {
                    throw DbException.wrapThrowable(e2);                    
                } finally {
                    tempTable = null;
                }
            }
        }
    }
}