Quadcap Embeddable Database

com/quadcap/sql/Analyze.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.sql.SQLException;

import com.quadcap.sql.types.Op;

import com.quadcap.util.Debug;

/**
 * Join planner.
 *
 * @author Stan Bailes
 */
public class Analyze {
    Session                             session;
    Expression                          expr;
    BinaryExpression                    b               = null;
    NameExpression                      n               = null;
    ValueExpression                     v               = null;
    //#ifdef DEBUG
    String                              prefix          = "";
    //#endif

    public Analyze(Session session, Expression expr) {
        this.session = session;
        this.expr = expr;
        if (expr instanceof BinaryExpression) b = (BinaryExpression)expr;
        if (expr instanceof NameExpression) n = (NameExpression)expr;
        if (expr instanceof ValueExpression) v = (ValueExpression)expr;
    }

    public void getConjunctives(Vector v) {
        if (b != null) {
            if (b.not) {
                // XXX could get fancy and try to DeMorgan'ize it.
                v.addElement(expr);
            } else {
                if (b.op == Op.AND) {
                    analyze(b.e).getConjunctives(v);
                    analyze(b.f).getConjunctives(v);
                } else {
                    v.addElement(expr);
                }
            }
        } else {
            v.addElement(expr);
        }
    }

    public boolean isConstant() {
        return expr instanceof ValueExpression;
    }

    public boolean isName() {
        return n != null;
    }

    public boolean refersTo(Tuple table) throws SQLException {
        boolean ret = false;
        if (n != null) {
            if (table.getColumn(n.name) != null) ret = true;
        }
        return ret;
    }

    public Analyze analyze(Expression e) {
        Analyze z = new Analyze(session, e);
        //#ifdef DEBUG
        z.prefix = prefix + "    ";
        //#endif
        return z;
    }    

    public boolean isConstantCompareToTable(Tuple table) throws SQLException {
        boolean ret = false;
        if (b != null) {
            Analyze be = analyze(b.e);
            Analyze bf = analyze(b.f);
            if (be.isConstant()) {
                if (bf.refersTo(table)) {
                    ret = true;
                }
            } else if (bf.isConstant()) {
                if (be.refersTo(table)) {
                    ret = true;
                }
            }
        }
        //Debug.println("Analyze[" + expr + "].isConstantCompareToTable(" +
        //              table.getName() + ") = " + ret);
        return ret;
    }

    public boolean isTermOrConstant(Tuple table) throws SQLException {
        boolean ret = false;
        if (n != null) {
            ret = refersTo(table);
        } else if (b != null) {
            Analyze be = analyze(b.e);
            Analyze bf = analyze(b.f);
            ret = be.isTermOrConstant(table) && bf.isTermOrConstant(table);
        } else if (v != null) {
            ret = true;
        }
        return ret;
    }

    public int[][] getJoinColumns(Cursor ca, Cursor cb) throws SQLException {
        Vector vec = new Vector();
        Vector aCols = new Vector();
        Vector bCols = new Vector();
        int cnt = 0;
        int[][] ret = null;
        getConjunctives(vec);
        for (int i = 0; i < vec.size(); i++) {
            Expression ei = (Expression)vec.elementAt(i);
            if (analyze(ei).isJoinColumn(ca, aCols, cb, bCols)) {
                cnt++;
            }
        }
        if (cnt > 0) {
            ret = new int[2][cnt];
            for (int i = 0; i < cnt; i++) {
                ret[0][i] = ((Column)aCols.elementAt(i)).getColumn();
                ret[1][i] = ((Column)bCols.elementAt(i)).getColumn();
            }
        }
        return ret;
    }

    boolean isJoinColumn(Cursor ca, Vector aCols, Cursor cb, Vector bCols) 
        throws SQLException 
    {
        if (b == null) return false;
        if (b.op != Op.EQ) return false;
        if (!(b.e instanceof NameExpression)) return false;
        String ename = ((NameExpression)b.e).name;
        if (!(b.f instanceof NameExpression)) return false;
        String fname = ((NameExpression)b.f).name;
        Column cea = ca.getColumn(ename);
        if (cea != null) {
            Column cfb = cb.getColumn(fname);
            if (cfb != null) {
                aCols.addElement(cea);
                bCols.addElement(cfb);
                return true;
            }
        }
        Column ceb = cb.getColumn(ename);
        if (ceb != null) {
            Column cfa = ca.getColumn(fname);
            if (cfa != null) {
                aCols.addElement(cfa);
                bCols.addElement(ceb);
                return true;
            }
        }
        return false;
    }

    public Expression factorTable(Tuple table) throws SQLException {
        Expression ret = null;
        if (table != null) {
            Vector vec = new Vector();
            getConjunctives(vec);
            for (int i = 0; i < vec.size(); i++) {
                Expression ei = (Expression)vec.elementAt(i);
                if (analyze(ei).isTermOrConstant(table)) {
                    if (ret == null) {
                        ret = ei;
                    } else {
                        ret = new BinaryExpression(Op.AND, ret, ei);
                    }
                }
            }
        }
//          Debug.println("Analyze[" + expr + "].factorTable(" +
//                        (table == null ? "null" : table.getName()) + ") => " +
//                        ret);
        return ret;
        
    }

    public boolean isJoinExpression(Tuple c) throws SQLException {
        boolean ret = false;
        if (isConstant()) {
            ret = true;
        } else if (n != null) {
            if (c.getColumn(n.name) != null) ret = true;
        } else if (b != null) {
            if (analyze(b.e).isJoinExpression(c) &&
                analyze(b.f).isJoinExpression(c)) ret = true;
        }
        return ret;
    }

    public Expression factorJoinExpression(Tuple c) throws SQLException {
        Expression ret = null;
        Vector vec = new Vector();
        getConjunctives(vec);
        for (int i = 0; i < vec.size(); i++) {
            Expression ei = (Expression)vec.elementAt(i);
            if (analyze(ei).isJoinExpression(c)) {
                if (ret == null) {
                    ret = ei;
                } else {
                    ret = new BinaryExpression(Op.AND, ret, ei);
                }
            }
        }
        return ret;
    }

    //#ifdef DEBUG
    public String toString() {
        return prefix + "Analyze[" + expr + "]";
    }
    //#endif
}