protected void appendRightComparison(Comparison obj) { append(obj.getRightExpression()); }
protected void appendRightComparison(Comparison obj) { append(obj.getRightExpression()); }
protected void appendRightComparison(Comparison obj) { append(obj.getRightExpression()); }
@Override protected void appendRightComparison(Comparison obj) { if (obj.getRightExpression() instanceof Array) { //oracle needs rhs arrays nested in extra parens buffer.append(SQLConstants.Tokens.LPAREN); super.appendRightComparison(obj); buffer.append(SQLConstants.Tokens.RPAREN); } else { super.appendRightComparison(obj); } }
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 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); }
private boolean isInComparison(NamedTable table, Comparison comparison) { return isInReference(table, (ColumnReference)comparison.getLeftExpression()) || isInReference(table, (ColumnReference)comparison.getRightExpression()); }
public void visit(Comparison obj) { visitNode(obj.getLeftExpression()); visitNode(obj.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; }
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; } } } }
@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 testGetRightExpression() throws Exception { Comparison impl = example(AbstractCompareCriteria.GE, 200, 100); assertNotNull(impl.getRightExpression()); assertTrue(impl.getRightExpression() instanceof Literal); assertEquals(new Integer(100), ((Literal)impl.getRightExpression()).getValue()); }
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()); } }
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 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); }
@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 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) { // 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); } }
@Test public void testBindings() throws Exception { BasicSourceCapabilities caps = TestOptimizer.getTypicalCapabilities(); caps.setCapabilitySupport(Capability.DEPENDENT_JOIN_BINDINGS, true); ProcessorPlan plan = TestOptimizer.helpPlan("select pm1.g1.e1, pm1.g1.e2, pm2.g1.e2 FROM pm1.g1, /*+ makedep */ pm2.g1 where (pm1.g1.e1 = pm2.g1.e1)", TestOptimizer.example1(), //$NON-NLS-1$ new String[] { "SELECT g_0.e1 AS c_0, g_0.e2 AS c_1 FROM pm1.g1 AS g_0 ORDER BY c_0", "SELECT g_0.e1 AS c_0, g_0.e2 AS c_1 FROM pm2.g1 AS g_0 WHERE g_0.e1 IN (<dependent values>) ORDER BY c_0" }, new DefaultCapabilitiesFinder(caps), TestOptimizer.ComparisonMode.EXACT_COMMAND_STRING ); //$NON-NLS-1$ //$NON-NLS-2$ List<?>[] expected = new List<?>[] { Arrays.asList(new Object[] { "a", 1, 2 }), //$NON-NLS-1$ }; HardcodedDataManager dataManager = new HardcodedDataManager(RealMetadataFactory.example1Cached()); dataManager.addData("SELECT g_0.e1 AS c_0, g_0.e2 AS c_1 FROM g1 AS g_0 ORDER BY c_0", new List<?>[] {Arrays.asList("a", 1)}); dataManager.addData("SELECT g_0.e1 AS c_0, g_0.e2 AS c_1 FROM g1 AS g_0 WHERE g_0.e1 = 'a' ORDER BY c_0", new List<?>[] {Arrays.asList("a", 2)}); TestProcessor.helpProcess(plan, dataManager, expected); Select select = (Select)dataManager.getPushdownCommands().get(1); assertTrue(((Literal)((Comparison)select.getWhere()).getRightExpression()).isBindEligible()); }