Quadcap Embeddable Database

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

import java.util.Hashtable;
import java.util.Vector;

import java.sql.ResultSetMetaData;
import java.sql.SQLException;

import com.quadcap.sql.index.Btree;

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

import com.quadcap.util.Debug;

/**
 * A SQL <b>VIEW</b>.
 *
 * @author Stan Bailes
 */
public class View extends TupleImpl implements Relation, Externalizable {
    Vector                      viewColumns;
    TableExpression             select;

    static final int            NOCHECK         = -1;
    static final int            CASCADED        = 0;
    static final int            LOCAL           = 1;
    
    int                         check;

    /**
     * Default constructor
     */
    public View() {}

    /**
     * Explicit constructor from name, columns, select expression,
     * VIEW CHECK state
     */
    public View(String name, Vector columns, TableExpression select,
                int check)
    {
        super(name);
        this.viewColumns = columns;
        this.select = select;
        this.check = check;
    }

    /**
     * Lazy build the view's columns list
     */
    public void addColumns(Session session) throws SQLException {
        if (columns.size() == 0) {
            Cursor c = getCursor(session, null,  null, null);
            try {
                addColumns(session, c);
            } finally {
                c.close();
            }
        }
    }

    /**
     * Check a base row to see if it's contained in the view
     */
    public void checkRow(Session session, Cursor cursor, Row row) throws SQLException {
        if ((check != NOCHECK || session.getViewCheck())
            && select.isUpdatable()) {
            session.setViewCheck();
            StaticCursor s = new StaticCursor(session, this, row);
            s.next();
            Expression w = select.getWhere();
            if (w != null) {
                Value v = w.getValue(session, s);
                if (v instanceof ValueBoolean && ((ValueBoolean)v).isTrue()) {
                    // ok
                } else {
                    throw new SQLException("View check option violation", "44000");
                }
            }
        }
    }

    /**
     * Externalizable.readExternal(): Read me from a stream.
     */
    public void readExternal(ObjectInput in)
        throws IOException, ClassNotFoundException
    {
        super.readExternal(in);
        this.viewColumns = (Vector)in.readObject();
        this.select = (TableExpression)in.readObject();
        this.check = in.readInt();
    }
    
    /**
     * Externalizable.writeExternal(): Write me to a stream.
     */
    public void writeExternal(ObjectOutput out) throws IOException {
        super.writeExternal(out);
        out.writeObject(viewColumns);
        out.writeObject(select);
        out.writeInt(check);
    }

    /**
     * Get the view's cursor
     */
    public Cursor getCursor(Session session, Expression where,
                            String asName, Cursor cursor)
        throws SQLException
    {
        Cursor c = select.getCursor(session, cursor);

        String qualName = asName;
        if (qualName == null) qualName = getName();
        String qPrefix = qualName;
        if (qPrefix.length() > 0) qPrefix = qPrefix + ".";

        Vector cols = viewColumns;
        if (cols == null) {
            cols = new Vector();
            Hashtable t = new Hashtable();
            for (int i = 1; i <= c.getColumnCount(); i++) {
                String name = c.getColumn(i).getName();
                int idx = name.lastIndexOf('.');
                if (idx >= 0) name = name.substring(idx+1);
                name = qPrefix + name;
                if (t.get(name) != null) {
                    throw new SQLException(
                        "A view column list must be specified if multiple " +
                        "columns have the same name: " + name, "42000");
                }
                cols.addElement(name);
                t.put(name, name);
            }
        } else {
            cols = new Vector();
            for (int i = 0; i < viewColumns.size(); i++) {
                cols.addElement(qPrefix + viewColumns.elementAt(i).toString());
            }
        }
        c = new ViewCursor(session, this, c, cols);
        return c;
    }

    public void insertRow(Session session, Row row)
        throws SQLException, IOException
    {
        Cursor c = getCursor(session, null, null, null);
        try {
            session.clearViewCheck();
            c.insertRow(row);
        } finally {
            c.close();
        }
    }

    public boolean isUpdatable() {
        return select.isUpdatable();
    }

    public boolean hasBlobs() {
        return false; // XXX test insert into view with blobs.
    }
        
    public Vector getBaseTables() {
        Vector v = new Vector();
        select.getBaseTables(v);
        return v;
    }

    public Expression getViewExpression() {
        return select;
    }

    public String getType() { return "VIEW"; }

    public void delete(Session session) {}

    public String toString() {
        StringBuffer sb = new StringBuffer("VIEW ");
        sb.append(getName());
        if (columns != null) {
            sb.append('(');
            for (int i = 0; i < columns.size(); i++) {
                if (i > 0) sb.append(',');
                Column col = (Column)columns.get(i);
                sb.append(col.getShortName());
            }
            sb.append(')');
        }
        sb.append(" AS ");
        sb.append(select.toString());
        return sb.toString();
    }
    
}