Quadcap Embeddable Database

com/quadcap/sql/TupleImpl.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.HashMap;
import java.util.Iterator;
import java.util.Vector;

import java.sql.SQLException;

import com.quadcap.sql.types.Type;

import com.quadcap.util.Debug;

/**
 * Base class for tuple implementations.
 *
 * @author Stan Bailes
 */
public class TupleImpl implements Tuple, Externalizable {
    protected String                    qual;
    protected String                    qualifier;
    protected Vector                    columns         = new Vector();
    protected HashMap                   names           = new HashMap();

    /**
     * Default constructor
     */
    public TupleImpl() {
        this.qualifier = "";
        this.qual = "";
    }

    /**
     * Named tuple constructor
     */
    public TupleImpl(String qualifier) {
        setName(qualifier);
    }

    /**
     * Set the tuple's name
     */
    public void setName(String name) {
        if (name == null) name = "";
        this.qualifier = name;
        if (qualifier.length() > 0) {
            this.qual = qualifier + ".";
        } else {
            this.qual = "";
        }
    }

    /**
     * Add, in order, the columns from the definition of tuple 't' to
     * the column list for this tuple.
     */
    public void addColumns(Session session, Tuple t) throws SQLException {
        addColumns(session, t, true);
    }

    /**
     * Add all the columns from the other tuple to this one.
     */
    public void addColumns(Session session, Tuple t, boolean resolve)
        throws SQLException
    {
        Connection conn = session.getConnection();
        boolean as = qual.length() > 0;
        for (int i = 1; i <= t.getColumnCount(); i++) {
            Column col = t.getColumn(i);
            String name = conn.resolveColname(col.getName(), this);
            //Debug.println("[" + getClass().getName() + "].addColumns " + i + ": " +
            //              col.getName() + "/" + col.getShortName() + "/" + name);
            Column ncol = new Column(name, col);
            if (col.isJoinColumn()) ncol.setJoinColumn(true);
            addColumn(ncol);
        }
        if (resolve) resolveColumns();
    }

    /**
     * Once all of the column names are available, we can look for duplicates
     * and shortest-unique names, etc.
     */
    public void resolveColumns() throws SQLException {
        for (int i = 1; i <= getColumnCount(); i++) {
            Column col = getColumn(i);
            String name = col.getName();
            for (int j = name.length() - 1; j > 0; j--) {
                if (name.charAt(j) == '.') {
                    String qname = name.substring(j+1);
                    Object obj = names.get(qname);
                    if (obj == col) {
                        col.setShortName(qname);
                        break;
                    }
                }
            }
        }
        //Debug.println("resolveColumns: " + this);
    }

    /**
     * addColumn helper
     */
    private final void addName(String name, Column col) {
        if (names.get(name) != null) {
            names.put(name, "duplicate");
        } else {
            names.put(name, col);
        }
    }

    /**
     * Return the number of columns in this tuple
     */
    public int getColumnCount() throws SQLException {
        return columns.size();
    }

    /**
     * Return the specified (one-based) column
     */
    public Column getColumn(int i) throws SQLException {
        return (Column)columns.elementAt(i-1);
    }

    /**
     * Return the column with the specified name/shortname
     */
    public Column getColumn(String name) throws SQLException {
        Column c = null;
        Object obj = names.get(name);
        if (obj != null && obj instanceof Column) {
            c = (Column)obj;
        }
        return c;
    }

    /**
     * Map the specified column names into an array of integer (one-based)
     * column indexes
     */
    public int[] mapColumns(Vector names) throws SQLException {
        int[] ret;
        if (names == null) {
            ret = new int[columns.size()];
            for (int i = 0; i < ret.length; i++) {
                ret[i] = i+1;
            }
        } else {
            ret = new int[names.size()];
            for (int i = 0; i < ret.length; i++) {
                String name = (String)names.elementAt(i);
                ret[i] = getColumnIndex(name);
                if (ret[i] <= 0) {
                    throw new SQLException("No such column: " + name, "42000");
                }
            }
        }
        return ret;
    }

    /**
     * Return the tuple's name
     */
    public String getName() { return qualifier; }

