Quadcap Embeddable Database

com/quadcap/sql/MergeExpression.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.Vector;

import java.sql.SQLException;

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

import com.quadcap.sql.file.BlockFile;

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

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

/**
 * Table expression representing <b>UNION</b> or <b>INTERSECTION</b>
 * operations.
 *
 * @author Stan Bailes
 */
public class MergeExpression extends TableExpression 
    implements Externalizable 
{
    int                                 op;
    boolean                             all;
    boolean                             corr;
    TableExpression                     a;
    TableExpression                     b;
    Vector                              columns;
    TempTableMerge                      tempTable;
    MergeCursor                         mcursor         = null;
    int[]                               amap            = null;
    int[]                               bmap            = null;
    Type[]                              typeMap         = null;
    
    public MergeExpression() {}

    public MergeExpression(int op, boolean all, TableExpression a,
                           TableExpression b, Vector columns,
                           boolean corr) {
        this.op = op;
        this.all = all;
        this.a = a;
        this.b = b;
        this.columns = columns;
        this.corr = corr;
    }

    public int rank() { return 2; }

    public boolean isUpdatable() { return false; }

    public void getBaseTables(Vector v) {
        a.getBaseTables(v);
        b.getBaseTables(v);
    }

    public void setWhere(Expression where) {
        this.where = where;
        a.setWhere(where);
        b.setWhere(where);
    }

    public Cursor getCursor(Session session, Cursor c) throws SQLException {
        try {
            Cursor ca = a.getCursor(session, c);
            Cursor cb = b.getCursor(session, c);

            try {
                checkCorresponding(ca, cb);
                
                Key compare = new Key(amap.length);

                tempTable = new TempTableMerge(session, compare);
                tempTable.addRows(session, ca, 0, amap);
                tempTable.addRows(session, cb, 1, bmap);

                mcursor = new MergeCursor(session, op, all, tempTable);

                if (!corr) {
                    for (int i = 1; i <= ca.getColumnCount(); i++) {
                        Column col = ca.getColumn(i);
                        mcursor.addColumn(new Column(col.getName(), col));
                    }
                } else {
                    for (int i = 0; i < amap.length; i++) {
                        Column col = ca.getColumn(amap[i]);
                        mcursor.addColumn(new Column(col.getName(), col));
                    }
                }
                mcursor.resolveColumns();
            } finally {
                ca.close();
                cb.close();
            }
        } catch (IOException e) {
            throw DbException.wrapThrowable(e);
        }
        return mcursor;
    }

    void checkCorresponding(Cursor ca, Cursor cb) throws SQLException {
        if (!corr) {
            if (ca.getColumnCount() != cb.getColumnCount()) {
                throw new SQLException(Op.toString(op) + " merge " +
                                   "operation, tables must have the " +
                                       "same number of columns", "42000");
            }
            amap = new int[ca.getColumnCount()];
            bmap = new int[amap.length];
            for (int i = 0; i < amap.length; i++) {
                amap[i] = bmap[i] = i+1;
            }
        } else if (columns == null) {
            // find the common columns for eg EXCEPT CORRESPONDING
            int cnt = 0;
            for (int i = 1; i <= ca.getColumnCount(); i++) {
                Column cola = ca.getColumn(i);
                Column colb = cb.getColumn(cola.getShortName());
                if (colb != null) {
                    cnt++;
                }
            }
            if (cnt == 0) {
                throw new SQLException(Op.toString(op) + " CORRESPONDING, " +
                                       "no common columns found", "42000");
            }
            amap = new int[cnt];
            bmap = new int[cnt];
            int p = 0;
            for (int i = 1; i <= ca.getColumnCount(); i++) {
                Column cola = ca.getColumn(i);
                Column colb = cb.getColumn(cola.getShortName());
                if (colb != null) {
                    amap[p] = cola.getColumn();
                    bmap[p] = colb.getColumn();
                    p++;
                }
            }
        } else {
            amap = new int[columns.size()];
            bmap = new int[amap.length];            
            
            for (int i = 0; i < columns.size(); i++) {
                String name = (String)columns.elementAt(i);
                Column cola = ca.getColumn(name);
                if (cola == null) {
                    throw new SQLException("Not found: " + name, "42000");
                }
                amap[i] = cola.getColumn();

                Column colb = cb.getColumn(name);
                if (colb == null) {
                    throw new SQLException("Not found: " + name, "42000");
                }
                bmap[i] = colb.getColumn();
            }
        }
    }

    public void invert() {
        throw new RuntimeException(
            "invert not implemented for MergeExpression");
    }

    public void readExternal(ObjectInput in)
        throws IOException, ClassNotFoundException
    {
        this.op = in.read();
        this.all = in.read() == 1;
        this.a = (TableExpression)in.readObject();
        this.b = (TableExpression)in.readObject();
        this.columns = (Vector)in.readObject();
        this.corr = in.read() == 1;
    }
    
    public void writeExternal(ObjectOutput out) throws IOException {
        out.write(op);
        out.write(all ? 1 : 0);
        out.writeObject(a);
        out.writeObject(b);
        out.writeObject(columns);
        out.write(corr ? 1 : 0);
    }

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

    public String toString() {
        StringBuffer sb = new StringBuffer(a.toString());
        sb.append(' ');
        sb.append(Op.toString(op));
        if (all) sb.append(" ALL");
        if (corr) {
            sb.append(" CORRESPONDING");
            if (columns != null) {
                sb.append(" BY (");
                for (int i = 0; i < columns.size(); i++) {
                    if (i > 0) sb.append(',');
                    sb.append(columns.get(i).toString());
                }
                sb.append(")");
            }
        }
        sb.append(' ');
        sb.append(b.toString());
        return sb.toString();
    }

    //#ifdef DEBUG
    public String name() {
        StringBuffer sb = new StringBuffer('(');
        sb.append(a.name());
        sb.append(' ');
        sb.append(Op.toString(op));
        sb.append(' ');
        sb.append(b.name());
        sb.append(')');
        return sb.toString();
    }
    //#endif
}