public static boolean canPushLanguageObject(LanguageObject obj, Object modelID, QueryMetadataInterface metadata, CapabilitiesFinder capFinder, AnalysisRecord analysisRecord) throws QueryMetadataException, TeiidComponentException { return canPushLanguageObject(obj, modelID, metadata, capFinder, analysisRecord, false, false, false); }
public void visit(SetCriteria crit) { if (willBecomeConstant(crit)) { return; } checkAbstractSetCriteria(crit); try { int maxSize = CapabilitiesUtil.getMaxInCriteriaSize(modelID, metadata, capFinder); int maxPredicates = CapabilitiesUtil.getMaxDependentPredicates(modelID, metadata, capFinder); //allow 1/2 to a single predicate - TODO: make this more precise if (maxSize > 0 && maxPredicates > 0 && crit.getValues().size() > Math.max(maxSize, (maxSize * (long)maxPredicates)/2)) { markInvalid(crit, "SetCriteria size exceeds maximum for source"); //$NON-NLS-1$ return; } } catch(QueryMetadataException e) { handleException(new TeiidComponentException(e)); } catch(TeiidComponentException e) { handleException(e); } checkLiteralComparison(crit, crit.getValues()); }
markInvalid(crit, "Quantified compare with an array cannot yet be pushed down."); //$NON-NLS-1$ return; markInvalid(crit, "SubqueryCompare not supported by source"); //$NON-NLS-1$ return; checkCompareCriteria(crit, crit.getCommand().getProjectedSymbols().get(0)); if (validateSubqueryPushdown(crit, modelID, metadata, capFinder, analysisRecord) == null) { markInvalid(crit.getCommand(), "Subquery cannot be pushed down"); //$NON-NLS-1$ handleException(new TeiidComponentException(e)); } catch(TeiidComponentException e) { handleException(e);
public void visit(AggregateSymbol obj) { try { if(! CapabilitiesUtil.supportsAggregateFunction(modelID, obj, metadata, capFinder)) { markInvalid(obj, "Aggregate function pushdown not supported by source"); //$NON-NLS-1$ } } catch(QueryMetadataException e) { handleException(new TeiidComponentException(e)); } catch(TeiidComponentException e) { handleException(e); } }
public void visit(SubquerySetCriteria crit) { checkAbstractSetCriteria(crit); try { // Check if compares with subqueries are allowed if(! this.caps.supportsCapability(Capability.CRITERIA_IN_SUBQUERY)) { markInvalid(crit, "SubqueryIn is not supported by source"); //$NON-NLS-1$ return; } if (validateSubqueryPushdown(crit, modelID, metadata, capFinder, analysisRecord) == null) { markInvalid(crit.getCommand(), "Subquery cannot be pushed down"); //$NON-NLS-1$ } } catch(QueryMetadataException e) { handleException(new TeiidComponentException(e)); } catch(TeiidComponentException e) { handleException(e); } }
@Override public void visit(OrderByItem obj) { try { checkElementsAreSearchable(obj.getSymbol(), SupportConstants.Element.SEARCHABLE_COMPARE); if (!CapabilitiesUtil.supportsNullOrdering(this.metadata, this.capFinder, this.modelID, obj)) { markInvalid(obj, "Desired null ordering is not supported by source"); //$NON-NLS-1$ } } catch(QueryMetadataException e) { handleException(new TeiidComponentException(e)); } catch(TeiidComponentException e) { handleException(e); } }
public void checkAbstractSetCriteria(AbstractSetCriteria crit) { try { // Check if compares are allowed if(! this.caps.supportsCapability(Capability.CRITERIA_IN)) { if (willBecomeConstant(crit)) { return; } markInvalid(crit, "In is not supported by source"); //$NON-NLS-1$ return; } if (crit.isNegated() && !this.caps.supportsCapability(Capability.CRITERIA_NOT)) { if (willBecomeConstant(crit)) { return; } markInvalid(crit, "Negation is not supported by source"); //$NON-NLS-1$ return; } // Check capabilities of the elements checkElementsAreSearchable(crit.getExpression(), SupportConstants.Element.SEARCHABLE_COMPARE); } catch(QueryMetadataException e) { handleException(new TeiidComponentException(e)); } catch(TeiidComponentException e) { handleException(e); } }
for (int i = 0; i < insert.getValues().size(); i++) { Expression ex = (Expression)insert.getValues().get(i); if (!CriteriaCapabilityValidatorVisitor.canPushLanguageObject(ex, modelID, metadata, capFinder, analysisRecord)) { final CriteriaCapabilityValidatorVisitor capVisitor = new CriteriaCapabilityValidatorVisitor(modelID, metadata, capFinder, caps); capVisitor.setCheckEvaluation(false); DeepPreOrderNavigator nav = new DeepPreOrderNavigator(ev) { protected void visitNode(org.teiid.query.sql.LanguageObject obj) { if (!capVisitor.isValid()) {
private boolean isPushdownValid(WithQueryCommand with, SetQuery setQuery, Object modelID, QueryCommand withCommand, RelationalPlan subPlan1) throws QueryMetadataException, TeiidComponentException { AccessNode aNode1 = CriteriaCapabilityValidatorVisitor.getAccessNode(subPlan1); if (aNode1 == null) { return false; } Object modelID1 = CriteriaCapabilityValidatorVisitor.validateCommandPushdown(null, metadata, capFinder, aNode1, false); QueryCommand withCommand1 = CriteriaCapabilityValidatorVisitor.getQueryCommand(aNode1); if (modelID1 == null || withCommand1 == null) { return false; } //if we are the same connector for each, then we should be good to proceed if (CapabilitiesUtil.isSameConnector(modelID, modelID1, metadata, capFinder)) { SetQuery pushdownSetQuery = new SetQuery(Operation.UNION, setQuery.isAll(), withCommand, withCommand1); WithQueryCommand wqc = new WithQueryCommand(with.getGroupSymbol(), with.getColumns(), pushdownSetQuery); wqc.setRecursive(true); this.withPlanningState.pushdownWith.put(with.getGroupSymbol().getName(), wqc); return true; } return false; }
CriteriaCapabilityValidatorVisitor visitor = new CriteriaCapabilityValidatorVisitor(modelID, metadata, capFinder, caps); visitor.setCheckEvaluation(!parameterObject.multiValuedReferences); visitor.analysisRecord = analysisRecord; visitor.isJoin = parameterObject.isJoin; obj.acceptVisitor(nav); if(visitor.getException() != null) { throw visitor.getException(); return visitor.isValid();
ProcessorPlan plan = subqueryContainer.getCommand().getProcessorPlan(); if (plan != null) { AccessNode aNode = getAccessNode(plan); critNodeModelID = validateCommandPushdown(critNodeModelID, metadata, capFinder, aNode, true); if (!CriteriaCapabilityValidatorVisitor.canPushLanguageObject(subqueryContainer.getCommand(), critNodeModelID, metadata, capFinder, analysisRecord )) { return null;
/** * @see org.teiid.query.sql.LanguageVisitor#visit(org.teiid.query.sql.lang.ExistsCriteria) */ public void visit(ExistsCriteria crit) { // Check if exists criteria are allowed if(! this.caps.supportsCapability(Capability.CRITERIA_EXISTS)) { markInvalid(crit, "Exists is not supported by source"); //$NON-NLS-1$ return; } if (crit.isNegated() && !this.caps.supportsCapability(Capability.CRITERIA_NOT)) { markInvalid(crit, "Negation is not supported by source"); //$NON-NLS-1$ return; } try { if (validateSubqueryPushdown(crit, modelID, metadata, capFinder, analysisRecord) == null) { if (crit.getCommand().getCorrelatedReferences() == null) { crit.setShouldEvaluate(true); } else { markInvalid(crit.getCommand(), "Subquery cannot be pushed down"); //$NON-NLS-1$ } } } catch (TeiidComponentException e) { handleException(e); } }
markEvaluatable(obj, canPreEval, "Correlated/nonDeterministic ScalarSubquery is not supported"); //$NON-NLS-1$ } else if (validateSubqueryPushdown(obj, modelID, metadata, capFinder, analysisRecord) == null) { markEvaluatable(obj, canPreEval, "Subquery cannot be pushed down"); //$NON-NLS-1$ } else if (this.isSelectClause && !this.caps.supportsCapability(Capability.QUERY_SUBQUERIES_SCALAR_PROJECTION)) { markEvaluatable(obj, canPreEval, "Correlated/nonDeterministic ScalarSubquery cannot be used in the SELECT clause"); //$NON-NLS-1$ } else if (canPreEval) { handleException(new TeiidComponentException(e)); } catch(TeiidComponentException e) { handleException(e);
public static void prepareSubquery(SubqueryContainer container) { RelationalPlan subqueryPlan = (RelationalPlan)container.getCommand().getProcessorPlan(); AccessNode aNode = CriteriaCapabilityValidatorVisitor.getAccessNode(subqueryPlan); QueryCommand command = CriteriaCapabilityValidatorVisitor.getQueryCommand(aNode); if (command == null) { return; } final SymbolMap map = container.getCommand().getCorrelatedReferences(); if (map != null) { ExpressionMappingVisitor visitor = new RulePlanSubqueries.ReferenceReplacementVisitor(map); DeepPostOrderNavigator.doVisit(command, visitor); } command.setProcessorPlan(container.getCommand().getProcessorPlan()); boolean removeLimit = false; if (container instanceof ExistsCriteria) { removeLimit = !((ExistsCriteria)container).shouldEvaluate(); } else if (container instanceof ScalarSubquery) { removeLimit = !((ScalarSubquery)container).shouldEvaluate(); } if (removeLimit && command.getLimit() != null && command.getLimit().isImplicit()) { command.setLimit(null); } container.setCommand(command); }
if (willBecomeConstant(obj)) { return; markInvalid(obj, "Function metadata indicates it cannot be pusheddown."); //$NON-NLS-1$ return; if (willBecomeConstant(obj)) { return; markInvalid(obj, (obj.isImplicit()?"(implicit) ":"") + obj.getName() + " function not supported by source"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ return; if (willBecomeConstant(obj)) { return; markInvalid(obj, obj.getName() + " non-literal parse format function not supported by source"); //$NON-NLS-1$ return; markInvalid(obj, obj.getName() + " non-literal parse format function not supported by source"); //$NON-NLS-1$ return; markInvalid(obj, obj.getName() + " literal parse " + c + " not supported by source"); //$NON-NLS-1$ //$NON-NLS-2$ return; handleException(new TeiidComponentException(e)); } catch(TeiidComponentException e) { handleException(e);
AccessNode aNode = CriteriaCapabilityValidatorVisitor.getAccessNode(this.processPlan); if (aNode != null) { String modelName = aNode.getModelName(); if (supportPreparedBatchUpdate && !CriteriaCapabilityValidatorVisitor.canPushLanguageObject(command, metadata.getModelID(modelName), metadata, capabilitiesFinder, analysisRecord, new ValidatorOptions(false, false, true))) { supportPreparedBatchUpdate = false;
public void visit(CompareCriteria obj) { checkCompareCriteria(obj, obj.getRightExpression()); checkLiteralComparison(obj, Arrays.asList(obj.getRightExpression())); }
/** * Returns whether a command can be placed in a connector batch * @param command an update command * @param metadata * @return true if this command can be added to a batch; false otherwise * @throws QueryMetadataException * @throws TeiidComponentException * @since 4.2 */ public static boolean isEligibleForBatching(Command command, QueryMetadataInterface metadata) throws QueryMetadataException, TeiidComponentException { ProcessorPlan plan = command.getProcessorPlan(); AccessNode aNode = CriteriaCapabilityValidatorVisitor.getAccessNode(plan); // If the command updates a physical group, it's eligible return aNode != null && !metadata.isVirtualGroup(getUpdatedGroup(command).getMetadataID()); }
public void visit(DependentSetCriteria crit) { checkAbstractSetCriteria(crit); }
public void checkAbstractSetCriteria(AbstractSetCriteria crit) { try { // Check if compares are allowed if(! this.caps.supportsCapability(Capability.CRITERIA_IN)) { if (willBecomeConstant(crit)) { return; } markInvalid(crit, "In is not supported by source"); //$NON-NLS-1$ return; } if (crit.isNegated() && !this.caps.supportsCapability(Capability.CRITERIA_NOT)) { if (willBecomeConstant(crit)) { return; } markInvalid(crit, "Negation is not supported by source"); //$NON-NLS-1$ return; } // Check capabilities of the elements checkElementsAreSearchable(crit.getExpression(), SupportConstants.Element.SEARCHABLE_COMPARE); } catch(QueryMetadataException e) { handleException(new TeiidComponentException(e)); } catch(TeiidComponentException e) { handleException(e); } }