Quadcap Embeddable Database

com/quadcap/sql/meta/MetaCursor.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;

//-//#ifdef JDK11
//-import com.sun.java.util.collections.Vector;
//#else
import java.util.Vector;
//#endif

import java.sql.ResultSet;
import java.sql.SQLException;

import com.quadcap.sql.Column;
import com.quadcap.sql.Cursor;
import com.quadcap.sql.Database;
import com.quadcap.sql.Expression;
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.types.*;

import com.quadcap.util.Debug;

/**
 * Base class for all cursors used in this package.
 *
 * @author Stan Bailes
 */
public class MetaCursor extends StaticCursor {
    static TypeVarChar          typeString      = new TypeVarChar(-1);
    static TypeInt              typeInt         = new TypeInt();
    static TypeSmallInt         typeShort       = new TypeSmallInt();
    static TypeAny              typeAny         = new TypeAny();
    static TypeBinary           typeBinary      = new TypeBinary(1);
    
    StaticCursor                sc;
    Expression                  predicate;

    /**
     * Constructor for a typical meta cursor with a predicate
     */
    public MetaCursor(Session session, Expression predicate)
        throws SQLException
    {
        super(session, new Vector());
        try {
            session.getTableWriteLock("#Schema");
        } catch (IOException e) {
            throw new SQLException(e.toString());
        }
        this.session = session;
        this.predicate = predicate;
        Vector vec = new Vector();
        vec.addElement(null);
        sc = new StaticCursor(session, vec);
    }
    
    /**
     * Constructor for empty metacursor
     */
    public static MetaCursor create(Session session, Column[] cols)
        throws SQLException {
        MetaCursor c = new MetaCursor(session, null);
        c.addColumns(cols);
        return c;
    }

    /**
     * Matcher function (compare the row against the supplied predicate)
     */
    boolean rowMatch(Row row) throws SQLException {
        if (predicate == null) return true;
        sc.updateRow(0, row);
        sc.absolute(1);
        Value v = predicate.getValue(session, sc);
        return (v instanceof ValueBoolean && ((ValueBoolean)v).isTrue());
    }

    /**
     * Add a list of columns
     */
    void addColumns(Column[] cols) throws SQLException {
        for (int i = 0; i < cols.length; i++) {
            addColumn(cols[i]);
            sc.addColumn(cols[i]);
        }
    }

    /**
     * Break down schema and table name into adjacent columns in the
     * result set
     */
    void doTableName(int col, Row row, String name) throws SQLException {
        int idx = name.indexOf('.');
        if (idx > 0) {
            row.set(col, new ValueString(name.substring(0, idx)));
            row.set(col+1, new ValueString(name.substring(idx+1)));
        } else {
            row.set(col, new ValueString(""));
            row.set(col+1, new ValueString(name));
        }
    }

    static Column[] cColumnPrivileges = {
        new Column("TABLE_CAT", typeString),                    // 1
        new Column("TABLE_SCHEM", typeString),                  // 2
        new Column("TABLE_NAME", typeString),                   // 3
        new Column("COLUMN_NAME", typeString),                  // 4
        new Column("GRANTOR", typeString),                      // 5
        new Column("GRANTEE", typeString),                      // 6
        new Column("PRIVILEGE", typeString),                    // 7
        new Column("IS_GRANTABLE", typeString)                  // 8
    };
    
    static Column[] cCatalogs = {
        new Column("TABLE_CAT", typeString)                     // 1
    };
    
    static Column[] cProcedureColumns = {
        new Column("PROCEDURE_CAT", typeString),                // 1
        new Column("PROCEDURE_SCHEM", typeString),              // 2
        new Column("PROCEDURE_NAME", typeString),               // 3
        new Column("COLUMN_NAME", typeString),                  // 4
        new Column("COLUMN_TYPE", typeShort),                   // 5
        new Column("DATA_TYPE", typeShort),                     // 6
        new Column("TYPE_NAME", typeString),                    // 7
        new Column("PRECISION", typeInt),                       // 8
        new Column("LENGTH", typeInt),                          // 9
        new Column("SCALE", typeShort),                         // 10
        new Column("RADIX", typeInt),                           // 11
        new Column("NULLABLE", typeShort),                      // 12
        new Column("REMARKS", typeString),                      // 13
    };

