| /* |
| * 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 |
| */ |
| |
| /* |
| * CodeGeneration.g |
| * |
| * Created on March 13, 2000 |
| */ |
| |
| header |
| { |
| package com.sun.jdo.spi.persistence.support.sqlstore.query.jqlc; |
| |
| import java.util.*; |
| import java.lang.reflect.Field; |
| import java.lang.IllegalAccessException; |
| |
| import com.sun.jdo.api.persistence.support.JDOFatalUserException; |
| import com.sun.jdo.spi.persistence.support.sqlstore.PersistenceCapable; |
| import com.sun.jdo.spi.persistence.support.sqlstore.PersistenceManager; |
| import com.sun.jdo.spi.persistence.support.sqlstore.RetrieveDesc; |
| import com.sun.jdo.spi.persistence.support.sqlstore.StateManager; |
| |
| import org.glassfish.persistence.common.I18NHelper; |
| import com.sun.jdo.spi.persistence.utility.FieldTypeEnumeration; |
| import com.sun.jdo.spi.persistence.utility.logging.Logger; |
| |
| 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 code generation pass of the JQL compiler. |
| * Input of this pass is the typed and optimized AST as produced by optimizer. |
| * The result is a RetrieveDesc. |
| * |
| * @author Michael Bouschen |
| * @author Shing Wai Chan |
| * @version 0.1 |
| */ |
| class CodeGeneration extends TreeParser; |
| |
| options |
| { |
| importVocab = JQL; |
| ASTLabelType = "JQLAST"; //NOI18N |
| } |
| |
| { |
| /** Name of the USE_IN property. */ |
| public static final String USE_IN_PROPERTY = |
| "com.sun.jdo.spi.persistence.support.sqlstore.query.jqlc.USE_IN"; |
| |
| /** */ |
| private static final boolean USE_IN = Boolean.getBoolean(USE_IN_PROPERTY); |
| |
| /** |
| * I18N support |
| */ |
| protected final static ResourceBundle messages = |
| I18NHelper.loadBundle(CodeGeneration.class); |
| |
| /** |
| * The persistence manager the query object is connected to. |
| */ |
| protected PersistenceManager pm; |
| |
| /** |
| * type table |
| */ |
| protected TypeTable typetab; |
| |
| /** |
| * query parameter table |
| */ |
| protected ParameterTable paramtab; |
| |
| /** |
| * |
| */ |
| protected ErrorMsg errorMsg; |
| |
| /** |
| * prefetchEnabled flag for RetrieveDesc. |
| */ |
| protected boolean prefetchEnabled; |
| |
| /** |
| * The RetrieveDesc for the candidate class. |
| * Code gen for the CLASS_DEF AST will initilaized this variable. |
| * Code gen for the filter expression will add the constraints. |
| */ |
| protected RetrieveDesc candidateRD; |
| |
| /** |
| * rd2TagMap maps RetrieveDesc to tags. A tag is either the variable name or |
| * the navigation path that used to create a new RetrieveDesc. This info is |
| * needed to identify whether two different RetrieveDescs denote the same |
| * variable or relationship. |
| */ |
| protected Map rd2TagMap; |
| |
| /** |
| * Set of RetrieveDescs. CodeGeneration uses this set to prevent multiple |
| * addConstraint calls for the RetrieveDescs denoting a variable. |
| */ |
| protected Set boundRetrieveDescs; |
| |
| /** The logger */ |
| private static Logger logger = LogHelperQueryCompilerJDO.getLogger(); |
| |
| /** |
| * Defines the SQL wildcard character to be used in wildcard pattern |
| * (string methods startsWith and endsWith). |
| */ |
| protected static final String WILDCARD_PATTERN = "%"; //NOI18N |
| |
| /** |
| * |
| */ |
| public void init(PersistenceManager pm, TypeTable typetab, |
| ParameterTable paramtab, ErrorMsg errorMsg, |
| boolean prefetchEnabled) |
| { |
| this.pm = pm; |
| this.typetab = typetab; |
| this.paramtab = paramtab; |
| this.errorMsg = errorMsg; |
| this.prefetchEnabled = prefetchEnabled; |
| this.rd2TagMap = new HashMap(); |
| this.boundRetrieveDescs = new HashSet(); |
| } |
| |
| /** |
| * |
| */ |
| public void reportError(RecognitionException ex) { |
| errorMsg.fatal("CodeGeneration error", ex); //NOI18N |
| } |
| |
| /** |
| * |
| */ |
| public void reportError(String s) { |
| errorMsg.fatal("CodeGeneration error: " + s); //NOI18N |
| } |
| |
| /** |
| * Returns the RetrieveDesc that represents the current query. |
| */ |
| public RetrieveDesc getRetrieveDesc() |
| { |
| if (candidateRD instanceof DebugRetrieveDesc) |
| return ((DebugRetrieveDesc)candidateRD).wrapped; |
| return candidateRD; |
| } |
| |
| /** |
| * Helper method for checkRetrieveDesc handling operators & and &&. |
| */ |
| protected void checkAndOpRetrieveDesc(JQLAST op, JQLAST left, |
| JQLAST right, Map usedRD) throws RecognitionException |
| { |
| if ((right.getType() == CONTAINS) || (right.getType() == NOT_CONTAINS)) |
| { |
| // If right is a CONTAINS clause, start analysing the right expr. |
| // This ensures that the lft expression can reuse the RD defined |
| // for the variable from the contains clause |
| checkRetrieveDesc(right, usedRD); |
| checkRetrieveDesc(left, usedRD); |
| } |
| else |
| { |
| checkRetrieveDesc(left, usedRD); |
| checkRetrieveDesc(right, usedRD); |
| } |
| op.setRetrieveDesc(getCommonRetrieveDesc(left, right)); |
| } |
| |
| /** |
| * Check the attached RetrieveDesc of the specified binary operation and its operands. |
| */ |
| protected RetrieveDesc getCommonRetrieveDesc(JQLAST left, JQLAST right) |
| { |
| RetrieveDesc rd = null; |
| RetrieveDesc leftRD = left.getRetrieveDesc(); |
| RetrieveDesc rightRD = right.getRetrieveDesc(); |
| |
| if ((leftRD == null) && (rightRD != null)) |
| { |
| // case 1: no RetrieveDesc for left operand, but right operand returns RetrieveDesc |
| // attach the right RetrieveDesc to all nodes of the left subtree |
| propagateRetrieveDesc(left, rightRD); |
| rd = rightRD; |
| } |
| |
| else if ((leftRD != null) && (rightRD == null)) |
| { |
| // case 2: no RetrieveDesc for right operand, but left operand returns RetrieveDesc |
| // attach the left RetrieveDesc to all nodes of the right subtree |
| propagateRetrieveDesc(right, leftRD); |
| rd = leftRD; |
| } |
| else if ((leftRD != null) && (rightRD != null)) |
| { |
| // case 3: both left and right operand have a RetrieveDesc attached |
| if (leftRD == rightRD) |
| { |
| // case 3a: left and right RetrieveDesc are identical |
| rd = leftRD; |
| } |
| else |
| { |
| // case 3b: left and right RetrieveDesc are NOT identical |
| // check navigation: |
| rd = getCommonRetrieveDescHelper(leftRD, findNavigationSource(left), |
| rightRD, findNavigationSource(right)); |
| |
| // use leftRD as default |
| if (rd == null) |
| { |
| rd = leftRD; |
| } |
| } |
| } |
| return rd; |
| } |
| |
| /** Helper method for getCommonRetrieveDesc used to check navigation. */ |
| protected RetrieveDesc getCommonRetrieveDescHelper( |
| RetrieveDesc leftRD, JQLAST leftNavSrc, |
| RetrieveDesc rightRD, JQLAST rightNavSrc) |
| { |
| RetrieveDesc rd = null; |
| String leftPath = (String)rd2TagMap.get(leftRD); |
| String rightPath = (String)rd2TagMap.get(rightRD); |
| RetrieveDesc leftNavSrcRD = |
| (leftNavSrc == null) ? null : leftNavSrc.getRetrieveDesc(); |
| String leftNavSrcPath = |
| (leftNavSrcRD == null ) ? null: (String)rd2TagMap.get(leftNavSrcRD); |
| RetrieveDesc rightNavSrcRD = |
| (rightNavSrc == null) ? null : rightNavSrc.getRetrieveDesc(); |
| String rightNavSrcPath = |
| (rightNavSrcRD == null) ? null : (String)rd2TagMap.get(rightNavSrcRD); |
| |
| if ((leftNavSrcPath != null) && leftNavSrcPath.equals(rightPath)) |
| { |
| // case I: left operand is a navigation and |
| // the navigation source is equal to the right operand |
| rd = rightRD; |
| } |
| else if ((rightNavSrcPath != null) && rightNavSrcPath.equals(leftPath)) |
| { |
| // case II: right operand is a navigation and |
| // the navigation source is equal to the left operand |
| rd = leftRD; |
| } |
| else if ((leftNavSrcPath != null) && (rightNavSrcPath != null) && |
| leftNavSrcPath.equals(rightNavSrcPath)) |
| { |
| // case III: both operands are navigations and have the same source |
| rd = leftNavSrcRD; |
| } |
| else { |
| // case IV: check whether the navigation source is a bound variable. |
| // If yes, check the collection source |
| JQLAST leftConstraint = findNavigationSourceOfBoundVariable(leftNavSrc); |
| JQLAST rightConstraint = findNavigationSourceOfBoundVariable(rightNavSrc); |
| if ((leftConstraint != null) && (rightConstraint != null)) |
| { |
| rd = getCommonRetrieveDescHelper(leftRD, leftConstraint, |
| rightRD, rightConstraint); |
| } |
| else if ((leftConstraint == null) && (rightConstraint != null)) |
| { |
| rd = getCommonRetrieveDescHelper(leftRD, leftNavSrc, |
| rightRD, rightConstraint); |
| } |
| else if ((leftConstraint != null) && (rightConstraint == null)) |
| { |
| rd = getCommonRetrieveDescHelper(leftRD, leftConstraint, |
| rightRD, rightNavSrc); |
| } |
| } |
| return rd; |
| } |
| |
| /** |
| * Helper method to support getting the common RetrieveDesc for operands |
| * taking three arguments such as like with escape, substring, indexOf. |
| */ |
| protected RetrieveDesc getCommonRetrieveDesc(JQLAST arg1, JQLAST arg2, JQLAST arg3) |
| { |
| RetrieveDesc rd = null; |
| if (arg3 == null) { |
| // Just call the regular method for binray ops, |
| // if the third argument is not specified. |
| rd = getCommonRetrieveDesc(arg1, arg2); |
| } |
| else { |
| // First check args two and three. |
| getCommonRetrieveDesc(arg2, arg3); |
| // Now check the first and the second arg. |
| rd = getCommonRetrieveDesc(arg1, arg2); |
| // Propagate the common RetrieveDesc to the third arg. |
| // This is important, if arg two and three are literals. |
| // Then the first call checking arg2 and arg3 did not attach any |
| // RetrieveDesc. The second call checking arg1 and arg2 might have |
| // propagated a rd from arg1 to arg2. So this propagateRetrieveDesc |
| // call propagates this rd to arg3, too. |
| propagateRetrieveDesc(arg3, rd); |
| } |
| return rd; |
| } |
| |
| /** |
| * Helper method to support getting the common RetrieveDesc for object |
| * comparison operators. |
| */ |
| protected RetrieveDesc getObjectComparisonRetrieveDesc(JQLAST left, JQLAST right) |
| { |
| RetrieveDesc rd = null; |
| if ((left.getType() == NAVIGATION) && |
| (right.getType() == VALUE) && (right.getValue() == null)) |
| { |
| // case obj.relship == null |
| // take the RetrieveDesc from the navigation source |
| rd = ((JQLAST)left.getFirstChild()).getRetrieveDesc(); |
| } |
| else if ((left.getType() == VALUE) && (left.getValue() == null) && |
| (right.getType() == NAVIGATION)) |
| { |
| // case null == obj.relship |
| // take the RetrieveDesc from the navigation source |
| rd = ((JQLAST)right.getFirstChild()).getRetrieveDesc(); |
| } |
| else |
| { |
| // use regular getCommonRetrieveDesc |
| rd = getCommonRetrieveDesc(left, right); |
| } |
| return rd; |
| } |
| |
| /** |
| * Returns the source if a navigation or field access. |
| */ |
| protected JQLAST findNavigationSource(JQLAST tree) |
| { |
| JQLAST child = (JQLAST)tree.getFirstChild(); |
| switch (tree.getType()) |
| { |
| case NOT_IN: |
| case FIELD_ACCESS: |
| case NAVIGATION: |
| return findNavigationSource(child); |
| case THIS: |
| case VARIABLE: |
| return tree; |
| case CONTAINS: |
| case NOT_CONTAINS: |
| return null; |
| default: |
| for (JQLAST node = child; node != null; node = (JQLAST)node.getNextSibling()) |
| { |
| JQLAST tmp = findNavigationSource(node); |
| if (tmp != null) |
| return tmp; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * If the specifid node is a bound variable return the navigation source of |
| * it's collection. |
| */ |
| protected JQLAST findNavigationSourceOfBoundVariable(JQLAST tree) |
| { |
| if ((tree.getType() == VARIABLE) && (tree.getFirstChild() != null)) |
| return findNavigationSource((JQLAST)tree.getFirstChild()); |
| return null; |
| } |
| |
| /** |
| * Attach the specified RetrieveDesc to all JQLAST node of the ast subtree, |
| * that do not have a RetrieveDesc attached. |
| */ |
| protected void propagateRetrieveDesc(JQLAST ast, RetrieveDesc rd) |
| { |
| if (ast.getRetrieveDesc() == null) |
| { |
| ast.setRetrieveDesc(rd); |
| } |
| for (JQLAST node = (JQLAST)ast.getFirstChild(); |
| node != null; |
| node = (JQLAST)node.getNextSibling()) |
| { |
| propagateRetrieveDesc(node, rd); |
| } |
| } |
| |
| /** |
| * Returns an Object representing 0 according to the specified type. |
| */ |
| protected Object getZeroValue(Type type) |
| { |
| return (type instanceof NumberType) ? |
| ((NumberType)type).getValue(new Integer(0)) : |
| null; |
| } |
| |
| /** |
| * Returns an Object representing -1 according to the specified type. |
| */ |
| protected Object getMinusOneValue(Type type) |
| { |
| return (type instanceof NumberType) ? |
| ((NumberType)type).getValue(new Integer(-1)) : |
| null; |
| } |
| |
| /** |
| * Returns -value. |
| * The method assumes that the passed argument is a numeric wrapper class object. |
| * If so it negates the wrapped numeric value and wraps the negated value into a |
| * numeric wrapper class object. |
| */ |
| protected Object negate(Object value, Type type) |
| { |
| return (type instanceof NumberType) ? |
| ((NumberType)type).negate((Number)value) : |
| null; |
| } |
| |
| /** |
| * Returns the boolean operation of the equivalent relational expression |
| * with swapped arguments. |
| * expr1 > expr2 <=> expr2 < expr1 |
| */ |
| protected int getSwappedOp(int operation) |
| { |
| int ret = 0; |
| switch (operation) |
| { |
| case RetrieveDesc.OP_EQ: |
| ret = RetrieveDesc.OP_EQ; |
| break; |
| case RetrieveDesc.OP_NE: |
| ret = RetrieveDesc.OP_NE; |
| break; |
| case RetrieveDesc.OP_LT: |
| ret = RetrieveDesc.OP_GT; |
| break; |
| case RetrieveDesc.OP_LE: |
| ret = RetrieveDesc.OP_GE; |
| break; |
| case RetrieveDesc.OP_GT: |
| ret = RetrieveDesc.OP_LT; |
| break; |
| case RetrieveDesc.OP_GE: |
| ret = RetrieveDesc.OP_LE; |
| break; |
| } |
| return ret; |
| } |
| |
| /** |
| * Code generation for a comparison of the form field relop value, |
| * where field denotes a non relationship field |
| * This method checks for null values and generates OP_NULL / OP_NOTNULL constraints |
| * in the case of field relop null |
| */ |
| protected void generateSimpleFieldValueComparison(RetrieveDesc rd, String name, |
| int operation, Object value) |
| { |
| if (value != null) |
| { |
| rd.addConstraint(name, operation, value); |
| } |
| else if (operation == RetrieveDesc.OP_EQ) |
| { |
| rd.addConstraint(name, RetrieveDesc.OP_NULL, null); |
| } |
| else if (operation == RetrieveDesc.OP_NE) |
| { |
| rd.addConstraint(name, RetrieveDesc.OP_NOTNULL, null); |
| } |
| else |
| { |
| errorMsg.fatal(I18NHelper.getMessage(messages, "jqlc.codegeneration.generatesimplefieldvaluecomparison.invalidvalue")); //NOI18N |
| } |
| } |
| |
| /** |
| * Code generation for a comparison of the form |
| * dbvalue relop constant |
| * where dbvalue denotes an object in the database such as |
| * - this |
| * - the result of a relationship navigation |
| * - variable access |
| * and constant is a constant value at query compile time (e.g. a literal) |
| */ |
| protected void generateDbValueConstantComparison(RetrieveDesc rd, ClassType objectType, |
| int operation, Object value, Type valueType) |
| { |
| int booleanOp = getKeyFieldsComparisonBooleanOp(operation); |
| |
| List keyFieldNames = objectType.getKeyFieldNames(); |
| for (Iterator i = keyFieldNames.iterator(); i.hasNext();) |
| { |
| String keyFieldName = (String)i.next(); |
| Object keyFieldValue = null; |
| if (value != null) |
| { |
| keyFieldValue = getFieldValue((ClassType)valueType, value, keyFieldName); |
| } |
| generateSimpleFieldValueComparison(rd, keyFieldName, operation, keyFieldValue); |
| if (i.hasNext()) |
| rd.addConstraint(null, booleanOp, null); |
| } |
| } |
| |
| /** |
| * Code generation for a comparison of the form |
| * dbvalue relop dbvalue |
| * where dbvalue denotes an object in the database such as |
| * - this |
| * - the result of a relationship navigation |
| * - variable access |
| */ |
| protected void generateDbValueDbValueComparison(RetrieveDesc leftRD, ClassType leftType, int operation, |
| RetrieveDesc rightRD, ClassType rightType) |
| { |
| int booleanOp = getKeyFieldsComparisonBooleanOp(operation); |
| |
| // Note, this code assumes that both operands are of class types that have |
| // the same key fields. Thus take the list of key field names of the left side. |
| List leftKeyFieldNames = leftType.getKeyFieldNames(); |
| for (Iterator i = leftKeyFieldNames.iterator(); i.hasNext();) |
| { |
| String keyFieldName = (String)i.next(); |
| leftRD.addConstraint(keyFieldName, operation, rightRD, keyFieldName); |
| if (i.hasNext()) |
| leftRD.addConstraint(null, booleanOp, null); |
| } |
| } |
| |
| /** |
| * Code generation for a comparison of the form |
| * parameter relop constantValue |
| */ |
| protected void generateParameterValueComparison(RetrieveDesc rd, |
| String paramName, |
| int operation, Object value) |
| { |
| if (value != null) |
| { |
| rd.addConstraint(null, RetrieveDesc.OP_VALUE, value); |
| rd.addConstraint(null, RetrieveDesc.OP_PARAMETER, |
| paramtab.getParameterInfoForParamName(paramName)); |
| rd.addConstraint(null, operation, null); |
| } |
| else if (operation == RetrieveDesc.OP_EQ) |
| { |
| rd.addConstraint(null, RetrieveDesc.OP_PARAMETER, |
| paramtab.getParameterInfoForParamName(paramName)); |
| rd.addConstraint(null, RetrieveDesc.OP_NULL, null); |
| } |
| else if (operation == RetrieveDesc.OP_NE) |
| { |
| rd.addConstraint(null, RetrieveDesc.OP_PARAMETER, |
| paramtab.getParameterInfoForParamName(paramName)); |
| rd.addConstraint(null, RetrieveDesc.OP_NOTNULL, null); |
| } |
| else |
| { |
| errorMsg.fatal(I18NHelper.getMessage(messages, "jqlc.codegeneration.generateparametervaluecomparison.invalidvalue")); //NOI18N |
| } |
| } |
| |
| /** |
| * Returns the boolean operation used to connect the key field comparison expressions: |
| * l == r is mapped to l.pk1 == r.pk1 & ... & l.pkn == r.pkn => return & |
| * l != r is mapped to l.pk1 != r.pk1 | ... | l.pkn != r.pkn => return | |
| */ |
| protected int getKeyFieldsComparisonBooleanOp(int operation) |
| { |
| switch (operation) |
| { |
| case RetrieveDesc.OP_EQ: |
| return RetrieveDesc.OP_AND; |
| case RetrieveDesc.OP_NE: |
| return RetrieveDesc.OP_OR; |
| } |
| errorMsg.fatal(I18NHelper.getMessage(messages, |
| "jqlc.codegeneration.getkeyfieldscomparisonbooleanop.invalidobj", //NOI18N |
| String.valueOf(operation))); |
| return 0; |
| } |
| |
| /** |
| * Returns the value of the field access object.field. |
| * Uses jdoGetField for object of a persistence capable class and reflection otherwise. |
| */ |
| protected static Object getFieldValue (ClassType classType, Object object, String fieldName) |
| { |
| Object value = null; |
| FieldInfo fieldInfo = classType.getFieldInfo(fieldName); |
| if (classType.isPersistenceCapable()) |
| { |
| PersistenceCapable pc = (PersistenceCapable)object; |
| int index = fieldInfo.getFieldNumber(); |
| StateManager stateManager = pc.jdoGetStateManager(); |
| |
| if (stateManager != null) |
| { |
| // call stateManager.prepareGetField to allow the stateManager |
| // to mediate the field access |
| stateManager.prepareGetField(index); |
| } |
| value = pc.jdoGetField(index); |
| } |
| else |
| { |
| // non persistence capable class => use reflection |
| try |
| { |
| value = fieldInfo.getField().get(object); |
| } |
| catch (IllegalAccessException e) |
| { |
| throw new JDOFatalUserException( |
| I18NHelper.getMessage(messages, "jqlc.codegeneration.fieldaccess.illegal", //NOI18N |
| fieldName, (object==null ? "null" : object.toString())), e); //NOI18N |
| } |
| } |
| return value; |
| } |
| |
| /** |
| * This method checks whether the result RetrieveDesc needs a DISTINCT clause or not. |
| * @param query the query AST |
| */ |
| protected void handleDistinct(JQLAST query, boolean distinct) |
| { |
| // candidateRD is null in the case of false filter |
| if (candidateRD == null) |
| return; |
| |
| if (distinct) |
| candidateRD.addResult(RetrieveDesc.OP_DISTINCT, FieldTypeEnumeration.NOT_ENUMERATED); |
| } |
| |
| /** |
| * This method returns true if the specified node is an AST that represensts a value. |
| * It returns false for CONTAINS/NOT_CONTAINS nodes and boolean operations that include |
| * only CONTAINS nodes |
| */ |
| protected boolean pushesValueOnStack(JQLAST node) |
| { |
| switch(node.getType()) |
| { |
| case CONTAINS: |
| case NOT_CONTAINS: |
| return false; |
| case BAND: |
| case BOR: |
| case AND: |
| case OR: |
| JQLAST left = (JQLAST)node.getFirstChild(); |
| JQLAST right = (JQLAST)left.getNextSibling(); |
| return pushesValueOnStack(left) || pushesValueOnStack(right); |
| default: |
| return true; |
| } |
| } |
| |
| /** |
| * Create a new RetrieveDesc for the specified classType and |
| * store this RetrieveDesc in the cache with the specified path expression attached. |
| * The method wraps the RetrieveDesc in a DebugRetrieveDesc, if debug mode is on. |
| */ |
| protected RetrieveDesc createRetrieveDesc(String pathExpr, ClassType classType) |
| { |
| RetrieveDesc rd = pm.getRetrieveDesc(classType.getJavaClass()); |
| if (logger.isLoggable(Logger.FINEST)) |
| { |
| rd = new DebugRetrieveDesc(rd); |
| logger.finest("LOG_JQLCDumpRD", "create " + JQLAST.getRetrieveDescRepr(rd)); //NOI18N |
| } |
| rd2TagMap.put(rd, pathExpr); |
| rd.setNavigationalId(pathExpr); |
| return rd; |
| } |
| |
| /** |
| * Wrapper that traces the RetrieveDesc calls |
| */ |
| protected static class DebugRetrieveDesc implements RetrieveDesc |
| { |
| RetrieveDesc wrapped = null; |
| |
| DebugRetrieveDesc(RetrieveDesc wrapped) |
| { |
| this.wrapped = wrapped; |
| } |
| |
| public RetrieveDesc unwrap(RetrieveDesc rd) |
| { |
| if (rd instanceof DebugRetrieveDesc) |
| return ((DebugRetrieveDesc)rd).wrapped; |
| return rd; |
| } |
| |
| // methods from RetrieveDesc |
| public void addResult(String name, RetrieveDesc desc, boolean projection) |
| { |
| if (logger.isLoggable(Logger.FINEST)) |
| logger.finest("LOG_JQLCDumpRD", //NOI18N |
| JQLAST.getRetrieveDescRepr(this) + ".addResult(" + //NOI18N |
| name + ", " + JQLAST.getRetrieveDescRepr(desc) + ", " + //NOI18N |
| projection + ")"); //NOI18N |
| desc = unwrap(desc); |
| wrapped.addResult(name, desc, projection); |
| } |
| |
| public void addResult(int opCode, int resultType) |
| { |
| if (logger.isLoggable(Logger.FINEST)) |
| logger.finest("LOG_JQLCDumpRD", //NOI18N |
| JQLAST.getRetrieveDescRepr(this) + ".addResult(" + //NOI18N |
| opCode + ", " + resultType + ")"); //NOI18N |
| wrapped.addResult(opCode, resultType); |
| } |
| |
| public void addConstraint(String name, int operation, Object value) |
| { |
| String thirdArgRepr = null; |
| if (value instanceof RetrieveDesc) |
| { |
| RetrieveDesc foreignConstraint = (RetrieveDesc)value; |
| thirdArgRepr = JQLAST.getRetrieveDescRepr(foreignConstraint); |
| value = unwrap(foreignConstraint); |
| } |
| else |
| { |
| thirdArgRepr = (value == null) ? "null" : value.toString(); |
| } |
| if (logger.isLoggable(Logger.FINEST)) |
| logger.finest("LOG_JQLCDumpRD", //NOI18N |
| JQLAST.getRetrieveDescRepr(this) + ".addConstraint(" + //NOI18N |
| name + ", " + operation + ", " + thirdArgRepr + ")"); //NOI18N |
| wrapped.addConstraint(name, operation, value); |
| } |
| |
| public void addConstraint(String name, RetrieveDesc foreignConstraint) |
| { |
| if (logger.isLoggable(Logger.FINEST)) |
| logger.finest("LOG_JQLCDumpRD", //NOI18N |
| JQLAST.getRetrieveDescRepr(this) + ".addConstraint(" + //NOI18N |
| name + ", " + JQLAST.getRetrieveDescRepr(foreignConstraint) + ")"); //NOI18N |
| foreignConstraint = unwrap(foreignConstraint); |
| wrapped.addConstraint(name, foreignConstraint); |
| } |
| |
| public void addConstraint(String name, int operator, RetrieveDesc foreignConstraint, String foreignFieldName) |
| { |
| if (logger.isLoggable(Logger.FINEST)) |
| logger.finest("LOG_JQLCDumpRD", //NOI18N |
| JQLAST.getRetrieveDescRepr(this) + ".addConstraint(" + //NOI18N |
| name + ", " + operator + ", " + JQLAST.getRetrieveDescRepr(foreignConstraint) + //NOI18N |
| ", " + foreignFieldName + ")"); //NOI18N |
| foreignConstraint = unwrap(foreignConstraint); |
| wrapped.addConstraint(name, operator, foreignConstraint, foreignFieldName); |
| } |
| |
| public void setNavigationalId(Object navigationalId) |
| { |
| if (logger.isLoggable(Logger.FINEST)) |
| logger.finest("LOG_JQLCDumpRD", //NOI18N |
| JQLAST.getRetrieveDescRepr(this) + |
| ".setNavigationalId(" + navigationalId + ")"); //NOI18N |
| wrapped.setNavigationalId(navigationalId); |
| } |
| |
| public void setPrefetchEnabled(boolean prefetchEnabled) |
| { |
| if (logger.isLoggable(Logger.FINEST)) |
| logger.finest("LOG_JQLCDumpRD", //NOI18N |
| JQLAST.getRetrieveDescRepr(this) + |
| ".setPrefetchEnabled(" + prefetchEnabled + ")"); //NOI18N |
| wrapped.setPrefetchEnabled(prefetchEnabled); |
| } |
| |
| // Methods from ActionDesc |
| |
| public Class getPersistenceCapableClass() |
| { return wrapped.getPersistenceCapableClass(); } |
| } |
| } |
| |
| // rules |
| |
| query |
| : q:. |
| { |
| prepareRetrieveDescs(q); |
| if (logger.isLoggable(Logger.FINEST)) |
| logger.finest("LOG_JQLCDumpTree", q.getTreeRepr("RD annotated AST")); //NOI18N |
| doCodeGen(q); |
| } |
| ; |
| |
| doCodeGen |
| { |
| boolean distinct = false; |
| } |
| : #( q:QUERY |
| candidateClass |
| parameters |
| variables |
| ordering |
| distinct = result |
| filter |
| ) |
| { |
| handleDistinct(q, distinct); |
| } |
| ; |
| |
| // ---------------------------------- |
| // rules: candidate class |
| // ---------------------------------- |
| |
| candidateClass |
| { |
| errorMsg.setContext("setCandidates"); //NOI18N |
| } |
| : c:CLASS_DEF |
| // Note, DISTINCT is added by handleDistinct called in the rule query |
| ; |
| // ---------------------------------- |
| // 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 i:IDENT ) |
| ; |
| |
| // ---------------------------------- |
| // rules: ordering specification |
| // ---------------------------------- |
| |
| ordering |
| { |
| errorMsg.setContext("setOrdering"); //NOI18N |
| } |
| : ( orderSpec )* |
| ; |
| |
| orderSpec |
| { |
| int op = 0; |
| } |
| : #( ORDERING_DEF |
| ( ASCENDING { op = RetrieveDesc.OP_ORDERBY; } |
| | DESCENDING { op = RetrieveDesc.OP_ORDERBY_DESC; } |
| ) |
| orderingExpr[op] |
| ) |
| ; |
| |
| orderingExpr [int op] |
| : ( #( FIELD_ACCESS expression IDENT) )=> #( f:FIELD_ACCESS expression i:IDENT ) |
| { |
| f.getRetrieveDesc().addConstraint(i.getText(), op, null); |
| } |
| | e:. |
| { |
| errorMsg.unsupported(e.getLine(), e.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.codegeneration.generic.unsupportedop", // NOI18N |
| e.getText())); |
| } |
| ; |
| |
| // ---------------------------------- |
| // rules: result expression |
| // ---------------------------------- |
| |
| result returns [boolean distinct] |
| { |
| errorMsg.setContext("setResult"); //NOI18N |
| distinct = false; |
| } |
| : #( RESULT_DEF |
| distinct = resultExpr[true] |
| ) |
| | { |
| // no result is equivalent to setResult("distinct this") => |
| // distinct is true |
| distinct = true; |
| } |
| ; |
| |
| resultExpr [boolean outer] returns [boolean distinct] |
| { |
| String name = null; |
| // this should be take care at first level of recursion |
| distinct = false; |
| boolean tmp; |
| } |
| : #( d:DISTINCT tmp = resultExpr[outer] ) |
| { |
| distinct = true; |
| } |
| | #( avg:AVG distinct = resultExpr[true] ) |
| { |
| candidateRD.addResult(RetrieveDesc.OP_AVG, |
| avg.getJQLType().getEnumType()); |
| } |
| | #( max:MAX distinct = resultExpr[true] ) |
| { |
| candidateRD.addResult(RetrieveDesc.OP_MAX, |
| max.getJQLType().getEnumType()); |
| } |
| | #( min:MIN distinct = resultExpr[true] ) |
| { |
| candidateRD.addResult(RetrieveDesc.OP_MIN, |
| min.getJQLType().getEnumType()); |
| } |
| | #( sum:SUM distinct = resultExpr[true] ) |
| { |
| candidateRD.addResult(RetrieveDesc.OP_SUM, |
| sum.getJQLType().getEnumType()); |
| } |
| | #( count:COUNT distinct = r:resultExpr[true] ) |
| { |
| Type resultType = r.getJQLType(); |
| if (typetab.isPersistenceCapableType(resultType)) { |
| List pkfields = ((ClassType)resultType).getKeyFieldNames(); |
| if (pkfields != null) { |
| candidateRD.addResult(RetrieveDesc.OP_COUNT_PC, |
| count.getJQLType().getEnumType()); |
| } else { |
| errorMsg.unsupported(r.getLine(), r.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.codegeneration.resultexpr.missingpkfields", // NOI18N |
| resultType.getName())); |
| } |
| } else { |
| candidateRD.addResult(RetrieveDesc.OP_COUNT, |
| count.getJQLType().getEnumType()); |
| } |
| } |
| | #( op1:FIELD_ACCESS tmp = expr1:resultExpr[false] i1:IDENT ) |
| { |
| op1.getRetrieveDesc().addResult(i1.getText(), null, true); |
| } |
| | #( op2:NAVIGATION tmp = expr2:resultExpr[false] i2:IDENT ) |
| { |
| RetrieveDesc from = expr2.getRetrieveDesc(); |
| RetrieveDesc to = op2.getRetrieveDesc(); |
| from.addResult(i2.getText(), to, outer); |
| } |
| | #( op3:VARIABLE ( name = col3:collectionExprResult )? ) |
| { |
| if (col3 != null) { |
| RetrieveDesc from = col3.getRetrieveDesc(); |
| RetrieveDesc to = op3.getRetrieveDesc(); |
| from.addResult(name, to, outer); |
| } |
| } |
| | THIS |
| ; |
| |
| collectionExprResult returns [String fieldName] |
| { |
| fieldName = null; |
| boolean tmp; |
| } |
| : #( FIELD_ACCESS tmp = resultExpr[false] name1:IDENT ) |
| { fieldName = name1.getText(); } |
| | #( NAVIGATION tmp = resultExpr[false] name2:IDENT ) |
| { fieldName = name2.getText(); } |
| | #( TYPECAST . fieldName = collectionExprResult ) |
| | #( NOT_IN fieldName = collectionExprResult ) |
| ; |
| |
| // ---------------------------------- |
| // rules: filer expression |
| // |
| // NOTE: the code generator traverses operands of binary operations in reverse order. |
| // The reason is that the RetrieveDesc processes the constriant stack in a LIFO way. |
| // This means, the code generator has to process the right operand first, |
| // then the left operand and finally the operation. |
| // ---------------------------------- |
| |
| filter |
| { |
| errorMsg.setContext("setFilter"); //NOI18N |
| } |
| : #( FILTER_DEF expr:. ) |
| { |
| switch (expr.getType()) { |
| case VALUE: |
| // constant filter |
| Object value = expr.getValue(); |
| if (value instanceof Boolean) |
| { |
| // Note, in the case of a true filter do not add |
| // any constraints to the candidateRD |
| |
| if (!((Boolean)value).booleanValue()) |
| { |
| // false filter => unset candidateRD |
| candidateRD = null; |
| } |
| } |
| else |
| { |
| errorMsg.fatal(I18NHelper.getMessage(messages, |
| "jqlc.codegeneration.filter.nonbooleanvalue", //NOI18N |
| String.valueOf(value))); |
| } |
| break; |
| case FIELD_ACCESS: |
| // The entire filter consists of a boolean field only. |
| // Map this to 'booleanField <> FALSE'. Note, the runtime will |
| // create a JDBC parameter for the literal FALSE and call |
| // setBoolean to bind the value. |
| RetrieveDesc rd = expr.getRetrieveDesc(); |
| rd.addConstraint(null, RetrieveDesc.OP_VALUE, Boolean.FALSE); |
| expression(expr); |
| rd.addConstraint(null, RetrieveDesc.OP_NE, null); |
| break; |
| default: |
| expression(expr); |
| break; |
| } |
| } |
| ; |
| |
| expression |
| : ( primary )=> primary |
| | bitwiseExpr |
| | conditionalExpr |
| | relationalExpr |
| | binaryArithmeticExpr |
| | unaryArithmeticExpr |
| | complementExpr |
| ; |
| |
| // This rule transforms an access expression of a boolean field into an |
| // equal operation: expr == true. |
| booleanOperationArgument |
| : e:expression |
| { |
| if (#e.getType() == FIELD_ACCESS) { |
| RetrieveDesc rd = #e.getRetrieveDesc(); |
| rd.addConstraint(null, RetrieveDesc.OP_VALUE, Boolean.TRUE); |
| rd.addConstraint(null, RetrieveDesc.OP_EQ, null); |
| } |
| } |
| ; |
| |
| bitwiseExpr |
| : #( op1:BAND left1:. right1:booleanOperationArgument ) |
| { |
| booleanOperationArgument(left1); |
| // do not generate boolean operation if one of the operands is variable constraint |
| if (pushesValueOnStack(left1) && pushesValueOnStack(right1)) |
| op1.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_AND, null); |
| } |
| | #( op2:BOR left2:. right2:booleanOperationArgument ) |
| { |
| booleanOperationArgument(left2); |
| // do not generate boolean operation if one of the operands is variable constraint |
| if (pushesValueOnStack(left2) && pushesValueOnStack(right2)) |
| op2.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_OR, null); |
| } |
| | #( op3:BXOR left3:. right3:booleanOperationArgument ) |
| { |
| booleanOperationArgument(left3); |
| errorMsg.unsupported(op3.getLine(), op3.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.codegeneration.generic.unsupportedop", // NOI18N |
| op3.getText())); |
| } |
| ; |
| |
| conditionalExpr |
| : #( op1:AND left1:. right1:booleanOperationArgument ) |
| { |
| booleanOperationArgument(left1); |
| // do not generate boolean operation if one of the operands is variable constraint |
| if (pushesValueOnStack(left1) && pushesValueOnStack(right1)) |
| op1.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_AND, null); |
| } |
| | #( op2:OR left2:. right2:booleanOperationArgument ) |
| { |
| booleanOperationArgument(left2); |
| // do not generate boolean operation if one of the operands is variable constraint |
| if (pushesValueOnStack(left2) && pushesValueOnStack(right2)) |
| op2.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_OR, null); |
| } |
| ; |
| |
| relationalExpr |
| : ( fieldComparison )=> fieldComparison |
| | ( objectComparison )=> objectComparison |
| | ( collectionComparison )=> collectionComparison |
| | ( parameterComparison )=> parameterComparison |
| | #( op1:EQUAL left1:. expression ) |
| { |
| expression(left1); |
| op1.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_EQ, null); |
| } |
| | #( op2:NOT_EQUAL left2:. expression ) |
| { |
| expression(left2); |
| op2.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_NE, null); |
| } |
| | #( op3:LT left3:. expression ) |
| { |
| expression(left3); |
| op3.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_LT, null); |
| } |
| | #( op4:GT left4:. expression ) |
| { |
| expression(left4); |
| op4.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_GT, null); |
| } |
| | #( op5:LE left5:. expression ) |
| { |
| expression(left5); |
| op5.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_LE, null); |
| } |
| | #( op6:GE left6:. expression ) |
| { |
| expression(left6); |
| op6.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_GE, null); |
| } |
| ; |
| |
| fieldComparison |
| : #(EQUAL fieldComparisonOperands[RetrieveDesc.OP_EQ] ) |
| | #(NOT_EQUAL fieldComparisonOperands[RetrieveDesc.OP_NE] ) |
| | #(LT fieldComparisonOperands[RetrieveDesc.OP_LT] ) |
| | #(LE fieldComparisonOperands[RetrieveDesc.OP_LE] ) |
| | #(GT fieldComparisonOperands[RetrieveDesc.OP_GT] ) |
| | #(GE fieldComparisonOperands[RetrieveDesc.OP_GE] ) |
| ; |
| |
| fieldComparisonOperands [int operation] |
| { |
| String leftName = null; |
| String rightName = null; |
| Object value = null; |
| } |
| : value = constantValue rightName = f1:fieldAccess |
| { |
| // case constant relop field |
| generateSimpleFieldValueComparison(f1.getRetrieveDesc(), rightName, |
| getSwappedOp(operation), value); |
| } |
| | p1:PARAMETER rightName = f2:fieldAccess |
| { |
| // case parameter relop field |
| // Support for fixed-width char pk columns |
| f2.getRetrieveDesc().addConstraint(rightName, RetrieveDesc.OP_FIELD, null); |
| f2.getRetrieveDesc().addConstraint(null, |
| RetrieveDesc.OP_PARAMETER, |
| paramtab.getParameterInfoForParamName(p1.getText(), rightName)); |
| f2.getRetrieveDesc().addConstraint(null, operation, null); |
| } |
| | leftName = f3:fieldAccess |
| ( value = constantValue |
| { |
| // case field relop constant |
| generateSimpleFieldValueComparison(f3.getRetrieveDesc(), leftName, |
| operation, value); |
| } |
| | rightName = f4:fieldAccess |
| { |
| // case field relop field |
| f3.getRetrieveDesc().addConstraint(leftName, operation, |
| f4.getRetrieveDesc(), rightName); |
| } |
| | p2:PARAMETER |
| { |
| // case field relop parameter |
| // Support for fixed-width char pk columns |
| f3.getRetrieveDesc().addConstraint(null, |
| RetrieveDesc.OP_PARAMETER, |
| paramtab.getParameterInfoForParamName(p2.getText(), leftName)); |
| f3.getRetrieveDesc().addConstraint(leftName, RetrieveDesc.OP_FIELD, null); |
| f3.getRetrieveDesc().addConstraint(null, operation, null); |
| } |
| ) |
| ; |
| |
| objectComparison |
| { |
| Object value = null; |
| } |
| : #( OBJECT_EQUAL objectComparisonOperands[RetrieveDesc.OP_EQ] ) |
| | #( OBJECT_NOT_EQUAL objectComparisonOperands[RetrieveDesc.OP_NE] ) |
| ; |
| |
| objectComparisonOperands [int operation] |
| { |
| Object value = null; |
| } |
| : value = v1:constantValue d1:dbValue |
| // case constant relop dbvalue |
| { |
| if ((value == null) && (d1.getType() == NAVIGATION)) |
| { |
| JQLAST expr = (JQLAST)d1.getFirstChild(); |
| JQLAST ident = (JQLAST)expr.getNextSibling(); |
| // now handle navigation source |
| expression(expr); |
| // now generate IS NULL constraint |
| generateSimpleFieldValueComparison(expr.getRetrieveDesc(), ident.getText(), |
| getSwappedOp(operation), value); |
| } |
| else |
| { |
| if (d1.getType() == NAVIGATION) navigation(d1); |
| generateDbValueConstantComparison(d1.getRetrieveDesc(), (ClassType)d1.getJQLType(), |
| getSwappedOp(operation), value, v1.getJQLType()); |
| } |
| } |
| | d2:dbValue |
| ( value = v2:constantValue |
| // case dbvalue relop constant |
| { |
| if ((value == null) && (d2.getType() == NAVIGATION)) |
| { |
| JQLAST expr = (JQLAST)d2.getFirstChild(); |
| JQLAST ident = (JQLAST)expr.getNextSibling(); |
| // now handle navigation source |
| expression(expr); |
| // now generate IS NULL constraint |
| generateSimpleFieldValueComparison(expr.getRetrieveDesc(), ident.getText(), |
| operation, value); |
| } |
| else |
| { |
| if (d2.getType() == NAVIGATION) navigation(d2); |
| generateDbValueConstantComparison(d2.getRetrieveDesc(), |
| (ClassType)d2.getJQLType(), |
| operation, value, v2.getJQLType()); |
| } |
| } |
| | d3:dbValue |
| // case dbvalue relop dbvalue |
| { |
| if (d2.getType() == NAVIGATION) navigation(d2); |
| if (d3.getType() == NAVIGATION) navigation(d3); |
| generateDbValueDbValueComparison(d2.getRetrieveDesc(), |
| (ClassType)d2.getJQLType(), |
| operation, |
| d3.getRetrieveDesc(), |
| (ClassType)d3.getJQLType()); |
| } |
| ) |
| ; |
| |
| parameterComparison |
| : #(EQUAL parameterComparisonOperands[RetrieveDesc.OP_EQ] ) |
| | #(NOT_EQUAL parameterComparisonOperands[RetrieveDesc.OP_NE] ) |
| | #(OBJECT_EQUAL parameterComparisonOperands[RetrieveDesc.OP_EQ] ) |
| | #(OBJECT_NOT_EQUAL parameterComparisonOperands[RetrieveDesc.OP_NE] ) |
| ; |
| |
| parameterComparisonOperands [int operation] |
| { |
| Object value = null; |
| } |
| : p1:PARAMETER value = v1:constantValue |
| { |
| generateParameterValueComparison(v1.getRetrieveDesc(), p1.getText(), |
| operation, value); |
| } |
| | value = v2:constantValue p2:PARAMETER |
| { |
| generateParameterValueComparison(v2.getRetrieveDesc(), p2.getText(), |
| operation, value); |
| } |
| ; |
| |
| dbValue |
| { |
| String name = null; |
| } |
| : THIS |
| | variableAccess |
| | #( NAVIGATION . IDENT ) |
| // do not use non-terminal navigation here, because navigation |
| // creates a RetrieveDesc for the relationship navigation and |
| // we must not create this in the case of relship == null |
| ; |
| |
| collectionComparison |
| : #( eq:COLLECTION_EQUAL . . ) |
| { |
| errorMsg.unsupported(eq.getLine(), eq.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.codegeneration.collectioncomparison.nonnull")); // NOI18N |
| } |
| | #( ne:COLLECTION_NOT_EQUAL . . ) |
| { |
| errorMsg.unsupported(ne.getLine(), ne.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.codegeneration.collectioncomparison.nonnull")); // NOI18N |
| } |
| ; |
| |
| binaryArithmeticExpr |
| : #( op1:PLUS left1:. right1:. ) |
| { |
| // Optimize indexOf + <intValue>: |
| // The SQL database returns an index starting with 1, so we need |
| // to decrement the returned index. We can do the derement at compile |
| // timeCombine, if the other operand is a constant int value. |
| if ((left1.getType() == INDEXOF) && |
| (right1.getType() == VALUE) && |
| (right1.getValue() instanceof Integer)) |
| { |
| // case: indexOf() + intValue |
| indexOf(left1, ((Integer)right1.getValue()).intValue()); |
| } |
| else if ((right1.getType() == INDEXOF) && |
| (left1.getType() == VALUE) && |
| (left1.getValue() instanceof Integer)) |
| { |
| // case: intValue + indexOf() |
| indexOf(right1, ((Integer)left1.getValue()).intValue()); |
| } |
| else |
| { |
| expression(right1); |
| expression(left1); |
| op1.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_ADD, null); |
| } |
| } |
| | #( op2:CONCAT left2:. expression ) |
| { |
| expression(left2); |
| op2.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_CONCAT, null); |
| } |
| | #( op3:MINUS left3:. right3:. ) |
| { |
| // Optimize indexOf + <intValue>: |
| // The SQL database returns an index starting with 1, so we need |
| // to decrement the returned index. We can do the derement at compile |
| // timeCombine, if the other operand is a constant int value. |
| if ((left3.getType() == INDEXOF) && |
| (right3.getType() == VALUE) && |
| (right3.getValue() instanceof Integer)) |
| { |
| // case: indexOf - intValue |
| // treated as indexOf + -intValue |
| indexOf(left3, -((Integer)right3.getValue()).intValue()); |
| } |
| else |
| { |
| expression(right3); |
| expression(left3); |
| op3.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_SUB, null); |
| } |
| } |
| | #( op4:STAR left4:. expression ) |
| { |
| expression(left4); |
| op4.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_MUL, null); |
| } |
| | #( op5:DIV left5:. expression ) |
| { |
| expression(left5); |
| op5.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_DIV, null); |
| } |
| | #( op6:MOD left6:. expression ) |
| { |
| expression(left6); |
| op6.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_MOD, null); |
| } |
| ; |
| |
| unaryArithmeticExpr |
| { |
| Object value = null; |
| } |
| : #( UNARY_PLUS expression ) |
| // no action needed, just ignore the unary plus |
| | #( op2:UNARY_MINUS |
| ( |
| ( constantValue )=> value = constantValue |
| { |
| value = negate(value, op2.getJQLType()); |
| op2.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_VALUE, value); |
| } |
| | |
| expression |
| { |
| // map -value to 0 - value |
| op2.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_VALUE, |
| getZeroValue(op2.getJQLType())); |
| op2.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_SUB, null); |
| } |
| ) |
| ) |
| ; |
| |
| complementExpr |
| : #( op1:BNOT expression ) |
| { |
| // map ~value to -1 - value (which is equivalent to (-value)-1) |
| op1.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_VALUE, |
| getMinusOneValue(op1.getJQLType())); |
| op1.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_SUB, null); |
| } |
| | #( op2:LNOT expr:. ) |
| { if (expr.getType() == FIELD_ACCESS) { |
| // The NOT operand is a boolean field. |
| // Map this to 'booleanField = FALSE'. Note, the runtime will |
| // create a JDBC parameter for the literal FALSE and call |
| // setBoolean to bind the value. |
| RetrieveDesc rd = op2.getRetrieveDesc(); |
| rd.addConstraint(null, RetrieveDesc.OP_VALUE, Boolean.FALSE); |
| expression(expr); |
| rd.addConstraint(null, RetrieveDesc.OP_EQ, null); |
| } |
| else { |
| expression(expr); |
| op2.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_NOT, null); |
| } |
| } |
| ; |
| |
| primary |
| { |
| Object value; |
| String name; |
| } |
| : #( TYPECAST type expression ) |
| { /* code gen for cast? */ } |
| | value = v:constantValue |
| { |
| if (value == null) |
| { |
| errorMsg.fatal(I18NHelper.getMessage(messages, "jqlc.codegeneration.primary.null")); //NOI18N |
| } |
| else if (value instanceof Boolean) |
| { |
| boolean booleanValue = ((Boolean)value).booleanValue(); |
| RetrieveDesc rd = v.getRetrieveDesc(); |
| rd.addConstraint(null, RetrieveDesc.OP_VALUE, new Integer(0)); |
| rd.addConstraint(null, RetrieveDesc.OP_VALUE, new Integer(0)); |
| rd.addConstraint(null, (booleanValue?RetrieveDesc.OP_EQ:RetrieveDesc.OP_NE), null); |
| } |
| else |
| { |
| v.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_VALUE, value); |
| } |
| } |
| | p:PARAMETER |
| { |
| p.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_PARAMETER, |
| paramtab.getParameterInfoForParamName(p.getText())); |
| } |
| | THIS |
| | name = f:fieldAccess |
| { |
| f.getRetrieveDesc().addConstraint(name, RetrieveDesc.OP_FIELD, null); |
| } |
| | navigation |
| | variableAccess |
| | #( CONTAINS . VARIABLE ) |
| // code moved to variable access |
| | #( NOT_CONTAINS . VARIABLE ) |
| // code moved to variable access |
| | startsWith |
| | endsWith |
| | isEmpty |
| | like |
| | substring |
| | indexOf[0] |
| | length |
| | abs |
| | sqrt |
| ; |
| |
| constantValue returns [Object value] |
| { |
| value = null; |
| } |
| : v:VALUE |
| { |
| value = v.getValue(); |
| } |
| ; |
| |
| |
| fieldAccess returns [String fieldName] |
| { |
| fieldName = null; |
| } |
| : #( FIELD_ACCESS expression name:IDENT ) |
| { fieldName = name.getText(); } |
| ; |
| |
| navigation |
| : #( n:NAVIGATION expr:expression i:IDENT ) |
| { |
| RetrieveDesc from = expr.getRetrieveDesc(); |
| RetrieveDesc to = n.getRetrieveDesc(); |
| from.addConstraint(i.getText(), to); |
| } |
| ; |
| |
| variableAccess |
| { |
| String name = null; |
| } |
| : #( var:VARIABLE ( name = col:collectionExpr )? ) |
| { |
| |
| RetrieveDesc varRD = var.getRetrieveDesc(); |
| if (!boundRetrieveDescs.contains(varRD)) |
| { |
| if (col != null) |
| { |
| if (col.getType() == NOT_IN) |
| col.getRetrieveDesc().addConstraint(name, RetrieveDesc.OP_NOTIN, varRD); |
| else if (USE_IN) |
| // generate OP_IN if USE_IN property is set |
| col.getRetrieveDesc().addConstraint(name, RetrieveDesc.OP_IN, varRD); |
| else |
| // otherwise generate regular join |
| col.getRetrieveDesc().addConstraint(name, varRD); |
| } |
| else |
| { |
| candidateRD.addConstraint(null, varRD); |
| } |
| boundRetrieveDescs.add(varRD); |
| } |
| } |
| ; |
| |
| collectionExpr returns [String fieldName] |
| { |
| fieldName = null; |
| } |
| : #( FIELD_ACCESS expression name1:IDENT ) |
| { fieldName = name1.getText(); } |
| | #( NAVIGATION expression name2:IDENT ) |
| { fieldName = name2.getText(); } |
| | #( TYPECAST . fieldName = collectionExpr ) |
| | #( NOT_IN fieldName = collectionExpr ) |
| ; |
| |
| startsWith |
| { |
| Object value = null; |
| JQLAST pattern = null; |
| } |
| : #( op1:STARTS_WITH string:. |
| { |
| // I need to store a pointer to the second operand of startsWith here. |
| // See second alternative below. |
| pattern = (JQLAST)string.getNextSibling(); |
| } |
| ( |
| ( constantValue )=> value = constantValue |
| { |
| if (string.getType() == FIELD_ACCESS) |
| { |
| // case 1 fieldAccess constantValue |
| String fieldName = fieldAccess(string); |
| op1.getRetrieveDesc().addConstraint(fieldName, RetrieveDesc.OP_LIKE, |
| ((String)value) + WILDCARD_PATTERN); |
| } |
| else |
| { |
| // case 2 expression constantValue |
| op1.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_VALUE, |
| ((String)value) + WILDCARD_PATTERN); |
| expression(string); |
| op1.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_LIKE, null); |
| } |
| } |
| | { |
| // I have to access the tree matched by rule expression before |
| // the rule is entered. Variable pattern points to that tree and |
| // needs to be initilaized before! |
| pattern.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_VALUE, |
| WILDCARD_PATTERN); |
| } |
| expression |
| { |
| // case 3 expression expression |
| pattern.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_CONCAT, null); |
| expression(string); |
| op1.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_LIKE, null); |
| } |
| ) |
| ) |
| ; |
| |
| endsWith |
| { |
| Object value = null; |
| } |
| : #( op1:ENDS_WITH string:. |
| ( |
| ( constantValue )=> value = constantValue |
| { |
| if (string.getType() == FIELD_ACCESS) |
| { |
| // case 1 fieldAccess constantValue |
| String fieldName = fieldAccess(string); |
| op1.getRetrieveDesc().addConstraint(fieldName, RetrieveDesc.OP_LIKE, |
| WILDCARD_PATTERN + ((String)value)); |
| } |
| else |
| { |
| // case 2 expression constantValue |
| op1.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_VALUE, |
| WILDCARD_PATTERN + ((String)value)); |
| expression(string); |
| op1.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_LIKE, null); |
| } |
| } |
| | pattern:expression |
| { |
| // case 3 expression expression |
| pattern.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_VALUE, |
| WILDCARD_PATTERN); |
| pattern.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_CONCAT, null); |
| expression(string); |
| op1.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_LIKE, null); |
| } |
| ) |
| ) |
| ; |
| |
| isEmpty |
| { |
| String name = null; |
| } |
| : #(op:IS_EMPTY name = collectionExpr) |
| { |
| op.getRetrieveDesc().addConstraint(name, RetrieveDesc.OP_NULL, null); |
| } |
| ; |
| |
| like |
| { |
| int opCode = RetrieveDesc.OP_LIKE; |
| } |
| : #( op:LIKE string:. pattern:. opCode = escape ) |
| { |
| expression(pattern); |
| expression(string); |
| op.getRetrieveDesc().addConstraint(null, opCode, null); |
| } |
| ; |
| |
| escape returns [int opCode] |
| { |
| // The default is no ESCAPE definition => OP_LIKE |
| opCode = RetrieveDesc.OP_LIKE; |
| } |
| : expression |
| { |
| opCode = RetrieveDesc.OP_LIKE_ESCAPE; |
| } |
| | // empty rule |
| ; |
| |
| substring |
| : // JDOQL: string.substring(begin, end) -> |
| // RetrieveDesc: SUBSTRING(string, begin + 1, end - begin) |
| #( op:SUBSTRING string:. begin:. end:. ) |
| { |
| RetrieveDesc rd = op.getRetrieveDesc(); |
| if ((begin.getType() == VALUE) && (end.getType() == VALUE)) |
| { |
| // Optimization: begin and end are constant values => |
| // calculate start and length of SQL SUBSTRING function |
| // at compile time. |
| // Note, Semantic ensures begin and end are int or Integer values. |
| int beginValue = (begin.getValue() != null) ? |
| ((Integer)begin.getValue()).intValue() : 0; |
| int endValue = (end.getValue() != null) ? |
| ((Integer)end.getValue()).intValue() : 0; |
| if (beginValue < 0) |
| { |
| errorMsg.error(begin.getLine(), begin.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.codegeneration.substring.beginnegative", // NOI18N |
| String.valueOf(beginValue))); |
| } |
| else if (endValue < beginValue) |
| { |
| errorMsg.error(op.getLine(), op.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.codegeneration.substring.beginlargerend", // NOI18N |
| String.valueOf(beginValue), String.valueOf(endValue))); |
| } |
| // SQL length = end - begin |
| rd.addConstraint(null, RetrieveDesc.OP_VALUE, |
| new Integer(endValue-beginValue)); |
| // SQL start index = begin + 1 |
| rd.addConstraint(null, RetrieveDesc.OP_VALUE, |
| new Integer(beginValue+1)); |
| } |
| else |
| { |
| // At least one of begin or end is a non constant value => |
| // generate the arguments start and length of the SQL SUBSTRING |
| // function as binary plus/minus expressions. |
| // The next 3 line denote the SQL length = end - begin |
| expression(begin); |
| expression(end); |
| rd.addConstraint(null, RetrieveDesc.OP_SUB, null); |
| // The next 3 lines denote the SQL start index = begin + 1 |
| rd.addConstraint(null, RetrieveDesc.OP_VALUE, new Integer(1)); |
| expression(begin); |
| rd.addConstraint(null, RetrieveDesc.OP_ADD, null); |
| } |
| // now push the string on the constraint stack |
| expression(string); |
| rd.addConstraint(null, RetrieveDesc.OP_SUBSTRING, null); |
| } |
| ; |
| |
| // incr denotes the value that need to be added to result of POSITION |
| indexOf [int incr] |
| { |
| int opCode = RetrieveDesc.OP_POSITION; |
| } |
| : // JDOQL: string.indexOf(pattern) -> |
| // RetrieveDesc: POSITION(string, pattern) - 1 |
| // JDOQL: string.indexOf(pattern, begin) -> |
| // RetrieveDesc: POSITION_START(string, pattern, begin + 1) - 1 |
| #( op:INDEXOF string:. pattern:. opCode = fromIndex ) |
| { |
| RetrieveDesc rd = op.getRetrieveDesc(); |
| // the 3 lines denote the SQL function POSITION OR POSITION_START |
| expression(pattern); |
| expression(string); |
| rd.addConstraint(null, opCode, null); |
| // SQL handles indexes starting from 1 => |
| // decrement the returned value to make it Java like! |
| incr--; |
| if (incr != 0) |
| { |
| rd.addConstraint(null, RetrieveDesc.OP_VALUE, new Integer(incr)); |
| rd.addConstraint(null, RetrieveDesc.OP_ADD, null); |
| } |
| } |
| ; |
| |
| fromIndex returns [int opCode] |
| { |
| // The default is no start definition => OP_POSITION |
| opCode = RetrieveDesc.OP_POSITION; |
| } |
| : e:. |
| { |
| opCode = RetrieveDesc.OP_POSITION_START; |
| // Java indexOf method use indexes starting with 0, |
| // where SQL starts with 1, so we need to add 1 |
| if (e.getType() == VALUE) |
| { |
| // Optimization: calulate index at compile time, |
| // if start is a constant value. |
| // Note, Semantic ensures begin and end are int or Integer values. |
| int value = (e.getValue() != null) ? |
| ((Integer)e.getValue()).intValue() : 0; |
| e.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_VALUE, |
| new Integer(value + 1)); |
| } |
| else |
| { |
| e.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_VALUE, |
| new Integer(1)); |
| expression(e); |
| e.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_ADD, null); |
| } |
| } |
| | // empty rule |
| ; |
| |
| length |
| : #( op:LENGTH expression ) |
| { |
| op.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_LENGTH, null); |
| } |
| ; |
| |
| abs |
| : #( op:ABS expression ) |
| { |
| op.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_ABS, null); |
| } |
| ; |
| |
| sqrt |
| : #( op:SQRT expression ) |
| { |
| op.getRetrieveDesc().addConstraint(null, RetrieveDesc.OP_SQRT, null); |
| } |
| ; |
| |
| type |
| : TYPENAME |
| | primitiveType |
| ; |
| |
| primitiveType |
| : BOOLEAN |
| | BYTE |
| | CHAR |
| | SHORT |
| | INT |
| | FLOAT |
| | LONG |
| | DOUBLE |
| ; |
| |
| // ---------------------------------- |
| // rules: RetrieveDesc handling |
| // ---------------------------------- |
| |
| prepareRetrieveDescs |
| { |
| Map usedRD = new HashMap(); |
| } |
| : #( q:QUERY |
| checkRetrieveDesc[usedRD] // candidate class |
| ( #( PARAMETER_DEF . . ) )* |
| ( #( VARIABLE_DEF . . ) )* |
| ( #( ORDERING_DEF |
| ( ASCENDING | DESCENDING ) |
| ordering:checkRetrieveDesc[usedRD] |
| { propagateRetrieveDesc(ordering, candidateRD); } |
| ) |
| )* |
| ( #( RESULT_DEF result:checkRetrieveDesc[usedRD] |
| { propagateRetrieveDesc(result, candidateRD); } |
| ) |
| )? |
| #( FILTER_DEF |
| filter:checkRetrieveDesc[usedRD] |
| { propagateRetrieveDesc(filter, candidateRD); } |
| ) |
| ) |
| ; |
| |
| checkRetrieveDesc [Map usedRD] |
| : c:CLASS_DEF |
| { |
| // check persistence capable |
| ClassType candidateClass = (ClassType)c.getJQLType(); |
| candidateRD = createRetrieveDesc("this", candidateClass); //NOI18N |
| candidateRD.setPrefetchEnabled(prefetchEnabled); |
| } |
| | #( cast:TYPECAST type expr1:checkRetrieveDesc[usedRD] ) |
| { |
| cast.setRetrieveDesc(expr1.getRetrieveDesc()); |
| } |
| |
| // constantValue not necessary here, this is covered by the last rule |
| |
| | t:THIS |
| { |
| t.setRetrieveDesc(candidateRD); |
| } |
| | #(var:VARIABLE ( checkRetrieveDesc[usedRD] )? ) |
| { |
| RetrieveDesc to = (RetrieveDesc)usedRD.get(var.getText()); |
| if (to == null) |
| { |
| to = createRetrieveDesc(var.getText(), (ClassType)var.getJQLType()); |
| usedRD.put(var.getText(), to); |
| } |
| var.setRetrieveDesc(to); |
| } |
| | #(notIn:NOT_IN notInArg:checkRetrieveDesc[usedRD]) |
| { |
| #notIn.setRetrieveDesc(#notInArg.getRetrieveDesc()); |
| } |
| | #(fa:FIELD_ACCESS expr4:checkRetrieveDesc[usedRD] i:IDENT) |
| { |
| fa.setRetrieveDesc(expr4.getRetrieveDesc()); |
| i.setRetrieveDesc(expr4.getRetrieveDesc()); |
| } |
| | #(n:NAVIGATION checkRetrieveDesc[usedRD] IDENT) |
| { |
| RetrieveDesc to = (RetrieveDesc)usedRD.get(n.getText()); |
| if (to == null) |
| { |
| to = createRetrieveDesc(n.getText(), (ClassType)n.getJQLType()); |
| usedRD.put(n.getText(), to); |
| } |
| n.setRetrieveDesc(to); |
| } |
| | #(CONTAINS checkRetrieveDesc[usedRD] checkRetrieveDesc[usedRD]) |
| | #(NOT_CONTAINS checkRetrieveDesc[usedRD] checkRetrieveDesc[usedRD]) |
| | #(sw:STARTS_WITH expr7:checkRetrieveDesc[usedRD] checkRetrieveDesc[usedRD]) |
| { |
| sw.setRetrieveDesc(expr7.getRetrieveDesc()); |
| } |
| | #(ew:ENDS_WITH expr8:checkRetrieveDesc[usedRD] checkRetrieveDesc[usedRD]) |
| { |
| ew.setRetrieveDesc(expr8.getRetrieveDesc()); |
| } |
| | #(ie:IS_EMPTY expr9:checkRetrieveDesc[usedRD]) |
| { |
| ie.setRetrieveDesc(expr9.getRetrieveDesc()); |
| } |
| | #(like:LIKE string10:checkRetrieveDesc[usedRD] |
| pattern10:checkRetrieveDesc[usedRD] ( escape10:checkRetrieveDesc[usedRD] )? ) |
| { |
| like.setRetrieveDesc(getCommonRetrieveDesc(string10, pattern10, escape10)); |
| } |
| | #(substr:SUBSTRING string11:checkRetrieveDesc[usedRD] |
| lower11:checkRetrieveDesc[usedRD] upper11:checkRetrieveDesc[usedRD] ) |
| { |
| substr.setRetrieveDesc(getCommonRetrieveDesc(string11, lower11, upper11)); |
| } |
| | #(indexOf:INDEXOF string12:checkRetrieveDesc[usedRD] |
| pattern12:checkRetrieveDesc[usedRD] ( start12:checkRetrieveDesc[usedRD] )? ) |
| { |
| indexOf.setRetrieveDesc(getCommonRetrieveDesc(string12, pattern12, start12)); |
| } |
| | #(len:LENGTH expr13:checkRetrieveDesc[usedRD]) |
| { |
| len.setRetrieveDesc(expr13.getRetrieveDesc()); |
| } |
| | #(abs:ABS expr14:checkRetrieveDesc[usedRD]) |
| { |
| abs.setRetrieveDesc(expr14.getRetrieveDesc()); |
| } |
| | #(sqrt:SQRT expr15:checkRetrieveDesc[usedRD]) |
| { |
| sqrt.setRetrieveDesc(expr15.getRetrieveDesc()); |
| } |
| |
| // binary operations |
| |
| | #( op1:BAND left1:. right1:. ) |
| { checkAndOpRetrieveDesc(op1, left1, right1, usedRD); } |
| | #( op2:BOR left2:checkRetrieveDesc[new HashMap(usedRD)] |
| right2:checkRetrieveDesc[new HashMap(usedRD)] ) |
| { op2.setRetrieveDesc(getCommonRetrieveDesc(left2, right2)); } |
| | #( op3:BXOR left3:checkRetrieveDesc[new HashMap()] |
| right3:checkRetrieveDesc[new HashMap()] ) |
| { op3.setRetrieveDesc(getCommonRetrieveDesc(left3, right3)); } |
| | #( op4:AND left4:. right4:. ) |
| { checkAndOpRetrieveDesc(op4, left4, right4, usedRD); } |
| | #( op5:OR left5:checkRetrieveDesc[new HashMap(usedRD)] |
| right5:checkRetrieveDesc[new HashMap(usedRD)] ) |
| { op5.setRetrieveDesc(getCommonRetrieveDesc(left5, right5)); } |
| | #( op6:EQUAL left6:checkRetrieveDesc[usedRD] right6:checkRetrieveDesc[usedRD] ) |
| { op6.setRetrieveDesc(getCommonRetrieveDesc(left6, right6)); } |
| | #( op7:NOT_EQUAL left7:checkRetrieveDesc[usedRD] right7:checkRetrieveDesc[usedRD] ) |
| { op7.setRetrieveDesc(getCommonRetrieveDesc(left7, right7)); } |
| | #( op8:LT left8:checkRetrieveDesc[usedRD] right8:checkRetrieveDesc[usedRD] ) |
| { op8.setRetrieveDesc(getCommonRetrieveDesc(left8, right8)); } |
| | #( op9:GT left9:checkRetrieveDesc[usedRD] right9:checkRetrieveDesc[usedRD] ) |
| { op9.setRetrieveDesc(getCommonRetrieveDesc(left9, right9)); } |
| | #( op10:LE left10:checkRetrieveDesc[usedRD] right10:checkRetrieveDesc[usedRD] ) |
| { op10.setRetrieveDesc(getCommonRetrieveDesc(left10, right10)); } |
| | #( op11:GE left11:checkRetrieveDesc[usedRD] right11:checkRetrieveDesc[usedRD] ) |
| { op11.setRetrieveDesc(getCommonRetrieveDesc(left11, right11)); } |
| | #( op12:OBJECT_EQUAL left12:checkRetrieveDesc[usedRD] right12:checkRetrieveDesc[usedRD] ) |
| { op12.setRetrieveDesc(getObjectComparisonRetrieveDesc(left12, right12)); } |
| | #( op13:OBJECT_NOT_EQUAL left13:checkRetrieveDesc[usedRD] right13:checkRetrieveDesc[usedRD] ) |
| { op13.setRetrieveDesc(getObjectComparisonRetrieveDesc(left13, right13)); } |
| | #( op14:COLLECTION_EQUAL left14:checkRetrieveDesc[usedRD] right14:checkRetrieveDesc[usedRD] ) |
| { op14.setRetrieveDesc(getCommonRetrieveDesc(left14, right14)); } |
| | #( op15:COLLECTION_NOT_EQUAL left15:checkRetrieveDesc[usedRD] right15:checkRetrieveDesc[usedRD] ) |
| { op15.setRetrieveDesc(getCommonRetrieveDesc(left15, right15)); } |
| | #( op16:PLUS left16:checkRetrieveDesc[usedRD] right16:checkRetrieveDesc[usedRD] ) |
| { op16.setRetrieveDesc(getCommonRetrieveDesc(left16, right16)); } |
| | #( op17:CONCAT left17:checkRetrieveDesc[usedRD] right17:checkRetrieveDesc[usedRD] ) |
| { op17.setRetrieveDesc(getCommonRetrieveDesc(left17, right17)); } |
| | #( op18:MINUS left18:checkRetrieveDesc[usedRD] right18:checkRetrieveDesc[usedRD] ) |
| { op18.setRetrieveDesc(getCommonRetrieveDesc(left18, right18)); } |
| | #( op19:STAR left19:checkRetrieveDesc[usedRD] right19:checkRetrieveDesc[usedRD] ) |
| { op19.setRetrieveDesc(getCommonRetrieveDesc(left19, right19)); } |
| | #( op20:DIV left20:checkRetrieveDesc[usedRD] right20:checkRetrieveDesc[usedRD] ) |
| { op20.setRetrieveDesc(getCommonRetrieveDesc(left20, right20)); } |
| | #( op21:MOD left21:checkRetrieveDesc[usedRD] right21:checkRetrieveDesc[usedRD] ) |
| { op21.setRetrieveDesc(getCommonRetrieveDesc(left21, right21)); } |
| |
| // unary operations |
| |
| | #( uop1:UNARY_PLUS arg1:checkRetrieveDesc[usedRD] ) |
| { uop1.setRetrieveDesc(arg1.getRetrieveDesc()); } |
| | #( uop2:UNARY_MINUS arg2:checkRetrieveDesc[usedRD] ) |
| { uop2.setRetrieveDesc(arg2.getRetrieveDesc()); } |
| | #( uop3:BNOT arg3:checkRetrieveDesc[usedRD] ) |
| { uop3.setRetrieveDesc(arg3.getRetrieveDesc()); } |
| | #( uop4:LNOT arg4:checkRetrieveDesc[usedRD] ) |
| { uop4.setRetrieveDesc(arg4.getRetrieveDesc()); } |
| | #( d:DISTINCT arg5:checkRetrieveDesc[usedRD] ) |
| { d.setRetrieveDesc(arg5.getRetrieveDesc()); } |
| | #( avg:AVG arg6:checkRetrieveDesc[usedRD] ) |
| { avg.setRetrieveDesc(arg6.getRetrieveDesc()); } |
| | #( max:MAX arg7:checkRetrieveDesc[usedRD] ) |
| { max.setRetrieveDesc(arg7.getRetrieveDesc()); } |
| | #( min:MIN arg8:checkRetrieveDesc[usedRD] ) |
| { min.setRetrieveDesc(arg8.getRetrieveDesc()); } |
| | #( sum:SUM arg9:checkRetrieveDesc[usedRD] ) |
| { sum.setRetrieveDesc(arg9.getRetrieveDesc()); } |
| | #( count:COUNT arg10:checkRetrieveDesc[usedRD] ) |
| { count.setRetrieveDesc(arg10.getRetrieveDesc()); } |
| | . |
| ; |
