Quadcap Embeddable Database

com/quadcap/sql/TempTableMerge.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.IOException;

import java.sql.SQLException;

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

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

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

/**
 * A special temp table used to implement <b>UNION</b> and <b>INTERSECT</b>
 * expressions.
 *
 * <p>
 * The temp table that we build has keys based on the union columns,
 * and the data as 13 bytes:
 * </p>
 * <table>
 * <tr><td>byte 0:</td>     <td>if zero, the rowId refers to a real table row
 *                          if one, the rowId refers to a temp row</td></tr>
 * <tr><td>bytes 1-8:</td>  <td>the rowId of the union row</td></tr>
 * <tr><td>bytes 9-12:</td> <td>the duplicate count (from table 1)</td></tr>
 * <tr><td>bytes 13-16:</td><td> the duplicate count (from table 2)</td></td>
 * </table>
 *
 * @author Stan Bailes
 */
public class TempTableMerge extends TempTable {

    /**
     * Byte offset of 'isTemp' byte flag in a data row.
     */
    final static int            fIS_TEMP = 0;

    /**
     * The byte offset of the (long) row ID in data data row
     */
    final static int            fROW_ID = 1;

    /**
     * The byte offset of the two 'count' integers. in the data row
     */
    final static int            fCOUNT = 9;

    /**
     * Total size of the data buffer in our temp index
     */
    final static int            BUFSIZE = 17;

    /**
     * Constructor for session and key
     */
    public TempTableMerge(Session session, Key compare) 
        throws SQLException, IOException 
    {
        super(session, compare, null);
        this.data = new byte[BUFSIZE];
    }
    
    /**
     * Add rows from one side of the {union/merge} operation, building a
     * temporary index on the key.
     */
    public void addRows(Session session, Cursor cursor, int side, int[] map) 
        throws SQLException, IOException 
    {
        int cpos = fCOUNT + side * 4;
        MapRow mapRow = new MapRow(map);
        BCursor wc = index.getCursor();
        //#ifdef DEBUG
        if (trace) {
            Debug.println("TempTable[" + mySerial + "].addRows() begin");
        }
        //#endif
        try {
            while (cursor.next()) {
                final Row row = cursor.getRow();
                mapRow.setRow(row);
                final byte[] key = Key.makeKey(null, mapRow, null, 0, false);
                final boolean found = wc.seek(key);
                if (found) {
                    byte[] tdata = wc.getValBuf();
                    final int cnt = ByteUtil.getInt(tdata, cpos);
                    ByteUtil.putInt(tdata, cpos, cnt+1);
                    wc.replace(tdata, 0, BUFSIZE);
                } else {
                    for (int i = 0; i < BUFSIZE; i++) {
                        data[i] = 0;
                    }
                    data[cpos+3] = 1;    //ByteUtil.putInt(data, cpos, 1);

                    long rowId = cursor.getRowId();
                    if (map == null && rowId != 0) {
                        ByteUtil.putLong(data, fROW_ID, rowId);
                    } else {
                        rowId = session.getDatabase().putRow(session,
                                                             tempFile, cursor, mapRow);
                        //#ifdef DEBUG
                        if (trace) {
                            Debug.println("TempTable[" + mySerial + "].putRow: " + toString(rowId));
                        }
                        //#endif
                        ByteUtil.putLong(data, fROW_ID, rowId);
                        data[fIS_TEMP] = 1;
                    }
                    wc.insert(key, data);
                }
            }
        } finally {
            wc.release();
        }
        //#ifdef DEBUG
        if (trace) {
            Debug.println("TempTable[" + mySerial + "].addRows() complete");
        }
        //#endif
    }

    public byte[] getData(byte[] key) throws IOException {
        if (index.get(key, key.length, data) != data.length) {
            return null;
        }
        return data;
    }

    final int getCount(int side) {
        return getCount(data, side);
    }

    final static int getCount(byte[] data, int side) {
        return ByteUtil.getInt(data, fCOUNT + (side*4));
    }

}