    static Column[] cProcedures = {
        new Column("PROCEDURE_CAT", typeString),                // 1
        new Column("PROCEDURE_SCHEM", typeString),              // 2
        new Column("PROCEDURE_NAME", typeString),               // 3
        new Column("reserved1", typeString),                    // 4
        new Column("reserved2", typeString),                    // 5
        new Column("reserved3", typeString),                    // 6
        new Column("REMARKS", typeString),                      // 7
        new Column("PROCEDURE_TYPE", typeShort)                 // 8 
    };

    static Column[] cTablePrivileges = {
        new Column("TABLE_CAT", typeString),                    // 1
        new Column("TABLE_SCHEM", typeString),                  // 2
        new Column("TABLE_NAME", typeString),                   // 3
        new Column("GRANTOR", typeString),                      // 4
        new Column("GRANTEE", typeString),                      // 5
        new Column("PRIVILEGE", typeString),                    // 6
        new Column("IS_GRANTABLE", typeString)                  // 7
    };

    static Column[] cUdts= {
        new Column("TYPE_CAT", typeString),                     // 1
        new Column("TYPE_SCHEM", typeString),                   // 2
        new Column("TYPE_NAME", typeString),                    // 3
        new Column("CLASS_NAME", typeString),                   // 4
        new Column("DATA_TYPE", typeShort),                     // 5
        new Column("REMARKS", typeString)                       // 6
    };
    
    static Column[] cVersionColumns = {
        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", typeInt),                   // 6
        new Column("DECIMAL_DIGITS", typeInt),                  // 7
        new Column("PSEUDO_COLUMN", typeShort)                  // 8
    };

    /**
     * Information schema
     */
    public static Cursor find(Session session, String name)
        throws SQLException
    {
        if (name.equalsIgnoreCase("SYSTEM.CATALOGS")) {
            return create(session, cCatalogs);
        } else if (name.equalsIgnoreCase("SYSTEM.COLUMNS")) {
            return new MetaColumns(session, null);
        } else if (name.equalsIgnoreCase("SYSTEM.COLUMNPRIVILEGES")) {
            return create(session, cColumnPrivileges);
        } else if (name.equalsIgnoreCase("SYSTEM.CROSSREFERENCE")) {
            return new MetaCrossReference(session, null);
        } else if (name.equalsIgnoreCase("SYSTEM.INDEXINFO")) {
            return new MetaIndexInfo(session, null);
        } else if (name.equalsIgnoreCase("SYSTEM.PRIMARYKEYS")) {
            return new MetaPrimaryKeys(session, null);
        } else if (name.equalsIgnoreCase("SYSTEM.PROCEDURECOLUMNS")) {
            return create(session, cProcedureColumns);
        } else if (name.equalsIgnoreCase("SYSTEM.PROCEDURES")) {
            return create(session, cProcedures);
        } else if (name.equalsIgnoreCase("SYSTEM.SCHEMAS")) {
            return new MetaSchemas(session);
        } else if (name.equalsIgnoreCase("SYSTEM.TABLES")) {
            return new MetaTables(session, null);
        } else if (name.equalsIgnoreCase("SYSTEM.TABLEPRIVILEGES")) {
            return create(session, cTablePrivileges);
        } else if (name.equalsIgnoreCase("SYSTEM.TABLETYPES")) {
            return new MetaTableTypes(session);
        } else if (name.equalsIgnoreCase("SYSTEM.VERSIONCOLUMNS")) {
            return create(session, cVersionColumns);
        } else if (name.equalsIgnoreCase("SYSTEM.TYPEINFO")) {
            return new MetaTypes(session);
        } else if (name.equalsIgnoreCase("SYSTEM.UDTS")) {
            return create(session, cUdts);
        }
        return null;
    }
}