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); } }
@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; }
@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); } }
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; }
@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); } }
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()); } }
@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; } }
public void visit(Comparison obj) { visitNode(obj.getLeftExpression()); visitNode(obj.getRightExpression()); }
private boolean isInComparison(NamedTable table, Comparison comparison) { return isInReference(table, (ColumnReference)comparison.getLeftExpression()) || isInReference(table, (ColumnReference)comparison.getRightExpression()); }
@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; }
@Override public void visit(Comparison obj) { // this for $cond in the select statement, and formatting of command for $cond vs $match is different if (this.processingDerivedColumn) { visitDerivedExpression(obj); return; } // this for the normal where clause ColumnDetail leftExprDetails = getExpressionAlias(obj.getLeftExpression()); append(obj.getRightExpression()); Object rightExpr = this.onGoingExpression.pop(); if (this.expressionMap.get(rightExpr) != null) { rightExpr = this.expressionMap.get(rightExpr).getProjectedName(); } QueryBuilder query = leftExprDetails.getQueryBuilder(); rightExpr = checkAndConvertToObjectId(obj.getLeftExpression(), obj.getRightExpression(), rightExpr); buildComparisionQuery(obj, rightExpr, query); if (leftExprDetails.partOfProject || obj.getLeftExpression() instanceof ColumnReference) { this.onGoingExpression.push(query.get()); } else { this.onGoingExpression.push(buildFunctionQuery(obj, (BasicDBObject)leftExprDetails.expression, rightExpr)); } if (obj.getLeftExpression() instanceof ColumnReference) { ColumnReference column = (ColumnReference)obj.getLeftExpression(); this.mongoDoc.updateReferenceColumnValue(column.getTable().getName(), column.getName(), rightExpr); } }
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()); }
@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) { 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$ } } }
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; }
@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 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; } } } }
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; }
throw new TranslatorException(msg); Expression leftExpr = compareCriteria.getLeftExpression(); if (!(leftExpr instanceof ColumnReference)) { final String msg = LDAPPlugin.Util.getString("LDAPUpdateExecution.criteriaLHSNotElementError"); //$NON-NLS-1$