final public CompareCriteria compareCrit(ParseInfo info, Expression expression) throws ParseException { Expression value = null; Token operator = null; operator = operator(); value = commonValueExpression(info); CompareCriteria compareCriteria = new CompareCriteria(); // Set left expression compareCriteria.setLeftExpression(expression); compareCriteria.setOperator(getOperator(operator.image)); // Set value compareCriteria.setRightExpression(value); {if (true) return compareCriteria;} throw new Error("Missing return statement in function"); }
/** * Deep copy of object * @return Deep copy of object */ public Object clone() { Expression leftCopy = null; if(getLeftExpression() != null) { leftCopy = (Expression) getLeftExpression().clone(); } Expression rightCopy = null; if(getRightExpression() != null) { rightCopy = (Expression) getRightExpression().clone(); } CompareCriteria result = new CompareCriteria(leftCopy, getOperator(), rightCopy); result.isOptional = isOptional; return result; }
static void filterOptionalCriteria(List<Criteria> crits, boolean all) { for (Iterator<Criteria> iter = crits.iterator(); iter.hasNext();) { Criteria crit = iter.next(); if (crit instanceof CompareCriteria) { CompareCriteria cc = (CompareCriteria) crit; if (Boolean.TRUE.equals(cc.getIsOptional()) || (all && cc.isOptional())) { iter.remove(); } } } }
/** * Sets the operands and operator. The clause is of the form: <variable> <operator> <value>. * * @param leftExpression The left expression * @param operator The operator representing how the expressions are compared * @param rightExpression The right expression */ public void set( Expression leftExpression, int operator, Expression rightExpression ) { setLeftExpression(leftExpression); setOperator(operator); setRightExpression(rightExpression); }
/** * @see org.teiid.query.sql.LanguageVisitor#visit(CompareCriteria) */ public void visit(CompareCriteria obj) { obj.setLeftExpression( replaceExpression(obj.getLeftExpression()) ); obj.setRightExpression( replaceExpression(obj.getRightExpression()) ); }
/** * Override equals() method. * @param obj Other object * @return true if objects are equivalent */ public boolean equals(Object obj) { // Use super.equals() to check obvious stuff and variable if(obj == this) { return true; } if(! (obj instanceof CompareCriteria)) { return false; } //also allow for semantic equivalence on equality CompareCriteria cc = (CompareCriteria)obj; return getOperator() == cc.getOperator() && (EquivalenceUtil.areEqual(getLeftExpression(), cc.getLeftExpression()) && EquivalenceUtil.areEqual(getRightExpression(), cc.getRightExpression())) || (getOperator() == EQ && EquivalenceUtil.areEqual(getLeftExpression(), cc.getRightExpression()) && EquivalenceUtil.areEqual(getRightExpression(), cc.getLeftExpression())); }
Expression leftExpr = rewriteExpressionDirect(criteria.getLeftExpression()); Expression rightExpr = rewriteExpressionDirect(criteria.getRightExpression()); criteria.setLeftExpression(leftExpr); criteria.setRightExpression(rightExpr); switch(criteria.getOperator()) { case CompareCriteria.LE: case CompareCriteria.GE: return getSimpliedCriteria(criteria, criteria.getLeftExpression(), true, true); default: if (leftExpr instanceof Constant) { return FALSE_CRITERIA; return getSimpliedCriteria(criteria, criteria.getLeftExpression(), false, true); criteria.setLeftExpression(rightExpr); criteria.setRightExpression(leftExpr); switch(criteria.getOperator()) { case CompareCriteria.LT: criteria.setOperator(CompareCriteria.GT); break; case CompareCriteria.LE: criteria.setOperator(CompareCriteria.GE); break; case CompareCriteria.GT: criteria.setOperator(CompareCriteria.LT); break; case CompareCriteria.GE: criteria.setOperator(CompareCriteria.LE); break; while (rightConstant && f != criteria.getLeftExpression() && criteria.getLeftExpression() instanceof Function) { f = (Function)criteria.getLeftExpression(); Criteria result = simplifyWithInverse(criteria); if (!(result instanceof CompareCriteria)) {
if ((cc.getLeftExpression() instanceof ElementSymbol) || (cc.getRightExpression() instanceof ElementSymbol)) { valid = true; if (crit instanceof CompareCriteria) { CompareCriteria cc = (CompareCriteria) crit; if (cc.isOptional()) { cc.setOptional(true); continue; if (considerOptional) { for (CompareCriteria criteria : thetaCriteria) { criteria.setOptional(false); if (criteria.getIsOptional() == null || !criteria.isOptional()) { hasCriteria = true; break;
private void addEmptyFilter(Collection<AggregateSymbol> aggregates, PlanNode stageGroup, QueryMetadataInterface metadata, CapabilitiesFinder capFinder, Object modelId) throws QueryMetadataException, TeiidComponentException { PlanNode selectNode = NodeFactory.getNewNode(NodeConstants.Types.SELECT); AggregateSymbol count = new AggregateSymbol(NonReserved.COUNT, false, null); aggregates.add(count); //consider the count aggregate for the push down call below Criteria crit = new CompareCriteria(count, CompareCriteria.GT, new Constant(new Integer(0))); selectNode.setProperty(NodeConstants.Info.SELECT_CRITERIA, crit); selectNode.setProperty(NodeConstants.Info.IS_HAVING, Boolean.TRUE); stageGroup.addAsParent(selectNode); }
if(TRUE_CRITERIA.equals(converted)) { if(operator == CompoundCriteria.OR) { } else if(FALSE_CRITERIA.equals(converted)) { if(operator == CompoundCriteria.AND) { } else if (UNKNOWN_CRITERIA.equals(converted)) { if (preserveUnknown) { newCrits.add(converted); newCrits.remove(crit); CompareCriteria cc = (CompareCriteria)crit; sc.getValues().add(cc.getRightExpression()); if (cc.getOperator() == CompareCriteria.EQ && cc.getRightExpression() instanceof Constant) { Criteria crit = exprMap.get(cc.getLeftExpression()); if (crit == null) { exprMap.put(cc.getLeftExpression(), cc); } else if (crit instanceof SetCriteria) { SetCriteria other = (SetCriteria)crit; other.getValues().add(cc.getRightExpression()); continue; } else { newCrits.remove(crit); CompareCriteria other = (CompareCriteria)crit; SetCriteria sc = new SetCriteria(cc.getLeftExpression(), DataTypeManager.isHashable(other.getRightExpression().getType())?new LinkedHashSet<Constant>():new TreeSet<Constant>()); sc.setAllConstants(true); sc.getValues().add(cc.getRightExpression()); sc.getValues().add(other.getRightExpression());
@Test public void testRewriteCase1954b() throws Exception{ QueryMetadataInterface metadata = RealMetadataFactory.example1Cached(); CompareCriteria expected = new CompareCriteria(); ElementSymbol leftElement = new ElementSymbol("pm1.g1.e4"); //$NON-NLS-1$ Constant constant = new Constant(new Double(3.0), DataTypeManager.DefaultDataClasses.DOUBLE); expected.setLeftExpression(leftElement); expected.setRightExpression(constant); // resolve against metadata QueryResolver.resolveCriteria(expected, metadata); helpTestRewriteCriteria("convert(pm1.g1.e4, string) = '3.0'", expected, metadata); //$NON-NLS-1$ }
public void visit(CompareCriteria obj) { preVisitVisitor(obj); visitNode(obj.getLeftExpression()); visitNode(obj.getRightExpression()); postVisitVisitor(obj); } public void visit(CompoundCriteria obj) {
public void visit(CompareCriteria obj) { checkCompareCriteria(obj, obj.getRightExpression()); checkLiteralComparison(obj, Arrays.asList(obj.getRightExpression())); }
@Test public void testNestedComparison() { CompareCriteria cc = new CompareCriteria( new ElementSymbol("m.g.c1"), //$NON-NLS-1$ CompareCriteria.EQ, new Constant("abc") ); //$NON-NLS-1$ CompareCriteria cc1 = new CompareCriteria( cc, //$NON-NLS-1$ CompareCriteria.EQ, new Constant(false) ); //$NON-NLS-1$ helpTest(cc1, "(m.g.c1 = 'abc') = FALSE"); //$NON-NLS-1$ cc1.setLeftExpression(new CompoundCriteria(Arrays.asList(cc, new CompareCriteria( new ElementSymbol("m.g.c2"), //$NON-NLS-1$ CompareCriteria.GT, new Constant(1))))); helpTest(cc1, "((m.g.c1 = 'abc') AND (m.g.c2 > 1)) = FALSE"); //$NON-NLS-1$ }
@Override public void visit(CompareCriteria obj) { if (isNonComparable(obj.getLeftExpression())) { handleValidationError(QueryPlugin.Util.getString("ERR.015.012.0027", obj, DataTypeManager.getDataTypeName(obj.getLeftExpression().getType())),obj); //$NON-NLS-1$ } }
@Ignore(value="Cannot deterime if the format is narrowing") @Test public void testRewriteCrit_formatDouble() throws Exception { String original = "formatDouble(convert(pm1.g1.e4, double), '$#,##0.00') = '$1,234.50'"; //$NON-NLS-1$ String expected = "pm1.g1.e4 = '1234.5'"; //$NON-NLS-1$ QueryMetadataInterface metadata = RealMetadataFactory.example1Cached(); Criteria origCrit = parseCriteria(original, metadata); Criteria expectedCrit = parseCriteria(expected, metadata); ((CompareCriteria)expectedCrit).setRightExpression(new Constant(new Double(1234.5))); // rewrite Criteria actual = QueryRewriter.rewriteCriteria(origCrit, null, null); assertEquals("Did not rewrite correctly: ", expectedCrit, actual); //$NON-NLS-1$ }
public int getReverseOperator() { int operator = getOperator(); switch(operator) { case CompareCriteria.LT: return CompareCriteria.GT; case CompareCriteria.LE: return CompareCriteria.GE; case CompareCriteria.GT: return CompareCriteria.LT; case CompareCriteria.GE: return CompareCriteria.LE; } return operator; }
/** * Override equals() method. * @param obj Other object * @return true if objects are equivalent */ public boolean equals(Object obj) { // Use super.equals() to check obvious stuff and variable if(obj == this) { return true; } if(! (obj instanceof CompareCriteria)) { return false; } //also allow for semantic equivalence on equality CompareCriteria cc = (CompareCriteria)obj; return getOperator() == cc.getOperator() && (EquivalenceUtil.areEqual(getLeftExpression(), cc.getLeftExpression()) && EquivalenceUtil.areEqual(getRightExpression(), cc.getRightExpression())) || (getOperator() == EQ && EquivalenceUtil.areEqual(getLeftExpression(), cc.getRightExpression()) && EquivalenceUtil.areEqual(getRightExpression(), cc.getLeftExpression())); }
return criteria; Expression leftExpr = rewriteExpressionDirect(criteria.getLeftExpression()); Expression rightExpr = rewriteExpressionDirect(criteria.getRightExpression()); criteria.setLeftExpression(leftExpr); criteria.setRightExpression(rightExpr); switch(criteria.getOperator()) { case CompareCriteria.LE: case CompareCriteria.GE: return getSimpliedCriteria(criteria, criteria.getLeftExpression(), true, true); default: if (leftExpr instanceof Constant) { return FALSE_CRITERIA; return getSimpliedCriteria(criteria, criteria.getLeftExpression(), false, true); criteria.setLeftExpression(rightExpr); criteria.setRightExpression(leftExpr); criteria.setOperator(criteria.getReverseOperator()); rightConstant = true; while (rightConstant && f != criteria.getLeftExpression() && criteria.getLeftExpression() instanceof Function) { f = (Function)criteria.getLeftExpression(); Criteria result = simplifyWithInverse(criteria); if (!(result instanceof CompareCriteria)) {
public ImmutableCompareCriteria(Expression leftExpression, int operator, Expression rightExpression) { super.setLeftExpression(leftExpression); super.setOperator(operator); super.setRightExpression(rightExpression); }