    /**
     * Find the first occurence of the '.' name separator in
     * the given SQL identifier string.
     */
    static int nextUnquotedPeriod(String s) {
        boolean q = false;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == '"') q = !q;
            if (!q && c == '.') return i;
        }
        return -1;
    }

    /**
     * Add a new column to the tuple
     */
    public void addColumn(Column col) throws SQLException {
        columns.addElement(col);
        col.setColumn(columns.size());
        col.setTable(this);
        String name = col.getName();
        addName(name, col);
        int idx = nextUnquotedPeriod(name);
        while (idx >= 0) {
            name = name.substring(idx+1);
            addName(name, col);
            idx = nextUnquotedPeriod(name);
        }
    }

    /**
     * Add a new column to the tuple in a specified position,
     * moving columns at that position and greater on position
     * to the right.
     */
    public void addColumn(Column col, int pos) throws SQLException {
        columns.addElement(col);
        int np = columns.size();
        while (np > pos) {
            Column col2 = (Column)columns.get(np-2);
            col2.setColumn(np);
            columns.set(np-1, col2);
            np--;
        }
        columns.set(pos-1, col);
        col.setColumn(pos);
        col.setTable(this);
        String name = col.getName();
        addName(name, col);
        int idx = nextUnquotedPeriod(name);
        while (idx >= 0) {
            name = name.substring(idx+1);
            addName(name, col);
            idx = nextUnquotedPeriod(name);
        }
    }

    /**
     * Add a column of the specified name and type to the tuple
     */
    public void addColumn(String name, Type type) throws SQLException {
        addColumn(new Column(name, type));
    }

    /**
     * Delete the specified column
     */
    public void deleteColumn(int col) throws SQLException, IOException {
        Column delCol = getColumn(col);
        int del = 0;
        for (int i = 1; i <= columns.size(); i++) {
            if (i == col) del++;
            else {
                Column cx = getColumn(i);
                cx.setColumn(i-del);
                columns.set(i-del-1, cx);
            }
        }
        columns.setSize(columns.size()-1);

        Iterator iter = names.keySet().iterator();
        while (iter.hasNext()) {
            String name = iter.next().toString();
            if (names.get(name) == delCol) iter.remove();
        }
    }

    /**
     * Return the (one-based) column index of the column with the
     * specified name
     */
    public int getColumnIndex(String name) throws SQLException {
        Column col = getColumn(name);
        if (col == null) {
            return -1;
        }
        return col.getColumn();
    }

    /**
     * Externalizable.readExternal(): Read me from a stream.
     */
    public void readExternal(ObjectInput in)
        throws IOException, ClassNotFoundException
    {
        qualifier = (String)in.readObject();
        if (qualifier.length() > 0) {
            this.qual = qualifier + ".";
        } else {
            this.qual = "";
        }
        Vector c = (Vector)in.readObject();
        this.columns = new Vector();
        this.names = new HashMap();
        for (int i = 0; i < c.size(); i++) {
            try {
                addColumn((Column)c.elementAt(i));
            } catch (SQLException e) {
                //#ifdef DEBUG
                Debug.print(e);
                //#endif
                throw new IOException(e.toString());
            }
        }
        try {
            resolveColumns();
        } catch (SQLException e) {
            //#ifdef DEBUG
            Debug.print(e);
            //#endif
            throw new IOException(e.toString());
        }
    }
    
    /**
     * Externalizable.writeExternal(): Write me to a stream.
     */
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(qualifier);
        out.writeObject(columns);
    }

    //#ifdef DEBUG
    /**
     * Return a string representation for debugging
     */
    public String toString() {
        try {
            StringBuffer sb = new StringBuffer(
                Table.strip(getClass().getName()));
            sb.append(" ");
            sb.append(qualifier);
            sb.append("\n");
            for (int i = 1; i <= getColumnCount(); i++) {
                Column c = getColumn(i);
                if (i > 1) sb.append("\n");
                sb.append("   col " + i + ": ");
                sb.append(c.toString());
            }
            sb.append("\n");
            //sb.append(names.toString());
            return sb.toString();
        } catch (Exception e) {
            Debug.print(e);
            return e.toString();
        }
    }
    //#endif

}