Quadcap Embeddable Database

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

import java.io.IOException;

import java.sql.SQLException;

import com.quadcap.sql.types.Value;
import com.quadcap.sql.types.ValueDefault;
import com.quadcap.sql.types.ValueNull;


/**
 * Implementation of the SQL <b>INSERT</b> statement. 
 *
 * @author Stan Bailes
 */

public class StmtInsert implements Stmt {
    String                      tableName;
    Vector                      columns;
    Expression                  values;

    boolean                     defaultValues           = false;
    VectorExpression            ve                      = null;
    Row                         tempRow                 = null;

    Relation          table        = null;

    public StmtInsert() {}
    
    public StmtInsert(String tableName) {
        this.tableName = tableName;
    }

    public void setDefaultValue() {
        this.defaultValues = true;
    }

    public void setColumns(Vector v) {
        this.columns = v;
    }

    public void setValues(Expression e) {
        this.values = e;
    }

    final Value getDefault(Session session, Cursor cursor, Column c)
        throws SQLException 
    {
        Value dflt = ValueNull.valueNull;
        Expression e = c.getDefault();
        if (e != null) {
            dflt = e.getValue(session, cursor);
        }
        return dflt;
    }

    public void setVrow(Session session, VectorExpression ve)
        throws IOException, SQLException
    {
        if (ve.size() != tempRow.size()) {
            throw new SQLException("Incorrect number of columns: " +
                                   ve.size() +
                                   "; expecting " +
                                   tempRow.size());
        }
        for (int col = 1; col <= tempRow.size(); col++) {
            Value v = ve.get(col-1).getValue(session, null);
            if (v instanceof ValueDefault) {
                Column c = table.getColumn(col);
                v = getDefault(session, null, c);
            }
            tempRow.set(col, v);
        }
        table.insertRow(session, tempRow);
    }

    public void execute(Session session) throws IOException, SQLException {
        Database db = session.getDatabase();
        if (table == null) {
            table = db.getRelation(tableName);
            if (table == null) {
                throw new SQLException("No table: " + tableName, "42000");
            }
        }
        if (columns == null) {
            if (ve != null || values instanceof VectorExpression) {
                // we can do something optimal here....
                if (ve == null) ve = (VectorExpression)values;
                if (tempRow == null) tempRow = new Row(table.getColumnCount());
                if (ve.rank() == 1) {
                    setVrow(session, ve);
                    return;
                } else if (ve.rank() == 2) {
                    for (int row = 0; row < ve.size(); row++) {
                        VectorExpression vr = (VectorExpression)ve.get(row);
                        setVrow(session, vr);
                    }
                    return;
                }
            }
        }

        // less-than-optimal but full-featured insert implementation
        Cursor cursor = null;
        if (values != null) {
            cursor = values.getCursor(session, null);
        }

        if (isSelfInsert()) {
            DistinctCursor dc = new DistinctCursor(session, cursor);
            dc.setDistinct(false);
            cursor = dc;
        }
        try {
            if (defaultValues) {
                if (tempRow == null) tempRow = new Row(table.getColumnCount());
                for (int col = 1; col <= tempRow.size(); col++) {
                    Column c = table.getColumn(col);
                    Value dflt = getDefault(session, cursor, c);
                    tempRow.set(col, dflt);
                }
                table.insertRow(session, tempRow);
            } else if (columns == null) {
                if (cursor.getColumnCount() != table.getColumnCount()) {
                    throw new SQLException("Incorrect number of columns: " +
                                           cursor.getColumnCount() +
                                           "; expecting " +
                                           table.getColumnCount());
                }
                if (cursor instanceof StaticCursor) {
                    // XXX is this right?  Can defaults show up in other
                    // XXX cursor types?
                    while (cursor.next()) {
                        Row r = cursor.getRow();
                        for (int i = 1; i <= r.size(); i++) {
                            Value v = r.item(i);
                            if (v instanceof ValueDefault) {
                                Column c = table.getColumn(i);
                                v = getDefault(session, cursor, c);
                                r.set(i, v);
                            }
                        }
                        table.insertRow(session, r);
                    }
                } else if (table.hasBlobs()) {
                    // We may have to passivate the blobs, but it's possible
                    // that the rows that we get back aren't updateable
                    // (e.g., insert into TAB select from TAB2, TAB3)
                    if (tempRow == null) {
                        tempRow = new Row(table.getColumnCount());
                    }
                    while (cursor.next()) {
                        Row r = cursor.getRow();
                        for (int i = 1; i <= table.getColumnCount(); i++) {
                            tempRow.set(i, r.item(i));
                        }
                        table.insertRow(session, tempRow);
                    }
                } else {
                    while (cursor.next()) {
                        Row r = cursor.getRow();
                        table.insertRow(session, r);
                    }
                }
            } else {
                if (tempRow == null) {
                    tempRow = new Row(table.getColumnCount());
                }
                int[] map = table.mapColumns(columns);
                int[] nmap = null;
                // make a map to quickly find columns that need defaults
                if (map.length < table.getColumnCount()) {
                    int[] cmap = new int[table.getColumnCount()];
                    for (int i = 0; i < map.length; i++) {
                        cmap[map[i]-1] = 1;
                    }
                    nmap = new int[cmap.length - map.length];
                    int ncnt = 0;
                    for (int i = 0; i < cmap.length; i++) {
                        if (cmap[i] == 0) {
                            nmap[ncnt++] = i+1;
                        }
                    }
                }
                while (cursor.next()) {
                    Row row = cursor.getRow();
                    for (int i = 0; i < map.length; i++) {
                        Value v = row.item(i+1);
                        if (v instanceof ValueDefault) {
                            Column c = table.getColumn(map[i]);
                            v = getDefault(session, cursor, c);
                        }
                        tempRow.set(map[i], v);
                    }
                    if (nmap != null) {
                        // fill in null/default values
                        for (int i = 0; i < nmap.length; i++) {
                            int col = nmap[i];
                            Column c = table.getColumn(col);
                            Value dflt = getDefault(session, cursor, c);
                            tempRow.set(col, dflt);
                        }
                    }
                    table.insertRow(session, tempRow);
                }
            }
        } finally {
            if (cursor != null) cursor.close();
        }
    }

    class IsSelfInsert implements ExpressionVisitor {
        boolean                 isit = false;

        public void visit(Expression sub) {
            if (!isit) {
                if (sub instanceof SelectExpression) {
                    Vector v = new Vector();
                    SelectExpression se = (SelectExpression)sub;
                    se.getBaseTables(v);
                    for (int i = 0; !isit && i < v.size(); i++) {
                        String name = v.get(i).toString();
                        isit = name.equalsIgnoreCase(tableName);
                    }
                } else {
                    sub.visitSubExpressions(this);
                }
            }
        }
    }

    boolean isSelfInsert() {
        boolean ret = false;
        if (values != null) {
            IsSelfInsert is = new IsSelfInsert();
            is.visit(values);
            ret = is.isit;
        }
        return ret;
    }
}