expression.java

Java写的含有一个jdbc驱动的小型数据库数据库引擎

	    break;

	case NOT:

	case EQUAL:

	case BIGGER_EQUAL:

	case BIGGER:

	case SMALLER:

	case SMALLER_EQUAL:

	case NOT_EQUAL:

	case LIKE:

	case AND:

	case OR:

	case IN:

	case EXISTS:
	    iDataType = Column.BIT;

	    break;

	case COUNT:
	    iDataType = Column.INTEGER;

	    break;

	case MAX:

	case MIN:

	case SUM:

	case AVG:
	    iDataType = eArg.iDataType;

	    break;

	case CONVERT:

	    // it is already set
	    break;

	case IFNULL:

	case CASEWHEN:
	    iDataType = eArg2.iDataType;

	    break;
	}
    }

    /**
     * Method declaration
     *
     *
     * @return
     */
    boolean isResolved() {
	if (iType == VALUE) {
	    return true;
	}

	if (iType == COLUMN) {
	    return tFilter != null;
	}

	// todo: could recurse here, but never miss a 'false'!
	return false;
    }

    /**
     * Method declaration
     *
     *
     * @param i
     *
     * @return
     */
    static boolean isCompare(int i) {
	switch (i) {

	case EQUAL:

	case BIGGER_EQUAL:

	case BIGGER:

	case SMALLER:

	case SMALLER_EQUAL:

	case NOT_EQUAL:
	    return true;
	}

	return false;
    }

    /**
     * Method declaration
     *
     *
     * @return
     */
    String getTableName() {
	if (iType == ASTERIX) {
	    return sTable;
	}

	if (iType == COLUMN) {
	    if (tFilter == null) {
		return sTable;
	    } else {
		return tFilter.getTable().getName();
	    }
	}

	// todo
	return "";
    }

    /**
     * Method declaration
     *
     *
     * @return
     */
    String getColumnName() {
	if (iType == COLUMN) {
	    if (tFilter == null) {
		return sColumn;
	    } else {
		return tFilter.getTable().getColumnName(iColumn);
	    }
	}

	return getAlias();
    }

    /**
     * Method declaration
     *
     *
     * @throws SQLException
     */
    void swapCondition() throws SQLException {
	int i = EQUAL;

	switch (iType) {

	case BIGGER_EQUAL:
	    i = SMALLER_EQUAL;

	    break;

	case SMALLER_EQUAL:
	    i = BIGGER_EQUAL;

	    break;

	case SMALLER:
	    i = BIGGER;

	    break;

	case BIGGER:
	    i = SMALLER;

	    break;

	case EQUAL:
	    break;

	default:
	    Trace.assert(false, "Expression.swapCondition");
	}

	iType = i;

	Expression e = eArg;

	eArg = eArg2;
	eArg2 = e;
    }

    /**
     * Method declaration
     *
     *
     * @param type
     *
     * @return
     *
     * @throws SQLException
     */
    Object getValue(int type) throws SQLException {
	Object o = getValue();

	if (o == null || iDataType == type) {
	    return o;
	}

	String s = Column.convertObject(o);

	return Column.convertString(s, type);
    }

    /**
     * Method declaration
     *
     *
     * @return
     */
    int getDataType() {
	return iDataType;
    }

    /**
     * Method declaration
     *
     *
     * @return
     *
     * @throws SQLException
     */
    Object getValue() throws SQLException {
	switch (iType) {

	case VALUE:
	    return oData;

	case COLUMN:
	    try {
		return tFilter.oCurrentData[iColumn];
	    } catch (NullPointerException e) {
		throw Trace.error(Trace.COLUMN_NOT_FOUND, sColumn);
	    }

	case FUNCTION:
	    return fFunction.getValue();

	case QUERY:
	    return sSelect.getValue(iDataType);

	case NEGATE:
	    return Column.negate(eArg.getValue(iDataType), iDataType);

	case COUNT:

	    // count(*): sum(1); count(col): sum(col<>null)
	    if (eArg.iType == ASTERIX || eArg.getValue() != null) {
		return new Integer(1);
	    }

	    return new Integer(0);

	case MAX:

	case MIN:

	case SUM:

	case AVG:
	    return eArg.getValue();

	case EXISTS:
	    return new Boolean(test());

	case CONVERT:
	    return eArg.getValue(iDataType);

	case CASEWHEN:
	    if (eArg.test()) {
		return eArg2.eArg.getValue();
	    } else {
		return eArg2.eArg2.getValue();
	    }
	}

	// todo: simplify this
	Object a = null, b = null;

	if (eArg != null) {
	    a = eArg.getValue(iDataType);
	}

	if (eArg2 != null) {
	    b = eArg2.getValue(iDataType);
	}

	switch (iType) {

	case ADD:
	    return Column.add(a, b, iDataType);

	case SUBTRACT:
	    return Column.subtract(a, b, iDataType);

	case MULTIPLY:
	    return Column.multiply(a, b, iDataType);

	case DIVIDE:
	    return Column.divide(a, b, iDataType);

	case CONCAT:
	    return Column.concat(a, b);

	case IFNULL:
	    return a == null ? b : a;

	default:

	    // must be comparisation
	    // todo: make sure it is
	    return new Boolean(test());
	}
    }

    /**
     * Method declaration
     *
     *
     * @param o
     * @param datatype
     *
     * @return
     *
     * @throws SQLException
     */
    private boolean testValueList(Object o,
				  int datatype) throws SQLException {
	if (iType == VALUELIST) {
	    if (datatype != iDataType) {
		o = Column.convertObject(o, iDataType);
	    }

	    return hList.containsKey(o);
	} else if (iType == QUERY) {

	    // todo: convert to valuelist before if everything is resolvable
	    Result r = sSelect.getResult(0);
	    Record n = r.rRoot;
	    int    type = r.iType[0];

	    if (datatype != type) {
		o = Column.convertObject(o, type);
	    }

	    while (n != null) {
		Object o2 = n.data[0];

		if (o2 != null && o2.equals(o)) {
		    return true;
		}

		n = n.next;
	    }

	    return false;
	}

	throw Trace.error(Trace.WRONG_DATA_TYPE);
    }

    /**
     * Method declaration
     *
     *
     * @return
     *
     * @throws SQLException
     */
    boolean test() throws SQLException {
	switch (iType) {

	case TRUE:
	    return true;

	case NOT:
	    Trace.assert(eArg2 == null, "Expression.test");

	    return !eArg.test();

	case AND:
	    return eArg.test() && eArg2.test();

	case OR:
	    return eArg.test() || eArg2.test();

	case LIKE:

	    // todo: now for all tests a new 'like' object required!
	    String s = (String) eArg2.getValue(Column.VARCHAR);
	    int    type = eArg.iDataType;
	    Like   l = new Like(s, cLikeEscape,
				type == Column.VARCHAR_IGNORECASE);
	    String c = (String) eArg.getValue(Column.VARCHAR);

	    return l.compare(c);

	case IN:
	    return eArg2.testValueList(eArg.getValue(), eArg.iDataType);

	case EXISTS:
	    Result r = eArg.sSelect.getResult(1);    // 1 is already enough

	    return r.rRoot != null;
	}

	Trace.check(eArg != null, Trace.GENERAL_ERROR);

	Object o = eArg.getValue();
	int    type = eArg.iDataType;

	Trace.check(eArg2 != null, Trace.GENERAL_ERROR);

	Object o2 = eArg2.getValue(type);
	int    result = Column.compare(o, o2, type);

	switch (iType) {

	case EQUAL:
	    return result == 0;

	case BIGGER:
	    return result > 0;

	case BIGGER_EQUAL:
	    return result >= 0;

	case SMALLER_EQUAL:
	    return result <= 0;

	case SMALLER:
	    return result < 0;

	case NOT_EQUAL:
	    return result != 0;
	}

	Trace.assert(false, "Expression.test2");

	return false;
    }

}