| /* |
| * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved. |
| * |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License v. 2.0, which is available at |
| * http://www.eclipse.org/legal/epl-2.0. |
| * |
| * This Source Code may also be made available under the following Secondary |
| * Licenses when the conditions for such availability set forth in the |
| * Eclipse Public License v. 2.0 are satisfied: GNU General Public License, |
| * version 2 with the GNU Classpath Exception, which is available at |
| * https://www.gnu.org/software/classpath/license.html. |
| * |
| * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 |
| */ |
| |
| /* |
| * Optimizer.g |
| * |
| * Created on June 11, 2001 |
| */ |
| |
| header |
| { |
| package com.sun.jdo.spi.persistence.support.sqlstore.query.jqlc; |
| |
| import java.util.*; |
| |
| import java.math.BigDecimal; |
| import java.math.BigInteger; |
| |
| import com.sun.jdo.api.persistence.support.JDOFatalUserException; |
| import org.glassfish.persistence.common.I18NHelper; |
| import com.sun.jdo.spi.persistence.support.sqlstore.query.util.type.TypeTable; |
| import com.sun.jdo.spi.persistence.support.sqlstore.query.util.type.Type; |
| import com.sun.jdo.spi.persistence.support.sqlstore.query.util.type.ClassType; |
| import com.sun.jdo.spi.persistence.support.sqlstore.query.util.type.FieldInfo; |
| import com.sun.jdo.spi.persistence.support.sqlstore.query.util.type.NumericType; |
| import com.sun.jdo.spi.persistence.support.sqlstore.query.util.type.NumericWrapperClassType; |
| import com.sun.jdo.spi.persistence.support.sqlstore.query.util.type.NumberType; |
| import com.sun.jdo.spi.persistence.support.sqlstore.query.util.type.StringType; |
| } |
| |
| /** |
| * This class defines the optimizer pass of the JQL compiler. |
| * It takes the typed AST as produced by the smenatic analysis and |
| * converts it into a simpler but equivalent typed AST. |
| * |
| * @author Michael Bouschen |
| * @version 0.1 |
| */ |
| class Optimizer extends TreeParser; |
| |
| options |
| { |
| importVocab = JQL; |
| buildAST = true; |
| defaultErrorHandler = false; |
| ASTLabelType = "JQLAST"; //NOI18N |
| } |
| |
| { |
| /** |
| * I18N support |
| */ |
| protected final static ResourceBundle messages = |
| I18NHelper.loadBundle(Optimizer.class); |
| |
| /** |
| * type table |
| */ |
| protected TypeTable typetab; |
| |
| /** |
| * query parameter table |
| */ |
| protected ParameterTable paramtab; |
| |
| /** |
| * |
| */ |
| protected ErrorMsg errorMsg; |
| |
| /** |
| * |
| */ |
| public void init(TypeTable typetab, ParameterTable paramtab, |
| ErrorMsg errorMsg) |
| { |
| this.typetab = typetab; |
| this.paramtab = paramtab; |
| this.errorMsg = errorMsg; |
| } |
| |
| /** |
| * |
| */ |
| public void reportError(RecognitionException ex) { |
| errorMsg.fatal("Optimizer error", ex); //NOI18N |
| } |
| |
| /** |
| * |
| */ |
| public void reportError(String s) { |
| errorMsg.fatal("Optimizer error: " + s); //NOI18N |
| } |
| |
| /** |
| * Converts the string argument into a single char. |
| */ |
| protected static char parseChar(String text) |
| { |
| char first = text.charAt(0); |
| if (first == '\\') |
| { |
| //found escape => check the next char |
| char second = text.charAt(1); |
| switch (second) |
| { |
| case 'n': return '\n'; |
| case 'r': return '\r'; |
| case 't': return '\t'; |
| case 'b': return '\b'; |
| case 'f': return '\f'; |
| case 'u': |
| // unicode spec |
| return (char)Integer.parseInt(text.substring(2, text.length()), 16); |
| case '0': |
| case '1': |
| case '2': |
| case '3': |
| case '4': |
| case '5': |
| case '6': |
| case '7': |
| // octal spec |
| return (char)Integer.parseInt(text.substring(1, text.length()), 8); |
| default : return second; |
| } |
| } |
| return first; |
| } |
| |
| |
| /** |
| * Check an AND operation (BAND, AND) for constant operands |
| * that could be optimized. |
| * @param op the AND operator |
| * @param left the left operand |
| * @param right the right operand |
| * @return optimized JQLAST |
| */ |
| protected JQLAST checkAnd(JQLAST op, JQLAST left, JQLAST right) |
| { |
| JQLAST ast = op; |
| |
| if (isBooleanValueAST(left)) |
| { |
| ast = handleValueAndExpr(op, left.getValue(), right); |
| } |
| else if (isBooleanValueAST(right)) |
| { |
| ast = handleValueAndExpr(op, right.getValue(), left); |
| } |
| return ast; |
| } |
| |
| /** |
| * Check an OR operation (BOR, OR) for constant operands |
| * that could be optimized. |
| * @param op the OR operator |
| * @param left the left operand |
| * @param right the right operand |
| * @return optimized JQLAST |
| */ |
| protected JQLAST checkOr(JQLAST op, JQLAST left, JQLAST right) |
| { |
| JQLAST ast = op; |
| |
| if (isBooleanValueAST(left)) |
| { |
| ast = handleValueOrExpr(op, left.getValue(), right); |
| } |
| else if (isBooleanValueAST(right)) |
| { |
| ast = handleValueOrExpr(op, right.getValue(), left); |
| } |
| return ast; |
| } |
| |
| /** |
| * Check a equality operation (EQUAL, NOT_EQUAL) for constant operands |
| * that could be optimized. |
| * @param op the equality operator |
| * @param left the left operand |
| * @param right the right operand |
| * @param negate true for not equal operation, false otherwise |
| * @return optimized JQLAST |
| */ |
| protected JQLAST checkEqualityOp(JQLAST op, JQLAST left, JQLAST right, |
| boolean negate) |
| { |
| JQLAST ast = op; |
| |
| // case <VALUE> <op> <VALUE> |
| if ((left.getType() == VALUE) && (right.getType() == VALUE)) |
| { |
| ast = handleValueEqValue(op, left, right, negate); |
| } |
| // case <boolean VALUE> <op> <expr> |
| else if (isBooleanValueAST(left)) |
| { |
| ast = handleBooleanValueEqExpr(op, left.getValue(), right, negate); |
| } |
| // case <expr> <op> <boolean VALUE> |
| else if (isBooleanValueAST(right)) |
| { |
| ast = handleBooleanValueEqExpr(op, right.getValue(), left, negate); |
| } |
| return ast; |
| } |
| |
| /** |
| * Check a object equality operation (OBJECT_EQUAL, OBJECT_NOT_EQUAL) |
| * for constant operands that could be optimized. |
| * @param op the object equality operator |
| * @param left the left operand |
| * @param right the right operand |
| * @param negate true for not equal operation, false otherwise |
| * @return optimized JQLAST |
| */ |
| protected JQLAST checkObjectEqualityOp(JQLAST op, JQLAST left, JQLAST right, |
| boolean negate) |
| { |
| JQLAST ast = op; |
| |
| if ((left.getType() == VALUE) && (right.getType() == VALUE)) |
| { |
| ast = handleValueEqValue(op, left, right, negate); |
| } |
| return ast; |
| } |
| |
| /** |
| * Check a collection equality operation (COLLECTION_EQUAL, |
| * COLLECTION_NOT_EQUAL) for constant operands that could be optimized. |
| * @param op the collection equality operator |
| * @param left the left operand |
| * @param right the right operand |
| * @param negate true for not equal operation, false otherwise |
| * @return optimized JQLAST |
| */ |
| protected JQLAST checkCollectionEqualityOp(JQLAST op, JQLAST left, |
| JQLAST right, boolean negate) |
| { |
| JQLAST ast = op; |
| boolean isLeftConstant = (left.getType() == VALUE); |
| boolean isRightConstant = (right.getType() == VALUE); |
| |
| if (isLeftConstant && isRightConstant) |
| { |
| ast = handleValueEqValue(op, left, right, negate); |
| } |
| else if ((isLeftConstant && (left.getValue() == null) && isNonConstantCollection(right)) || |
| (isRightConstant && (right.getValue() == null) && isNonConstantCollection(left))) |
| { |
| // This optimization is datastore dependend. |
| // In TP we know a collection returned by the datastore is never null. |
| // null == <collection field> -> false |
| // <collection field> == null -> false |
| // null != <collection field> -> true |
| // <collection field> != null -> true |
| ast.setType(VALUE); |
| ast.setValue(new Boolean(negate)); |
| ast.setFirstChild(null); |
| } |
| |
| return ast; |
| } |
| |
| /** |
| * Check a logical not operation (LNOT) for a constant operand |
| * that could be optimized. |
| * @param op the logical not operator |
| * @param arg the operand |
| * @return optimized JQLAST |
| */ |
| protected JQLAST checkLogicalNotOp(JQLAST op, JQLAST arg) |
| { |
| JQLAST ast = op; |
| |
| if (arg.getType() == VALUE) |
| { |
| // !value may be calculated at compile time. |
| Object valueObj = arg.getValue(); |
| boolean value = (valueObj instanceof Boolean) ? |
| ((Boolean)valueObj).booleanValue() : false; |
| arg.setType(VALUE); |
| arg.setValue(new Boolean(!value)); |
| arg.setNextSibling(null); |
| ast = arg; |
| } |
| else |
| { |
| ast = deMorgan(arg); |
| } |
| return ast; |
| } |
| |
| /** |
| * Check a binary plus operation (PLUS) for constant operands |
| * that could be optimized. |
| * @param op the plus operator |
| * @param left the left operand |
| * @param right the right operand |
| * @return optimized JQLAST |
| */ |
| protected JQLAST checkBinaryPlusOp(JQLAST op, JQLAST left, JQLAST right) |
| { |
| JQLAST ast = op; |
| |
| if ((left.getType() == VALUE) && (right.getType() == VALUE)) |
| { |
| Object leftValue = left.getValue(); |
| Object rightValue = right.getValue(); |
| Object value = null; |
| if (leftValue == null) |
| value = rightValue; |
| else if (rightValue == null) |
| value = leftValue; |
| else |
| { |
| Type type = op.getJQLType(); |
| |
| if (type instanceof NumericWrapperClassType) |
| type = ((NumericWrapperClassType)type).getPrimitiveType(); |
| |
| if (type.equals(typetab.intType)) |
| value = new Integer(((Number)leftValue).intValue() + |
| ((Number)rightValue).intValue()); |
| else if (type.equals(typetab.longType)) |
| value = new Long(((Number)leftValue).longValue() + |
| ((Number)rightValue).longValue()); |
| else if (type.equals(typetab.floatType)) |
| value = new Float(((Number)leftValue).floatValue() + |
| ((Number)rightValue).floatValue()); |
| else if (type.equals(typetab.doubleType)) |
| value = new Double(((Number)leftValue).doubleValue() + |
| ((Number)rightValue).doubleValue()); |
| else if (type.equals(typetab.bigDecimalType)) |
| value = getBigDecimalValue(leftValue).add( |
| getBigDecimalValue(rightValue)); |
| else if (type.equals(typetab.bigIntegerType)) |
| value = getBigIntegerValue(leftValue).add( |
| getBigIntegerValue(rightValue)); |
| else |
| errorMsg.fatal(I18NHelper.getMessage(messages, |
| "jqlc.optimizer.checkbinaryplusop.invalidtype", //NOI18N |
| String.valueOf(type))); |
| } |
| ast.setType(VALUE); |
| ast.setValue(value); |
| ast.setFirstChild(null); |
| } |
| return ast; |
| } |
| |
| /** |
| * Check a string concatenation operation (CONCAT) for constant operands |
| * that could be optimized. |
| * @param op the concat operator |
| * @param left the left operand |
| * @param right the right operand |
| * @return optimized JQLAST |
| */ |
| protected JQLAST checkConcatOp(JQLAST op, JQLAST left, JQLAST right) |
| { |
| JQLAST ast = op; |
| |
| if ((left.getType() == VALUE) && (right.getType() == VALUE)) |
| { |
| Object leftValue = left.getValue(); |
| Object rightValue = right.getValue(); |
| Object value = null; |
| if (leftValue == null) |
| value = rightValue; |
| else if (rightValue == null) |
| value = leftValue; |
| else |
| value = leftValue.toString() + rightValue.toString(); |
| ast.setType(VALUE); |
| ast.setValue(value); |
| ast.setFirstChild(null); |
| } |
| return ast; |
| } |
| |
| /** |
| * Check a binary minus operation (MINUS) for constant operands |
| * that could be optimized. |
| * @param op the minus operator |
| * @param left the left operand |
| * @param right the right operand |
| * @return optimized JQLAST |
| */ |
| protected JQLAST checkBinaryMinusOp(JQLAST op, JQLAST left, JQLAST right) |
| { |
| JQLAST ast = op; |
| |
| if ((left.getType() == VALUE) && (right.getType() == VALUE)) |
| { |
| Object leftValue = left.getValue(); |
| Object rightValue = right.getValue(); |
| Object value = null; |
| if (rightValue == null) |
| value = leftValue; |
| else |
| { |
| if (leftValue == null) |
| leftValue = new Integer(0); |
| |
| Type type = op.getJQLType(); |
| |
| if (type instanceof NumericWrapperClassType) |
| type = ((NumericWrapperClassType)type).getPrimitiveType(); |
| |
| if (type.equals(typetab.intType)) |
| value = new Integer(((Number)leftValue).intValue() - |
| ((Number)rightValue).intValue()); |
| else if (type.equals(typetab.longType)) |
| value = new Long(((Number)leftValue).longValue() - |
| ((Number)rightValue).longValue()); |
| else if (type.equals(typetab.floatType)) |
| value = new Float(((Number)leftValue).floatValue() - |
| ((Number)rightValue).floatValue()); |
| else if (type.equals(typetab.doubleType)) |
| value = new Double(((Number)leftValue).doubleValue() - |
| ((Number)rightValue).doubleValue()); |
| else if (type.equals(typetab.bigDecimalType)) |
| value = getBigDecimalValue(leftValue).subtract( |
| getBigDecimalValue(rightValue)); |
| else if (type.equals(typetab.bigIntegerType)) |
| value = getBigIntegerValue(leftValue).subtract( |
| getBigIntegerValue(rightValue)); |
| else |
| errorMsg.fatal(I18NHelper.getMessage(messages, |
| "jqlc.optimizer.checkbinaryminusop.invalidtype", //NOI18N |
| String.valueOf(type))); |
| } |
| ast.setType(VALUE); |
| ast.setValue(value); |
| ast.setFirstChild(null); |
| } |
| return ast; |
| } |
| |
| /** |
| * Check a binary multiplication operation (STAR) for constant operands |
| * that could be optimized. |
| * @param op the multiplication operator |
| * @param left the left operand |
| * @param right the right operand |
| * @return optimized JQLAST |
| */ |
| protected JQLAST checkMultiplicationOp(JQLAST op, JQLAST left, JQLAST right) |
| { |
| JQLAST ast = op; |
| |
| if ((left.getType() == VALUE) && (right.getType() == VALUE)) |
| { |
| Object leftValue = left.getValue(); |
| Object rightValue = right.getValue(); |
| Object value = null; |
| if (leftValue == null) |
| leftValue = new Integer(0); |
| if (rightValue == null) |
| rightValue = new Integer(0); |
| Type type = op.getJQLType(); |
| |
| if (type instanceof NumericWrapperClassType) |
| type = ((NumericWrapperClassType)type).getPrimitiveType(); |
| |
| if (type.equals(typetab.intType)) |
| value = new Integer(((Number)leftValue).intValue() * |
| ((Number)rightValue).intValue()); |
| else if (type.equals(typetab.longType)) |
| value = new Long(((Number)leftValue).longValue() * |
| ((Number)rightValue).longValue()); |
| else if (type.equals(typetab.floatType)) |
| value = new Float(((Number)leftValue).floatValue() * |
| ((Number)rightValue).floatValue()); |
| else if (type.equals(typetab.doubleType)) |
| value = new Double(((Number)leftValue).doubleValue() * |
| ((Number)rightValue).doubleValue()); |
| else if (type.equals(typetab.bigDecimalType)) |
| value = getBigDecimalValue(leftValue).multiply( |
| getBigDecimalValue(rightValue)); |
| else if (type.equals(typetab.bigIntegerType)) |
| value = getBigIntegerValue(leftValue).multiply( |
| getBigIntegerValue(rightValue)); |
| else |
| errorMsg.fatal(I18NHelper.getMessage(messages, |
| "jqlc.optimizer.checkmultiplicationop.invalidtype", //NOI18N |
| String.valueOf(type))); |
| |
| ast.setType(VALUE); |
| ast.setValue(value); |
| ast.setFirstChild(null); |
| } |
| return ast; |
| } |
| |
| /** |
| * Check a binary division operation (DIV) for constant operands |
| * that could be optimized. |
| * @param op the division operator |
| * @param left the left operand |
| * @param right the right operand |
| * @return optimized JQLAST |
| */ |
| protected JQLAST checkDivisionOp(JQLAST op, JQLAST left, JQLAST right) |
| { |
| JQLAST ast = op; |
| |
| if ((left.getType() == VALUE) && (right.getType() == VALUE)) |
| { |
| Object leftValue = left.getValue(); |
| Object rightValue = right.getValue(); |
| Object value = null; |
| if (leftValue == null) |
| leftValue = new Integer(0); |
| if (rightValue == null) |
| // division by zero! |
| rightValue = new Integer(0); |
| |
| Type type = op.getJQLType(); |
| |
| if (type instanceof NumericWrapperClassType) |
| type = ((NumericWrapperClassType)type).getPrimitiveType(); |
| |
| if (type.equals(typetab.intType)) |
| value = new Integer(((Number)leftValue).intValue() / |
| ((Number)rightValue).intValue()); |
| else if (type.equals(typetab.longType)) |
| value = new Long(((Number)leftValue).longValue() / |
| ((Number)rightValue).longValue()); |
| else if (type.equals(typetab.floatType)) |
| value = new Float(((Number)leftValue).floatValue() / |
| ((Number)rightValue).floatValue()); |
| else if (type.equals(typetab.doubleType)) |
| value = new Double(((Number)leftValue).doubleValue() / |
| ((Number)rightValue).doubleValue()); |
| else if (type.equals(typetab.bigDecimalType)) |
| value = getBigDecimalValue(leftValue).divide( |
| getBigDecimalValue(rightValue), BigDecimal.ROUND_HALF_EVEN); |
| else if (type.equals(typetab.bigIntegerType)) |
| value = getBigIntegerValue(leftValue).divide( |
| getBigIntegerValue(rightValue)); |
| else |
| errorMsg.fatal(I18NHelper.getMessage(messages, |
| "jqlc.optimizer.checkdivisionop.invalidtype", //NOI18N |
| String.valueOf(type))); |
| |
| ast.setType(VALUE); |
| ast.setValue(value); |
| ast.setFirstChild(null); |
| } |
| return ast; |
| } |
| |
| /** |
| * Check a binary modular operation (MOD) for constant operands |
| * that could be optimized. |
| * @param op the mod operator |
| * @param left the left operand |
| * @param right the right operand |
| * @return optimized JQLAST |
| */ |
| protected JQLAST checkModOp(JQLAST op, JQLAST left, JQLAST right) |
| { |
| JQLAST ast = op; |
| |
| if ((left.getType() == VALUE) && (right.getType() == VALUE)) |
| { |
| Object leftValue = left.getValue(); |
| Object rightValue = right.getValue(); |
| Object value = null; |
| if (leftValue == null) |
| leftValue = new Integer(0); |
| if (rightValue == null) |
| // division by zero! |
| rightValue = new Integer(0); |
| |
| Type type = op.getJQLType(); |
| |
| if (type instanceof NumericWrapperClassType) |
| type = ((NumericWrapperClassType)type).getPrimitiveType(); |
| |
| if (type.equals(typetab.intType)) |
| value = new Integer(((Number)leftValue).intValue() % |
| ((Number)rightValue).intValue()); |
| else if (type.equals(typetab.longType)) |
| value = new Long(((Number)leftValue).longValue() % |
| ((Number)rightValue).longValue()); |
| else if (type.equals(typetab.floatType)) |
| value = new Float(((Number)leftValue).floatValue() % |
| ((Number)rightValue).floatValue()); |
| else if (type.equals(typetab.doubleType)) |
| value = new Double(((Number)leftValue).doubleValue() % |
| ((Number)rightValue).doubleValue()); |
| else if (type.equals(typetab.bigDecimalType)) |
| { |
| BigDecimal leftBigDecimal = getBigDecimalValue(leftValue); |
| BigDecimal rightBigDecimal = getBigDecimalValue(rightValue); |
| //use ROUND_HALF_EVEN so that it is consistent with div |
| BigDecimal quotient = leftBigDecimal.divide(rightBigDecimal, |
| 0, BigDecimal.ROUND_HALF_EVEN); |
| value = leftBigDecimal.subtract( |
| rightBigDecimal.multiply(quotient)); |
| } |
| else if (type.equals(typetab.bigIntegerType)) |
| value = getBigIntegerValue(leftValue).remainder( |
| getBigIntegerValue(rightValue)); |
| else |
| errorMsg.fatal(I18NHelper.getMessage(messages, |
| "jqlc.optimizer.checkmodop.invalidtype", //NOI18N |
| String.valueOf(type))); |
| |
| ast.setType(VALUE); |
| ast.setValue(value); |
| ast.setFirstChild(null); |
| } |
| return ast; |
| } |
| |
| /** |
| * Check a unary minus operation (UNARY_MINUS) for a constant operand |
| * that could be optimized. |
| * @param op the unary minus operator |
| * @param arg the operand |
| * @return optimized JQLAST |
| */ |
| protected JQLAST checkUnaryMinusOp(JQLAST op, JQLAST arg) |
| { |
| JQLAST ast = op; |
| |
| if (arg.getType() == VALUE) |
| { |
| Object value = arg.getValue(); |
| Type type = op.getJQLType(); |
| Object negate = null; |
| |
| if (type instanceof NumberType) |
| negate = ((NumberType)type).negate((Number)value); |
| else |
| errorMsg.fatal(I18NHelper.getMessage(messages, |
| "jqlc.optimizer.checkunaryminusop.invalidtype", //NOI18N |
| String.valueOf(type))); |
| |
| ast.setType(VALUE); |
| ast.setValue(negate); |
| ast.setFirstChild(null); |
| } |
| return ast; |
| } |
| |
| /** |
| * Check a cast operation for a constant operand |
| * that could be optimized. |
| * @param op the cast operator |
| * @param castType the cast type |
| * @param expr the non constant operand |
| * @return optimized JQLAST |
| */ |
| protected JQLAST checkCastOp(JQLAST op, JQLAST castType, JQLAST expr) |
| { |
| JQLAST ast = op; |
| |
| if (expr.getType() == VALUE) |
| { |
| Object value = expr.getValue(); |
| Type type = op.getJQLType(); |
| if (type instanceof NumericWrapperClassType) |
| type = ((NumericWrapperClassType)type).getPrimitiveType(); |
| |
| if (type.equals(typetab.intType)) |
| value = new Integer(((Number)value).intValue()); |
| else if (type.equals(typetab.longType)) |
| value = new Long(((Number)value).longValue()); |
| else if (type.equals(typetab.floatType)) |
| value = new Float(((Number)value).floatValue()); |
| else if (type.equals(typetab.doubleType)) |
| value = new Double(((Number)value).doubleValue()); |
| else if (type.equals(typetab.bigDecimalType)) |
| value = getBigDecimalValue(value); |
| else if (type.equals(typetab.bigIntegerType)) |
| value = getBigIntegerValue(value); |
| else if (type.equals(typetab.byteType)) |
| value = new Byte((byte)((Number)value).intValue()); |
| else if (type.equals(typetab.shortType)) |
| value = new Short((short)((Number)value).intValue()); |
| else if (type.equals(typetab.charType)) |
| value = new Character((char)((Number)value).intValue()); |
| |
| // If non of the above type applies, leave the value as it is |
| |
| // convert the TYPECAST op into a VALUE |
| ast.setType(VALUE); |
| ast.setValue(value); |
| ast.setFirstChild(null); |
| } |
| return ast; |
| } |
| |
| /** |
| * Converts the specified value into a BigDecimal value. |
| * @param value value to be converted |
| * @return BigDecimal representation |
| */ |
| protected BigDecimal getBigDecimalValue(Object value) |
| { |
| BigDecimal ret = null; |
| if (value instanceof Number) |
| ret = (BigDecimal)typetab.bigDecimalType.getValue((Number)value); |
| else |
| errorMsg.fatal(I18NHelper.getMessage(messages, |
| "jqlc.optimizer.getbigdecimalvalue.notnumber", //NOI18N |
| String.valueOf(value))); |
| |
| return ret; |
| } |
| |
| /** |
| * Converts the specified value into a BigInteger value. |
| * @param value value to be converted |
| * @return BigInteger representation |
| */ |
| protected BigInteger getBigIntegerValue(Object value) |
| { |
| BigInteger ret = null; |
| |
| if (value instanceof Number) |
| ret = (BigInteger)typetab.bigIntegerType.getValue((Number)value); |
| else |
| errorMsg.fatal(I18NHelper.getMessage(messages, |
| "jqlc.optimizer.getbigintegervalue.notnumber", //NOI18N |
| String.valueOf(value))); |
| |
| return ret; |
| } |
| |
| /** |
| * This method is called in the case of an equality operation having two |
| * constant operands. It calculates the result of this constant operation |
| * and returns a JQLAST node representing a constant boolean value. |
| * @param op the equality operator |
| * @param left the left operand |
| * @param right the right operand |
| * @param negate true for not equal operation, false otherwise |
| * @return optimized JQLAST |
| */ |
| protected JQLAST handleValueEqValue(JQLAST op, JQLAST left, JQLAST right, |
| boolean negate) |
| { |
| Object leftValue = left.getValue(); |
| Object rightValue = right.getValue(); |
| boolean value = false; |
| |
| if ((leftValue == null) && (rightValue == null)) |
| { |
| // both values are null -> true |
| value = true; |
| } |
| else if ((leftValue != null) && (rightValue != null)) |
| { |
| // both values are not null -> use equals |
| value = leftValue.equals(rightValue); |
| } |
| else |
| { |
| // one value is null, the other is not null -> false |
| value = false; |
| } |
| if (negate) |
| { |
| value = !value; |
| } |
| op.setType(VALUE); |
| op.setValue(new Boolean(value)); |
| op.setFirstChild(null); |
| return op; |
| } |
| |
| /** |
| * This method is called in the case of an equality operation having |
| * a boolean constant operand and a non constant operand. |
| * It returns the non constant operand either as it is or inverted, |
| * depending on the equality operation. |
| * @param op the equality operator |
| * @param value the contant boolean value |
| * @param expr the non constant operand |
| * @param negate true for not equal operation, false otherwise |
| * @return optimized JQLAST |
| */ |
| private JQLAST handleBooleanValueEqExpr(JQLAST op, Object value, |
| JQLAST expr, boolean negate) |
| { |
| JQLAST ast; |
| boolean skip = (value instanceof Boolean) ? |
| ((Boolean)value).booleanValue() : false; |
| if (negate) skip = !skip; |
| |
| if (skip) |
| { |
| // expr == true -> expr |
| // expr != false -> expr |
| ast = expr; |
| } |
| else |
| { |
| // if expr is a equality op or a not op the invert operation may be "inlined": |
| // (expr1 == expr2) != true -> expr1 != expr2 |
| // (expr1 != expr2) != true -> expr1 == expr2 |
| // !expr != true -> expr |
| // !expr == false -> expr |
| // Otherwise wrap the expr with a not op |
| // expr != true -> !expr |
| // expr == false -> !expr |
| switch (expr.getType()) |
| { |
| case EQUAL: |
| expr.setType(NOT_EQUAL); |
| expr.setText("!="); //NOI18N |
| ast = expr; |
| break; |
| case NOT_EQUAL: |
| expr.setType(EQUAL); |
| expr.setText("=="); //NOI18N |
| ast = expr; |
| break; |
| case LNOT: |
| ast = (JQLAST)expr.getFirstChild(); |
| break; |
| default: |
| op.setType(LNOT); |
| op.setText("!"); //NOI18N |
| op.setFirstChild(expr); |
| ast = op; |
| } |
| expr.setNextSibling(null); |
| } |
| return ast; |
| } |
| |
| /** |
| * This method is called in the case of an AND operation having at least |
| * one constant operand. If the constant operand evaluates to true it |
| * returns the other operand. If it evaluates to false it returns an AST |
| * representing the constant boolean value false. |
| * @param op the AND operator |
| * @param left the left operand |
| * @param right the right operand |
| * @return optimized JQLAST |
| */ |
| private JQLAST handleValueAndExpr(JQLAST op, Object value, JQLAST expr) |
| { |
| JQLAST ast; |
| |
| if ((value instanceof Boolean) && ((Boolean)value).booleanValue()) |
| { |
| // true AND expr -> expr |
| // expr AND true -> expr |
| expr.setNextSibling(null); |
| ast = expr; |
| } |
| else |
| { |
| // false AND expr -> false |
| // expr AND false -> false |
| op.setType(VALUE); |
| op.setText("false"); //NOI18N |
| op.setValue(new Boolean(false)); |
| op.setFirstChild(null); |
| ast = op; |
| } |
| return ast; |
| } |
| |
| /** |
| * This method is called in the case of an OR operation having at least |
| * one constant operand. If the constant operand evaluates to false it |
| * returns the other operand. If it evaluates to true it returns an AST |
| * representing the constant boolean value true. |
| * @param op the AND operator |
| * @param left the left operand |
| * @param right the right operand |
| * @return optimized JQLAST |
| */ |
| private JQLAST handleValueOrExpr(JQLAST op, Object value, JQLAST expr) |
| { |
| JQLAST ast; |
| |
| if ((value instanceof Boolean) && ((Boolean)value).booleanValue()) |
| { |
| // true OR expr -> true |
| // expr OR true -> true |
| op.setType(VALUE); |
| op.setText("true"); //NOI18N |
| op.setValue(new Boolean(true)); |
| op.setFirstChild(null); |
| ast = op; |
| } |
| else |
| { |
| // false OR expr -> expr |
| // expr OR false -> expr |
| expr.setNextSibling(null); |
| ast = expr; |
| } |
| return ast; |
| } |
| |
| /** |
| * Returns true if the specified AST represents a constant boolean value. |
| */ |
| protected boolean isBooleanValueAST(JQLAST ast) |
| { |
| return (ast.getType() == VALUE) && |
| (typetab.booleanType.equals(ast.getJQLType())); |
| } |
| |
| /** |
| * Returns true if the specified AST represents a datastore value. |
| */ |
| protected boolean isNonConstantCollection(JQLAST ast) |
| { |
| switch (ast.getType()) |
| { |
| case FIELD_ACCESS : |
| case NAVIGATION : |
| return true; |
| case TYPECAST : |
| JQLAST expr = (JQLAST)ast.getFirstChild().getNextSibling(); |
| return isNonConstantCollection(expr); |
| default: |
| return false; |
| } |
| } |
| |
| /** |
| * Implements DeMorgans rule: |
| * <br> |
| * NOT (a AND b) -> NOT a OR NOT b |
| * <br> |
| * NOT (a OR b) -> NOT a AND NOT b |
| * <br> |
| * NOT (NOT a) -> a |
| * <br> |
| * The method assumes that the tree passed as an argument does not include |
| * the initial NOT. Note, this method checks for contains clauses, because |
| * they require special treatement. |
| */ |
| protected JQLAST deMorgan(JQLAST tree) |
| { |
| JQLAST result = null; |
| JQLAST left = null; |
| JQLAST right = null; |
| switch (tree.getType()) |
| { |
| case AND: |
| case BAND: |
| left = (JQLAST)tree.getFirstChild(); |
| right = (JQLAST)left.getNextSibling(); |
| String leftVar = getVariableFromContainsClause(left); |
| String rightVar = getVariableFromContainsClause(right); |
| if (leftVar != null) |
| { |
| // found AND ( CONTAINS, right ), so check right for special |
| // variable treatement |
| result = buildAST(tree, left, deMorgan(right, leftVar)); |
| } |
| else if (rightVar != null) |
| { |
| // found AND ( left, CONTAINS, ), so check left for special |
| // variable treatement |
| result = buildAST(tree, right, deMorgan(left, rightVar)); |
| } |
| else |
| { |
| invertNode(tree); |
| result = buildAST(tree, deMorgan(left), deMorgan(right)); |
| } |
| break; |
| case OR: |
| case BOR: |
| left = (JQLAST)tree.getFirstChild(); |
| right = (JQLAST)left.getNextSibling(); |
| invertNode(tree); |
| result = buildAST(tree, deMorgan(left), deMorgan(right)); |
| break; |
| case LNOT: |
| // This is !(!arg) => return arg |
| result = (JQLAST)tree.getFirstChild(); |
| break; |
| default: |
| // wrap arg into not operator |
| result = buildAST(new JQLAST(LNOT, "!", typetab.booleanType), tree); |
| break; |
| } |
| return result; |
| } |
| |
| /** |
| * This overloaded deMorgan method implements special treatment of variable |
| * access expressions in the case of !contains. The method keeps an expression |
| * accessing the specified variable as it is, but it inverts an expression NOT |
| * accessing the variable following regular DeMorgan rules. |
| */ |
| protected JQLAST deMorgan(JQLAST tree, String var) |
| { |
| JQLAST result = tree; |
| switch (tree.getType()) |
| { |
| case AND: |
| case BAND: |
| case OR: |
| case BOR: |
| JQLAST left = (JQLAST)tree.getFirstChild(); |
| JQLAST right = (JQLAST)left.getNextSibling(); |
| if (!includesVariableAccess(left, var) || |
| !includesVariableAccess(right, var)) |
| { |
| invertNode(tree); |
| } |
| result = buildAST(tree, deMorgan(left, var), deMorgan(right, var)); |
| break; |
| default: |
| if (!includesVariableAccess(tree, var)) |
| { |
| result = deMorgan(tree); |
| } |
| break; |
| } |
| return result; |
| } |
| |
| /** |
| * Checks the specified tree being a CONATAINS clause. If yes it returns |
| * the variable used in the contains clause. Otherwise it returns null. |
| */ |
| protected String getVariableFromContainsClause(JQLAST tree) |
| { |
| switch (tree.getType()) |
| { |
| case CONTAINS: |
| case NOT_CONTAINS: |
| return tree.getFirstChild().getNextSibling().getText(); |
| default: |
| return null; |
| } |
| } |
| |
| /** |
| * Checks whether the specified tree accesses the variable with the |
| * specified name. Accessing means either this node or of of the subnodes |
| * has the type VARIABLE. |
| * NOTE, the method is intended to be used in the ! contains case only! |
| * If it find a variable access node of the form |
| * <br> |
| * #(VARIABLE collection) |
| * it maps it to |
| * #(VARIABLE #(NOT_IN (collection)) |
| * <br> |
| * This incdicates a variable belonging to a !contains clause. |
| */ |
| protected boolean includesVariableAccess(AST tree, String var) |
| { |
| if ((tree == null) || (var == null)) |
| return false; |
| |
| boolean found = false; |
| JQLAST child = (JQLAST)tree.getFirstChild(); |
| if ((tree.getType() == VARIABLE) && (tree.getText().equals(var)) && |
| (child != null)) |
| { |
| found = true; |
| if (child.getType() != NOT_IN) |
| { |
| tree.setFirstChild(buildAST( |
| new JQLAST(NOT_IN, "notIn", typetab.booleanType), child)); |
| } |
| } |
| for (AST node = tree.getFirstChild(); node != null; node = node.getNextSibling()) |
| { |
| if (includesVariableAccess(node, var)) |
| found = true; |
| } |
| return found; |
| } |
| |
| /** |
| * Inverts the specified node: AND -> OR, == -> !=, etc. |
| */ |
| protected void invertNode(JQLAST node) |
| { |
| switch(node.getType()) |
| { |
| case AND: |
| node.setType(OR); |
| node.setText("||"); |
| break; |
| case BAND: |
| node.setType(BOR); |
| node.setText("|"); |
| break; |
| case OR: |
| node.setType(AND); |
| node.setText("&&"); |
| break; |
| case BOR: |
| node.setType(BAND); |
| node.setText("&"); |
| break; |
| case EQUAL: |
| node.setType(NOT_EQUAL); |
| node.setText("!="); |
| break; |
| case NOT_EQUAL: |
| node.setType(EQUAL); |
| node.setText("=="); |
| break; |
| case LT: |
| node.setType(GE); |
| node.setText(">="); |
| break; |
| case LE: |
| node.setType(GT); |
| node.setText(">"); |
| break; |
| case GT: |
| node.setType(LE); |
| node.setText("<="); |
| break; |
| case GE: |
| node.setType(LT); |
| node.setText("<"); |
| break; |
| } |
| } |
| |
| /** Builds a binary tree. */ |
| protected JQLAST buildAST(JQLAST root, JQLAST left, JQLAST right) |
| { |
| root.setFirstChild(left); |
| left.setNextSibling(right); |
| right.setNextSibling(null); |
| return root; |
| } |
| |
| /** */ |
| protected JQLAST buildAST(JQLAST root, JQLAST arg) |
| { |
| root.setFirstChild(arg); |
| arg.setNextSibling(null); |
| return root; |
| } |
| } |
| |
| // rules |
| |
| query |
| : #( q:QUERY |
| candidateClass |
| parameters |
| variables |
| ordering |
| result |
| filter |
| ) |
| ; |
| |
| // ---------------------------------- |
| // rules: candidate class |
| // ---------------------------------- |
| |
| candidateClass |
| { |
| errorMsg.setContext("setCandidates"); //NOI18N |
| } |
| : CLASS_DEF |
| ; |
| |
| // ---------------------------------- |
| // rules: parameter declaration |
| // ---------------------------------- |
| |
| parameters |
| { |
| errorMsg.setContext("declareParameters"); //NOI18N |
| } |
| : ( declareParameter )* |
| ; |
| |
| declareParameter |
| : #( PARAMETER_DEF type IDENT ) |
| ; |
| |
| // ---------------------------------- |
| // rules: variable declaration |
| // ---------------------------------- |
| |
| variables |
| { |
| errorMsg.setContext("declareVariables"); //NOI18N |
| } |
| : ( declareVariable )* |
| ; |
| |
| declareVariable |
| : #( VARIABLE_DEF type IDENT ) |
| ; |
| |
| // ---------------------------------- |
| // rules: ordering specification |
| // ---------------------------------- |
| |
| ordering |
| { |
| errorMsg.setContext("setOrdering"); //NOI18N |
| } |
| : ( orderSpec )* |
| ; |
| |
| orderSpec |
| : #( ORDERING_DEF ( ASCENDING | DESCENDING ) expression ) |
| ; |
| |
| // ---------------------------------- |
| // rules: result expression |
| // ---------------------------------- |
| |
| result |
| { |
| errorMsg.setContext("setResult"); //NOI18N |
| } |
| : #( r:RESULT_DEF resultExpr ) |
| | // empty rule |
| ; |
| |
| resultExpr |
| : #( DISTINCT resultExpr ) |
| | #( AVG resultExpr ) |
| | #( MAX resultExpr ) |
| | #( MIN resultExpr ) |
| | #( SUM resultExpr ) |
| | #( COUNT resultExpr ) |
| | expression |
| ; |
| |
| // ---------------------------------- |
| // rules: filer expression |
| // ---------------------------------- |
| |
| filter |
| { |
| errorMsg.setContext("setFilter"); //NOI18N |
| } |
| : #( FILTER_DEF expression ) |
| ; |
| |
| expression |
| : primary |
| | bitwiseExpr |
| | conditionalExpr |
| | relationalExpr |
| | binaryArithmeticExpr |
| | unaryArithmeticExpr |
| | complementExpr |
| ; |
| |
| bitwiseExpr |
| : #( op1:BAND left1:expression right1:expression ) |
| { |
| #bitwiseExpr = checkAnd(#op1, #left1, #right1); |
| } |
| | #( op2:BOR left2:expression right2:expression ) |
| { |
| #bitwiseExpr = checkOr(#op2, #left2, #right2); |
| } |
| | #( op3:BXOR left3:expression right3:expression ) |
| ; |
| |
| conditionalExpr |
| : #( op1:AND left1:expression right1:expression ) |
| { |
| #conditionalExpr = checkAnd(#op1, #left1, #right1); |
| } |
| | #( op2:OR left2:expression right2:expression ) |
| { |
| #conditionalExpr = checkOr(#op2, #left2, #right2); |
| } |
| ; |
| |
| relationalExpr |
| : #( op1:EQUAL left1:expression right1:expression ) |
| { |
| #relationalExpr = checkEqualityOp(#op1, #left1, #right1, false); |
| } |
| | #( op2:NOT_EQUAL left2:expression right2:expression ) |
| { |
| #relationalExpr = checkEqualityOp(#op2, #left2, #right2, true); |
| } |
| | #( op3:OBJECT_EQUAL left3:expression right3:expression ) |
| { |
| #relationalExpr = checkObjectEqualityOp(#op3, #left3, #right3, false); |
| } |
| | #( op4:OBJECT_NOT_EQUAL left4:expression right4:expression ) |
| { |
| #relationalExpr = checkObjectEqualityOp(#op4, #left4, #right4, true); |
| } |
| | #( op5:COLLECTION_EQUAL left5:expression right5:expression ) |
| { |
| #relationalExpr = checkCollectionEqualityOp(#op5, #left5, #right5, false); |
| } |
| | #( op6:COLLECTION_NOT_EQUAL left6:expression right6:expression ) |
| { |
| #relationalExpr = checkCollectionEqualityOp(#op6, #left6, #right6, true); |
| } |
| | #( LT expression expression ) |
| | #( GT expression expression ) |
| | #( LE expression expression ) |
| | #( GE expression expression ) |
| ; |
| |
| binaryArithmeticExpr |
| : #( op1:PLUS left1:expression right1:expression ) |
| { |
| #binaryArithmeticExpr = checkBinaryPlusOp(#op1, #left1, #right1); |
| } |
| | #( op2:CONCAT left2:expression right2:expression ) |
| { |
| #binaryArithmeticExpr = checkConcatOp(#op2, #left2, #right2); |
| } |
| | #( op3:MINUS left3:expression right3:expression ) |
| { |
| #binaryArithmeticExpr = checkBinaryMinusOp(#op3, #left3, #right3); |
| } |
| | #( op4:STAR left4:expression right4:expression ) |
| { |
| #binaryArithmeticExpr = checkMultiplicationOp(#op4, #left4, #right4); |
| } |
| | #( op5:DIV left5:expression right5:expression ) |
| { |
| #binaryArithmeticExpr = checkDivisionOp(#op5, #left5, #right5); |
| } |
| | #( op6:MOD left6:expression right6:expression ) |
| { |
| #binaryArithmeticExpr = checkModOp(#op6, #left6, #right6); |
| } |
| ; |
| |
| unaryArithmeticExpr |
| : #( UNARY_PLUS expression ) |
| | ( unaryMinusLiteralExpr )=> unaryMinusLiteralExpr |
| | #( op2:UNARY_MINUS arg2:expression ) |
| { |
| #unaryArithmeticExpr = checkUnaryMinusOp(#op2, #arg2); |
| } |
| ; |
| |
| unaryMinusLiteralExpr |
| : #( UNARY_MINUS ( i:INT_LITERAL | l:LONG_LITERAL ) ) |
| { |
| JQLAST li = (#i != null) ? #i : #l; |
| li.setText("-" + li.getText()); |
| // calling literal here directly does not work properly |
| // the following logic need to be in sync with that of literal |
| li.setValue(#literalHelper(li)); |
| li.setType(VALUE); |
| #unaryMinusLiteralExpr = #li; |
| } |
| ; |
| |
| complementExpr |
| : #( op1:BNOT arg1:expression ) |
| | #( op2:LNOT arg2:expression ) |
| { |
| #complementExpr = checkLogicalNotOp(#op2, #arg2); |
| } |
| ; |
| |
| primary |
| : castExpr |
| | literal |
| | VALUE |
| | THIS |
| | parameter |
| | staticFieldAccess |
| | fieldAccess |
| | navigation |
| | variableAccess |
| | #( CONTAINS expression VARIABLE ) |
| | #( NOT_CONTAINS expression VARIABLE ) |
| | startsWith |
| | endsWith |
| | isEmpty |
| | like |
| | substring |
| | indexOf |
| | length |
| | abs |
| | sqrt |
| ; |
| |
| castExpr |
| : #( c:TYPECAST t:type e:expression ) |
| { |
| #castExpr = checkCastOp(#c, #t, #e); |
| } |
| ; |
| |
| literal |
| { |
| Object value = null; |
| } |
| : value = l:literalHelper |
| { |
| #l.setType(VALUE); |
| #l.setValue(value); |
| } |
| ; |
| |
| literalHelper returns [Object value] |
| { |
| value = null; |
| } |
| : TRUE |
| { value = new Boolean(true); } |
| | FALSE |
| { value = new Boolean(false); } |
| | i:INT_LITERAL |
| { |
| try |
| { |
| value = Integer.decode(i.getText()); |
| } |
| catch (NumberFormatException ex) |
| { |
| errorMsg.error(i.getLine(), i.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.optimizer.literal.invalid", //NOI18N |
| i.getJQLType().getName(), i.getText())); |
| } |
| } |
| | l:LONG_LITERAL |
| { |
| String txt = l.getText(); |
| char last = txt.charAt(txt.length() - 1); |
| if ((last == 'l') || (last == 'L')) |
| { |
| txt = txt.substring(0, txt.length() - 1); |
| } |
| try |
| { |
| value = Long.decode(txt); |
| } |
| catch (NumberFormatException ex) |
| { |
| errorMsg.error(l.getLine(), l.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.optimizer.literal.invalid", //NOI18N |
| l.getJQLType().getName(), l.getText())); |
| } |
| } |
| | f:FLOAT_LITERAL |
| { |
| String txt = f.getText(); |
| char last = txt.charAt(txt.length() - 1); |
| if ((last == 'f') || (last == 'F')) |
| { |
| txt = txt.substring(0, txt.length() - 1); |
| } |
| try |
| { |
| value = new Float(txt); |
| } |
| catch (NumberFormatException ex) |
| { |
| errorMsg.error(f.getLine(), f.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.optimizer.literal.invalid", //NOI18N |
| f.getJQLType().getName(), f.getText())); |
| } |
| } |
| | d:DOUBLE_LITERAL |
| { |
| String txt = d.getText(); |
| char last = txt.charAt(txt.length() - 1); |
| if ((last == 'd') || (last == 'd')) |
| { |
| txt = txt.substring(0, txt.length() - 1); |
| } |
| try |
| { |
| value = new Double(txt); |
| } |
| catch (NumberFormatException ex) |
| { |
| errorMsg.error(d.getLine(), d.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.optimizer.literal.invalid", //NOI18N |
| d.getJQLType().getName(), d.getText())); |
| } |
| } |
| | c:CHAR_LITERAL |
| { value = new Character(parseChar(c.getText())); } |
| | s:STRING_LITERAL |
| { value = s.getText(); } |
| | n:NULL |
| { value = null; } |
| ; |
| |
| parameter |
| : p:PARAMETER |
| { |
| if (paramtab.inline(#p.getText())) { |
| #p.setType(VALUE); |
| #p.setValue(paramtab.getValueByName(#p.getText())); |
| } |
| } |
| ; |
| |
| staticFieldAccess |
| { |
| Object value = null; |
| } |
| : #( s:STATIC_FIELD_ACCESS t:TYPENAME i:IDENT) |
| { |
| // Calculate the value of the static field at compile time |
| // and treat it as constant value. |
| ClassType classType = (ClassType)t.getJQLType(); |
| FieldInfo fieldInfo = classType.getFieldInfo(i.getText()); |
| try |
| { |
| value = fieldInfo.getField().get(null); |
| #s.setType(VALUE); |
| #s.setValue(value); |
| #s.setFirstChild(null); |
| } |
| catch (IllegalAccessException e) |
| { |
| throw new JDOFatalUserException( |
| I18NHelper.getMessage(messages, |
| "jqlc.optimizer.staticfieldaccess.illegal", //NOI18N |
| i.getText(), classType.getName()), e); |
| } |
| } |
| ; |
| |
| fieldAccess |
| : #( f:FIELD_ACCESS o:expression name:IDENT ) |
| { |
| if (#o.getType() == VALUE) |
| { |
| // If the object of the field access is a constant value, |
| // evaluate the field access at compile time and |
| // treat the expression as constant value. |
| Object object = #o.getValue(); |
| ClassType classType = (ClassType)#o.getJQLType(); |
| Object value = CodeGeneration.getFieldValue(classType, object, |
| #name.getText()); |
| #f.setType(VALUE); |
| #f.setValue(value); |
| #f.setFirstChild(null); |
| } |
| } |
| ; |
| |
| navigation |
| : #( n:NAVIGATION o:expression name:IDENT ) |
| { |
| if (#o.getType() == VALUE) |
| { |
| // If the object of the navigation is a constant value, |
| // evaluate the field access at compile time and |
| // treat the expression as constant value. |
| Object object = #o.getValue(); |
| ClassType classType = (ClassType)#o.getJQLType(); |
| Object value = CodeGeneration.getFieldValue(classType, object, |
| #name.getText()); |
| #n.setType(VALUE); |
| #n.setValue(value); |
| #n.setFirstChild(null); |
| } |
| } |
| ; |
| |
| variableAccess |
| : #( VARIABLE ( expression )? ) |
| ; |
| |
| startsWith |
| : #( STARTS_WITH expression expression ) |
| ; |
| |
| endsWith |
| : #( ENDS_WITH expression expression ) |
| ; |
| |
| isEmpty |
| : #( op:IS_EMPTY e:expression) |
| { |
| if (#e.getType() == VALUE) |
| { |
| // If the expression that specifies the collection is a constant value, |
| // evaluate the isEmpty call at compile time and treat the expression |
| // as constant value. |
| Object object = #e.getValue(); |
| Object value = null; |
| if (object == null) |
| { |
| value = new Boolean(false); |
| } |
| else if (object instanceof Collection) |
| { |
| value = new Boolean(((Collection)object).isEmpty()); |
| } |
| else |
| { |
| errorMsg.fatal(I18NHelper.getMessage(messages, "jqlc.optimizer.isempty.requirecollection")); //NOI18N |
| } |
| #op.setType(VALUE); |
| #op.setValue(value); |
| #op.setFirstChild(null); |
| } |
| } |
| ; |
| |
| like |
| : #( LIKE expression expression ( expression )? ) |
| ; |
| |
| substring |
| : #( SUBSTRING expression expression expression ) |
| ; |
| |
| indexOf |
| : #( INDEXOF expression expression ( expression )? ) |
| ; |
| |
| length |
| : #( LENGTH expression ) |
| ; |
| |
| abs |
| : #( ABS expression ) |
| ; |
| |
| sqrt |
| : #( SQRT expression ) |
| ; |
| |
| // ---------------------- |
| // types |
| // ---------------------- |
| |
| type |
| : TYPENAME |
| | primitiveType |
| ; |
| |
| primitiveType |
| : BOOLEAN |
| | BYTE |
| | CHAR |
| | SHORT |
| | INT |
| | FLOAT |
| | LONG |
| | DOUBLE |
| ; |
