@Override public List<?> translate(LanguageObject obj, ExecutionContext context) { if (obj instanceof Comparison) { Comparison compare = (Comparison)obj; if (compare.getLeftExpression().getType() == TypeFacility.RUNTIME_TYPES.BOOLEAN && compare.getLeftExpression() instanceof Function && compare.getRightExpression() instanceof Literal) { boolean isTrue = Boolean.TRUE.equals(((Literal)compare.getRightExpression()).getValue()); if ((isTrue && compare.getOperator() == Operator.EQ) || (!isTrue && compare.getOperator() == Operator.NE)) { return Arrays.asList(compare.getLeftExpression()); } if ((!isTrue && compare.getOperator() == Operator.EQ) || (isTrue && compare.getOperator() == Operator.NE)) { return Arrays.asList("NOT ", compare.getLeftExpression()); //$NON-NLS-1$ } } } else if (obj instanceof Not) { Not not = (Not)obj; return Arrays.asList("NOT ", not.getCriteria()); //$NON-NLS-1$ } return super.translate(obj, context); }
public Comparison createCompareCriteria( Comparison.Operator operator, Expression leftExpression, Expression rightExpression) { return new Comparison(leftExpression, rightExpression, operator); }
@Override public void visit(Comparison obj) { if (allowImplictConversion(obj)) { Function left = (Function) obj.getLeftExpression(); obj.setLeftExpression(left.getParameters().get(0)); Function right = (Function) obj.getRightExpression(); obj.setRightExpression(right.getParameters().get(0)); } super.visit(obj); }
public void visit(Comparison obj) { visitNode(obj.getLeftExpression()); visitNode(obj.getRightExpression()); }
if (comp.getOperator() != Operator.EQ) { continue; if (comp.getRightExpression() instanceof Parameter) { iter.remove(); p = (Parameter)comp.getRightExpression(); } else if (comp.getRightExpression() instanceof Array) { Array array = (Array)comp.getRightExpression(); if (array.getExpressions().get(0) instanceof Parameter) { iter.remove(); List<Expression> params = new ArrayList<Expression>(); for (Comparison comp : entry.getValue()) { Expression ex = comp.getLeftExpression(); if (ex instanceof Array) { Array array = (Array)ex; params.addAll(((Array)comp.getRightExpression()).getExpressions()); for (Expression expr : array.getExpressions()) { cols.add(createTempColumn(cols.size()+1, expr)); params.add(comp.getRightExpression()); cols.add(createTempColumn(cols.size()+1, ex)); Expression ex = comp.getLeftExpression(); if (ex instanceof Array) { Array array = (Array)ex; for (Expression expr : array.getExpressions()) { conditions.add(new Comparison(expr, new ColumnReference(table, COL_PREFIX+i++, null, expr.getType()), Comparison.Operator.EQ));
@Override public void visit(Comparison obj) { if (isFixedChar(obj.getLeftExpression())) { if (obj.getRightExpression() instanceof Literal) { Literal l = (Literal)obj.getRightExpression(); l.setType(FixedCharType.class); } else if (obj.getRightExpression() instanceof Parameter) { Parameter p = (Parameter)obj.getRightExpression(); p.setType(FixedCharType.class); } } if (obj.getLeftExpression().getType() == TypeFacility.RUNTIME_TYPES.BOOLEAN && (obj.getLeftExpression() instanceof Function) && obj.getRightExpression() instanceof Literal) { Function f = (Function)obj.getLeftExpression(); if (STRING_BOOLEAN_FUNCTIONS.contains(f.getName())) { Boolean b = (Boolean)((Literal)obj.getRightExpression()).getValue(); obj.setRightExpression(new Literal(b!=null?(b?"TRUE":"FALSE"):null, TypeFacility.RUNTIME_TYPES.STRING)); //$NON-NLS-1$ //$NON-NLS-2$ } } super.visit(obj); }
protected void appendRightComparison(Comparison obj) { append(obj.getRightExpression()); }
@Override public void visit(Comparison obj) { append(obj.getLeftExpression()); this.filter.append(Tokens.SPACE); switch(obj.getOperator()) { case EQ: this.filter.append("eq"); //$NON-NLS-1$ break; case NE: this.filter.append("ne"); //$NON-NLS-1$ break; case LT: this.filter.append("lt"); //$NON-NLS-1$ break; case LE: this.filter.append("le"); //$NON-NLS-1$ break; case GT: this.filter.append("gt"); //$NON-NLS-1$ break; case GE: this.filter.append("ge"); //$NON-NLS-1$ break; } this.filter.append(Tokens.SPACE); BaseColumn old = setCurrentExpression(obj.getLeftExpression()); appendRightComparison(obj); this.currentExpression = old; }
loadColumnMetadata((NamedTable) right); Comparison criteria = (Comparison) join.getCondition(); Expression lExp = criteria.getLeftExpression(); Expression rExp = criteria.getRightExpression(); if (isIdColumn(rExp) || isIdColumn(lExp)) { Column rColumn = ((ColumnReference) rExp).getMetadataObject(); addCriteria(new Comparison(fKey, new Literal(null, fKey.getType()), Comparison.Operator.NE));
protected BasicDBObject buildFunctionQuery(Comparison obj, BasicDBObject leftExpr, Object rightExpr) { switch(obj.getOperator()) { case EQ: if (rightExpr instanceof Boolean && ((Boolean)rightExpr)) { return leftExpr; } //$FALL-THROUGH$ case NE: case LT: case LE: case GT: case GE: } this.exceptions.add(new TranslatorException(MongoDBPlugin.Event.TEIID18030, MongoDBPlugin.Util.gs(MongoDBPlugin.Event.TEIID18030))); return null; }
public void testGetLeftExpression() throws Exception { Comparison impl = example(AbstractCompareCriteria.GE, 200, 100); assertNotNull(impl.getLeftExpression()); assertTrue(impl.getLeftExpression() instanceof Literal); assertEquals(new Integer(200), ((Literal)impl.getLeftExpression()).getValue()); }
private boolean isInComparison(NamedTable table, Comparison comparison) { return isInReference(table, (ColumnReference)comparison.getLeftExpression()) || isInReference(table, (ColumnReference)comparison.getRightExpression()); }
protected void appendRightComparison(Comparison obj) { append(obj.getRightExpression()); }
@Override public void visit(Comparison obj) { Expression left = obj.getLeftExpression(); switch(obj.getOperator()) { case EQ: this.filter.append("eq"); //$NON-NLS-1$
public void testGetOperator() throws Exception { assertEquals(Operator.EQ, example(AbstractCompareCriteria.EQ, 200, 100).getOperator()); assertEquals(Operator.GE, example(AbstractCompareCriteria.GE, 200, 100).getOperator()); assertEquals(Operator.GT, example(AbstractCompareCriteria.GT, 200, 100).getOperator()); assertEquals(Operator.LE, example(AbstractCompareCriteria.LE, 200, 100).getOperator()); assertEquals(Operator.LT, example(AbstractCompareCriteria.LT, 200, 100).getOperator()); assertEquals(Operator.NE, example(AbstractCompareCriteria.NE, 200, 100).getOperator()); }
@Override public void visit( Comparison criteria ) { addCompareCriteria(criteria); boolean isAcceptableID = (Operator.EQ == criteria.getOperator() && isIdColumn(criteria.getLeftExpression())); setHasCriteria(true, isAcceptableID); if (isAcceptableID) { this.idInCriteria = new In(criteria.getLeftExpression(), Arrays.asList(criteria.getRightExpression()), false); } }
private boolean allowImplictConversion(Comparison obj) { if (isConvertFunctionWithSimpleExpression(obj.getLeftExpression()) && isConvertFunctionWithSimpleExpression(obj.getRightExpression())) { String left = getParameterDataType(obj.getLeftExpression()); String right = getParameterDataType(obj.getRightExpression()); if (left.equals(DataTypeManager.DefaultDataTypes.INTEGER) && right.equals(DataTypeManager.DefaultDataTypes.FLOAT)) { return true; } if (left.equals(DataTypeManager.DefaultDataTypes.FLOAT) && right.equals(DataTypeManager.DefaultDataTypes.INTEGER)) { return true; } } return false; }
protected void appendRightComparison(Comparison obj) { append(obj.getRightExpression()); }
protected void buildComparisionQuery(Comparison obj, Object rightExpr, QueryBuilder query) { switch(obj.getOperator()) { case EQ: query.is(rightExpr); break; case NE: query.notEquals(rightExpr); break; case LT: query.lessThan(rightExpr); break; case LE: query.lessThanEquals(rightExpr); break; case GT: query.greaterThan(rightExpr); break; case GE: query.greaterThanEquals(rightExpr); break; } }
@Override public List<?> translate(Function function) { Expression trueValue = function.getParameters().get(0); Expression falseValue = trueValue; falseValue = new IsNull(falseValue, true); if (!(trueValue instanceof Predicate)) { trueValue = new Comparison(trueValue, new Literal(Boolean.TRUE, TypeFacility.RUNTIME_TYPES.BOOLEAN), Comparison.Operator.EQ); } return Arrays.asList("CASE WHEN ", trueValue, " THEN 'true' WHEN ", falseValue, " THEN 'false' END"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ } });