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; }
@Override public void visit(Comparison obj) { append(obj.getLeftExpression()); if (!this.skipCompare) { buffer.append(Tokens.SPACE); if (obj.getOperator().equals(Operator.NE)) { buffer.append("!="); //$NON-NLS-1$ } else { buffer.append(obj.getOperator()); } buffer.append(Tokens.SPACE); append(obj.getRightExpression()); } this.skipCompare = false; }
public void visit(Comparison obj) { boolean addNot = false; if ((!isUpdate() || obj.getLeftExpression().getType() != TypeFacility.RUNTIME_TYPES.STRING) && (obj.getOperator() == Operator.NE || obj.getOperator() == Operator.LT || obj.getOperator() == Operator.LE || (obj.getOperator() == Operator.EQ && !(obj.getRightExpression() instanceof Literal)))) { addNot = true; buffer.append("("); //$NON-NLS-1$ } super.visit(obj); if (addNot) { buffer.append(" AND "); //$NON-NLS-1$ visitNode(obj.getLeftExpression()); if (!isUpdate()) { buffer.append(" IS NOT NULL)"); //$NON-NLS-1$ } else { buffer.append(" <> \"\")"); //$NON-NLS-1$ } } }
@Override public void visit(Comparison obj) { try { Object o1 = getRowValue(obj.getLeftExpression()); Object o2 = getLiteralValue(obj.getRightExpression()); int compare = ((Comparable<Object>)o1).compareTo(o2); switch(obj.getOperator()) { case EQ: this.match.push(Boolean.valueOf(compare == 0)); break; case NE: this.match.push(Boolean.valueOf(compare != 0)); break; case LT: this.match.push(Boolean.valueOf(compare < 0)); break; case LE: this.match.push(Boolean.valueOf(compare <= 0)); break; case GT: this.match.push(Boolean.valueOf(compare > 0)); break; case GE: this.match.push(Boolean.valueOf(compare >= 0)); break; } } catch (TranslatorException e) { this.exceptions.add(e); } }
@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); }
private void visitDerivedExpression(Comparison obj) { append(obj.getLeftExpression()); Object leftExpr = this.onGoingExpression.pop(); append(obj.getRightExpression()); Object rightExpr = this.onGoingExpression.pop(); BasicDBList values = new BasicDBList(); values.add(0, leftExpr); values.add(1, rightExpr); switch(obj.getOperator()) { case EQ: this.onGoingExpression.push(new BasicDBObject("$eq", values)); //$NON-NLS-1$ break; case NE: this.onGoingExpression.push(new BasicDBObject("$ne", values)); //$NON-NLS-1$ break; case LT: this.onGoingExpression.push(new BasicDBObject("$lt", values)); //$NON-NLS-1$ break; case LE: this.onGoingExpression.push(new BasicDBObject("$lte", values)); //$NON-NLS-1$ break; case GT: this.onGoingExpression.push(new BasicDBObject("$gt", values)); //$NON-NLS-1$ break; case GE: this.onGoingExpression.push(new BasicDBObject("$gte", values)); //$NON-NLS-1$ break; } }
@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; }
public void visit(Comparison obj) { if (obj.getLeftExpression() instanceof Condition) { buffer.append(Tokens.LPAREN); append(obj.getLeftExpression()); buffer.append(Tokens.RPAREN); } else { append(obj.getLeftExpression()); } buffer.append(Tokens.SPACE); buffer.append(obj.getOperator()); buffer.append(Tokens.SPACE); if (obj.getRightExpression() instanceof Condition) { buffer.append(Tokens.LPAREN); appendRightComparison(obj); buffer.append(Tokens.RPAREN); } else { appendRightComparison(obj); } }
protected void addCompareCriteria(Comparison compCriteria ) { Expression lExpr = compCriteria.getLeftExpression(); if (lExpr instanceof Function) { parseFunction((Function)lExpr); } else { criteriaBuffer.add(getValue(lExpr, false)); criteriaBuffer.add(SPACE); criteriaBuffer.add(compCriteria.getOperator()==Operator.NE?"!=":compCriteria.getOperator().toString()); //$NON-NLS-1$ criteriaBuffer.add(SPACE); Expression rExp = compCriteria.getRightExpression(); criteriaBuffer.add(getValue(rExp, false)); if (lExpr instanceof ColumnReference && "IsDeleted".equalsIgnoreCase(((ColumnReference)lExpr).getMetadataObject().getSourceName())) { //$NON-NLS-1$ Literal isDeletedLiteral = (Literal)compCriteria.getRightExpression(); Boolean isDeleted = (Boolean)isDeletedLiteral.getValue(); if (isDeleted) { this.queryAll = isDeleted; } } } }
switch(obj.getOperator()) { case EQ: this.filter.append("eq"); //$NON-NLS-1$
public void visitComparisonWithBooleanFunction(Comparison obj) { boolean truthiness = SQLConstants.Reserved.TRUE.equals(obj.getRightExpression().toString()); boolean isNot = !truthiness; switch(obj.getOperator()) { case EQ: break; case NE: isNot = !isNot; break; default: this.exceptions.add(new TranslatorException( ODataPlugin.Util.gs(ODataPlugin.Event.TEIID17018, ((Function)obj.getLeftExpression()).getName()))); } if(isNot) { // can't use a Not object, because it requires a Condition inside, // and we don't have support for generic unary conditions this.filter.append(NOT) .append(Tokens.SPACE) .append(Tokens.LPAREN); append(obj.getLeftExpression()); this.filter.append(Tokens.RPAREN); } else { append(obj.getLeftExpression()); } }
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); } }
switch(obj.getOperator()) { case EQ: this.filters.add(new CompareFilter(rightExpr-1, Operator.EQ));
if (comp.getOperator() != Operator.EQ) { continue;
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; } }
private boolean parseKeySegmentFromComparison(Comparison obj) throws TranslatorException { if (obj.getOperator().equals(Comparison.Operator.EQ)) { if (obj.getLeftExpression() instanceof ColumnReference && obj.getRightExpression() instanceof ColumnReference) { Column left = ((ColumnReference)obj.getLeftExpression()).getMetadataObject(); Column right = ((ColumnReference)obj.getRightExpression()).getMetadataObject(); if (isJoinOrPkColumn(left) && isJoinOrPkColumn(right)) { // in odata the navigation from parent to child implicit by their keys return true; } } } return false; }
if (compareCriteria.getOperator() != Operator.EQ) { final String msg = LDAPPlugin.Util.getString("LDAPUpdateExecution.criteriaNotEqualsError"); //$NON-NLS-1$ throw new TranslatorException(msg);
switch(obj.getOperator()) { case EQ: if (this.joinType.equals(JoinType.LEFT_OUTER_JOIN)) {
private boolean addEnityKey(Comparison obj) { if (obj.getOperator().equals(Comparison.Operator.EQ)) { if (obj.getLeftExpression() instanceof ColumnReference && obj.getRightExpression() instanceof Literal) { ColumnReference columnRef = (ColumnReference)obj.getLeftExpression(); Table parentTable = columnRef.getTable().getMetadataObject(); Entity entity = getEntity(parentTable); if (entity != null) { Column column = columnRef.getMetadataObject(); if (parentTable.getPrimaryKey().getColumnByName(column.getName())!=null) { entity.addKeyValue(column, (Literal)obj.getRightExpression()); return true; } } } if (obj.getLeftExpression() instanceof ColumnReference && obj.getRightExpression() instanceof ColumnReference) { Column left = ((ColumnReference)obj.getLeftExpression()).getMetadataObject(); Column right = ((ColumnReference)obj.getRightExpression()).getMetadataObject(); if (isJoinOrPkColumn(left)&& isJoinOrPkColumn(right)) { // in odata the navigation from parent to child implicit by their keys Entity leftEntity = getEntity((Table)left.getParent()); Entity rightEntity = getEntity((Table)right.getParent()); leftEntity.addRelation(left, right, rightEntity); rightEntity.addRelation(right,left, leftEntity); return true; } } } return false; }