Quadcap Embeddable Database

com/quadcap/sql/MergeCursor.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.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

import java.util.Vector;

import java.sql.SQLException;

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

import com.quadcap.sql.file.ByteUtil;

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

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

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

/**
 * Cursor implementing the SQL <b>UNION</b> or <b>INTERSECTION</b> operations.
 * This cursor shares some functionality with the GroupByCursor class,
 * and factorization should be investigated.
 *
 * @author Stan Bailes
 */
public class MergeCursor extends CursorImpl {
    int                                 op;
    boolean                             all;
    TempTableMerge                      tempTable;
    LazyRow                             row = null;
    BCursor                             bc = null;
    int                                 duplicateCount  = 0;

    public MergeCursor(Session session, int op, boolean all,
                       TempTableMerge tempTable)
        throws SQLException
    {
        super(session, null, null);
        this.op = op;
        this.all = all;
        this.tempTable = tempTable;
    }

    public Row getRow() throws SQLException {
        return row;
    }

    public void checkCursor() throws IOException {
        if (bc == null) {
            bc = tempTable.getCursor();
        }
    }

    public long getRowId() {
        byte[] val = bc.getValBuf();
        return val[0] == 1 ? 0 : ByteUtil.getLong(val, 1);
    }

    public void resolveColumns() throws SQLException {
        super.resolveColumns();
        row = new LazyRow(getColumnCount());
        beforeFirst();
    }

    public String getName() { return ""; }

    public long size() throws SQLException {
        try {
            checkCursor();
            return bc.size();
        } catch (IOException e) {
            throw DbException.wrapThrowable(e);
        }
    }
    
    public void afterLast() throws SQLException {
        throw new SQLException("afterLast() not supported for this cursor type");
    }

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

    public boolean next() throws SQLException {
        try {
            checkCursor();
            switch (op) {
            case Op.UNION:
                return all ? nextUnionAll() : nextUnion();
            case Op.INTERSECT:
                return nextIntersect();
            case Op.EXCEPT:
                return nextExcept();
            default:
                throw new SQLException("Bad merge op: " + op, "42000");
            }
        } catch (IOException e) {
            throw DbException.wrapThrowable(e);
        }
    }

    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 {
            checkCursor();
            bc.beforeFirst();
        } catch (IOException e) {
            throw DbException.wrapThrowable(e);
        } finally {
            duplicateCount = 0;
        }
    }

    /**
     * Separate from 'nextUnionAll' because we can avoid fetching the
     * data for this case.
     */
    boolean nextUnion() throws SQLException, IOException {
        if (!bc.next()) return false;
        tempTable.getRow(bc.getValBuf(), row);
        return true;
    }

    /**
     * Fetch the data once when we fetch the counts, then return each
     * row the required number of times
     */
    boolean nextUnionAll() throws SQLException, IOException {
        if (duplicateCount-- <= 0) {
            if (!bc.next()) return false;
            tempTable.getRow(bc.getValBuf(), row);
            byte[] data = bc.getValBuf();
            int acnt = TempTableMerge.getCount(data, 0);
            int bcnt = TempTableMerge.getCount(data, 1);
            duplicateCount = acnt + bcnt - 1;
            return true;
        }
        return true;
    }

    boolean nextIntersect() throws SQLException, IOException {
        if (!all || duplicateCount-- <= 0) {
            boolean found = false;
            do {
                if (!bc.next()) return false;
                byte[] data = bc.getValBuf();
                int acnt = TempTableMerge.getCount(data, 0);
                int bcnt = TempTableMerge.getCount(data, 1);
                duplicateCount =
                    all
                    ? Math.min(acnt, bcnt)
                    : (acnt > 0 && bcnt > 0) ? 1 : 0;
                if (duplicateCount-- > 0) {
                    tempTable.getRow(data, row);
                    found = true;
                }
            } while (!found);
            return found;
        }
        return true;
    }
    
    boolean nextExcept() throws SQLException, IOException {
        if (!all || duplicateCount-- <= 0) {
            boolean found = false;
            do {
                if (!bc.next()) return false;
                byte[] data = bc.getValBuf();
                int acnt = TempTableMerge.getCount(data, 0);
                int bcnt = TempTableMerge.getCount(data, 1);
                duplicateCount =
                    all
                    ? (acnt - bcnt)
                    : (acnt > 0 && bcnt == 0) ? 1 : 0;
                if (duplicateCount-- > 0) {
                    tempTable.getRow(data, row);
                    found = true;
                }
            } while (!found);
            return found;
        }
        return true;
    }
    
    /**
     * On close, we release the resources.
     */
    public void close() throws SQLException {
        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;
            }
        }
    }
}