Quadcap Embeddable Database

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

import java.util.Enumeration;
import java.util.Hashtable;

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.util.Debug;
import com.quadcap.util.Util;

/**
 * Cursor that implements the <b>DISTINCT</b> modifier by creating
 * temporary table, where the entire row is used as the index key.
 *
 * @author Stan Bailes
 */
public class DistinctCursor extends BC_Cursor {
    Cursor                              sourceCursor;
    Vector                              orderBy         = null;
    TempTable                           tempTable;
    boolean                             distinct        = true;

    /**
     * Constructor on session and cursor
     */
    public DistinctCursor(Session session, Cursor cursor) throws SQLException {
        super(session, null, null);
        this.sourceCursor = cursor;
        addColumns(session, cursor);
    }

    public final void checkCursor() throws SQLException, IOException {
        if (bc == null) {
            try {
                makeTempTable();
            } finally {
                try {
                    sourceCursor.close();
                } catch (Throwable t) {
                } finally {
                    sourceCursor = null;
                }
            }
        }
    }


    private void makeTempTable() throws IOException, SQLException {
        int size = getColumnCount();
        if (orderBy == null) {
            if (distinct) {
                tempTable = new TempTable(session, new Key(size), null);
            } else {
                tempTable = new TempTable(session, new Key(1), new int[0]);
            }
        } else {
            tempTable = makeObTemp();
        }
        tempTable.addRows(sourceCursor);
        row = new LazyRow(size);
        bc = tempTable.getCursor();
    }

    TempTable makeObTemp() throws SQLException, IOException {
        int[] map = new int[getColumnCount()];
        boolean[] rmap = new boolean[map.length+1];
        boolean[] asc = new boolean[map.length];
        for (int i = 0; i < orderBy.size(); i++) {
            OrderElement elem = (OrderElement)orderBy.elementAt(i);
            int num = elem.getColumn();
            if (num < 0) {
                String name = elem.getColName();
                Column col = getColumn(name);
                if (col == null) {
                    throw new SQLException("Bad column name: " + name);
                }
                num = col.getColumn();
                elem.setColumn(num);
            }
            map[i] = num;
            rmap[num] = true;
            asc[i] = elem.isAscending();
        }
        int cnt = orderBy.size();
        for (int i = 1; i < rmap.length; i++) {
            if (!rmap[i]) {
                map[cnt] = i;
                asc[cnt] = true;
                cnt++;
            }
        }           
        Key compare = new Key(asc);
        return new TempTable(session, compare, map);
    }

    public void setOrder(Vector v) {
        this.orderBy = v;
    }

    public void setDistinct(boolean b) {
        this.distinct = b;
    }    

    public long getCurrentRowId() throws SQLException {
        return ByteUtil.getLong(bc.getValBuf(), 1);
    }

    public void fetchCurrentRow() throws SQLException, IOException {
        tempTable.getRow(bc.getValBuf(), row);
        rowValid = true;
    }
    
    /**
     * On close, we release the resources.
     */
    public void close() throws SQLException {
        try {
            super.close();
        } finally {
            try {
                if (sourceCursor != null) sourceCursor.close();
            } finally {
                sourceCursor = null;
                try {
                    if (tempTable != null) tempTable.release();
                } catch (IOException ex) {
                    throw DbException.wrapThrowable(ex);
                } finally {
                    tempTable = null;
                }
            }
        }
    }

    //#ifdef DEBUG
    public String toString() {
        return super.toString() + "\n\t[source cursor = " + sourceCursor + "]\n";
    }
    //#endif
}