Quadcap Embeddable Database

com/quadcap/sql/meta/MetaBestRowId.java

Go to the documentation of this file.

package com.quadcap.sql.meta;

/* 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.util.Enumeration;
import java.util.Vector;

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

import com.quadcap.sql.Column;
import com.quadcap.sql.Constraint;
import com.quadcap.sql.Database;
import com.quadcap.sql.Expression;
import com.quadcap.sql.PrimaryKeyConstraint;
import com.quadcap.sql.Relation;
import com.quadcap.sql.Row;
import com.quadcap.sql.Session;
import com.quadcap.sql.StaticCursor;
import com.quadcap.sql.Table;
import com.quadcap.sql.UniqueConstraint;

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

import com.quadcap.sql.types.*;

import com.quadcap.util.Debug;

/**
 * A Cursor supporting the <code>DatabaseMetaData.getBestRowId()</code>
 * operation.
 *
 * @author Stan Bailes
 */
public class MetaBestRowId extends MetaCursor {
    static Column[] cols = {
        new Column("SCOPE", typeShort),                 // 1
        new Column("COLUMN_NAME", typeString),          // 2
        new Column("DATA_TYPE", typeShort),             // 3
        new Column("TYPE_NAME", typeString),            // 4
        new Column("COLUMN_SIZE", typeInt),             // 5
        new Column("BUFFER_LENGTH", typeAny),           // 6
        new Column("DECIMAL_DIGITS", typeInt),          // 7
        new Column("PSEUDO_COLUMN", typeShort)          // 8
    };

    static int[] sortColumns = { 2 };

    /**
     * The constructor for this meta cursor finds the "best" index
     * to use for this table, purely based on the index type
     * (and possibly the 'nullable' flag).  We don't do anything with
     * scope -- best is best for us.
     */
    public MetaBestRowId(Session session, String tableName, int scope,
                         boolean nullable)
        throws SQLException
    {
        super(session, null);
        try {
            addColumns(cols);
            Database db = session.getDatabase();
            session.getTableWriteLock("#Schema");
            tableName = tableName.toUpperCase();
            Table t = (Table)db.getRelation(tableName);
            if (t != null) {
                UniqueConstraint uc = null;
                int num = t.getNumConstraints();
                for (int i = 0; i < num; i++) {
                    Constraint c = t.getConstraint(i);
                    if (c instanceof UniqueConstraint) {
                        if (nullable || checkNullable(c)) {
                            uc = (UniqueConstraint)c;
                            if (c instanceof PrimaryKeyConstraint) break;
                        }
                    }
                }
                if (uc != null) {
                    int cnt = uc.getColumnCount();
                    for (int i = 0; i < cnt; i++) {
                        addRow(doColumn(uc.getColumn(i)));
                    }
                }
            }
            sort();
        } catch (ValueException e) {
            Debug.print(e);
            SQLException te = new SQLException(e.toString(), "Q000J");
            te.setNextException(e);
            throw te;
        } catch (IOException e) {
            Debug.print(e);
            throw new SQLException(e.toString(), "Q000K");
        }           
    }

    /**
     * Sort by name, I guess...
     */
    public int[] getSortColumns() {
        return sortColumns;
    }

    /**
     * Do any of the columns in this constraint allow nulls?
     */
    public boolean checkNullable(Constraint c) throws SQLException {
        boolean ret = !(c instanceof PrimaryKeyConstraint);
        int cnt = c.getColumnCount();
        for (int i = 0; ret && i < cnt; i++) {
            ret = c.getColumn(i).isNullable();
        }
        return ret;
    }

    /**
     * Add one cursor row to describe the specified column.
     */
    Row doColumn(Column col) throws SQLException {
        Type type = col.getType();
        Row row = new Row(18);
        row.set(1, new ValueShort(DatabaseMetaData.bestRowSession));
        row.set(2, new ValueString(col.getShortName()));
        row.set(3, new ValueShort(type.getJDBCType()));
        row.set(4, new ValueString(type.getTypeName()));

        Value size = new ValueInteger(type.getPrecision());
        if (type instanceof TypeChar) {
            size = new ValueInteger(((TypeChar)type).getMax());
        } else if (type instanceof TypeVarChar) {
            size = new ValueInteger(((TypeVarChar)type).getMax());
        } 
        row.set(5, size);
        row.set(6, ValueNull.valueNull);
        row.set(7, new ValueShort(type.getScale()));
        row.set(8, new ValueShort(DatabaseMetaData.bestRowUnknown));
        return row;
    }
}