private void setRoutingName(AccessNode accessNode, PlanNode node, Command command)
throws QueryPlannerException, TeiidComponentException {
// Look up connector binding name
try {
Object modelID = node.getProperty(NodeConstants.Info.MODEL_ID);
if (modelID == null || modelID instanceof TempMetadataID) {
if (command instanceof StoredProcedure) {
modelID = ((StoredProcedure) command).getModelID();
} else if (!(command instanceof Create || command instanceof Drop)) {
Collection<GroupSymbol> groups = GroupCollectorVisitor.getGroups(command, true);
GroupSymbol group = groups.iterator().next();
modelID = metadata.getModelID(group.getMetadataID());
}
}
String cbName = metadata.getFullName(modelID);
accessNode.setModelName(cbName);
accessNode.setModelId(modelID);
accessNode.setConformedTo((Set<Object>) node.getProperty(Info.CONFORMED_SOURCES));
} catch (QueryMetadataException e) {
throw new QueryPlannerException(
QueryPlugin.Event.TEIID30251, e, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30251));
}
}
private RelationalNode correctProjectionInternalTables(PlanNode node, AccessNode aNode)
throws QueryMetadataException, TeiidComponentException {
if (node.getGroups().size() != 1) {
return aNode;
}
GroupSymbol group = node.getGroups().iterator().next();
if (!CoreConstants.SYSTEM_MODEL.equals(
metadata.getFullName(metadata.getModelID(group.getMetadataID())))
&& !CoreConstants.SYSTEM_ADMIN_MODEL.equals(
metadata.getFullName(metadata.getModelID(group.getMetadataID())))) {
return aNode;
}
List projectSymbols = (List) node.getProperty(NodeConstants.Info.OUTPUT_COLS);
List<ElementSymbol> acutalColumns = ResolverUtil.resolveElementsInGroup(group, metadata);
if (projectSymbols.equals(acutalColumns)) {
return aNode;
}
node.setProperty(NodeConstants.Info.OUTPUT_COLS, acutalColumns);
if (node.getParent() != null && node.getParent().getType() == NodeConstants.Types.PROJECT) {
// if the parent is already a project, just correcting the output cols is enough
return aNode;
}
ProjectNode pnode = new ProjectNode(getID());
pnode.setSelectSymbols(projectSymbols);
aNode = (AccessNode) prepareToAdd(node, aNode);
node.setProperty(NodeConstants.Info.OUTPUT_COLS, projectSymbols);
pnode.addChild(aNode);
return pnode;
}
private Expression rewriteMultiSourceCommand(Command command) throws TeiidComponentException {
Expression result = null;
if (command instanceof StoredProcedure) {
StoredProcedure obj = (StoredProcedure) command;
for (Iterator<SPParameter> params = obj.getMapOfParameters().values().iterator();
params.hasNext(); ) {
SPParameter param = params.next();
if (param.getParameterType() != SPParameter.IN) {
continue;
}
if (metadata.isMultiSourceElement(param.getMetadataID())) {
Expression source = param.getExpression();
params.remove();
if (param.isUsingDefault()
&& source instanceof Constant
&& ((Constant) source).isNull()) {
continue;
}
result = source;
break;
}
}
}
if (command instanceof Insert) {
Insert obj = (Insert) command;
for (int i = 0; i < obj.getVariables().size(); i++) {
ElementSymbol elem = obj.getVariables().get(i);
Object metadataID = elem.getMetadataID();
if (metadata.isMultiSourceElement(metadataID)) {
Expression source = (Expression) obj.getValues().get(i);
obj.getVariables().remove(i);
obj.getValues().remove(i);
result = source;
break;
}
}
} else if (command instanceof FilteredCommand) {
for (Criteria c : Criteria.separateCriteriaByAnd(((FilteredCommand) command).getCriteria())) {
if (!(c instanceof CompareCriteria)) {
continue;
}
CompareCriteria cc = (CompareCriteria) c;
if (cc.getLeftExpression() instanceof ElementSymbol) {
ElementSymbol es = (ElementSymbol) cc.getLeftExpression();
if (metadata.isMultiSourceElement(es.getMetadataID())
&& EvaluatableVisitor.willBecomeConstant(cc.getRightExpression())) {
if (result != null && !result.equals(cc.getRightExpression())) {
return Constant.NULL_CONSTANT;
}
result = cc.getRightExpression();
}
}
}
}
return result;
}
private Object validateMatView(QueryMetadataInterface metadata, String viewName)
throws TeiidComponentException, TeiidProcessingException {
try {
Object groupID = metadata.getGroupID(viewName);
if (!metadata.hasMaterialization(groupID) || metadata.getMaterialization(groupID) != null) {
throw new QueryProcessingException(
QueryPlugin.Event.TEIID30233,
QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30233, viewName));
}
return groupID;
} catch (QueryMetadataException e) {
throw new TeiidProcessingException(QueryPlugin.Event.TEIID30234, e);
}
}
private void checkNotNull(ElementSymbol param, Object value)
throws TeiidComponentException, QueryMetadataException, QueryValidatorException {
if (metadata.elementSupports(param.getMetadataID(), SupportConstants.Element.NULL)) {
return;
}
if (metadata.isVariadic(param.getMetadataID())) {
if (value instanceof ArrayImpl) {
ArrayImpl av = (ArrayImpl) value;
for (Object o : av.getValues()) {
if (o == null) {
throw new QueryValidatorException(
QueryPlugin.Event.TEIID30164,
QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30164, param));
}
}
}
} else if (value == null) {
throw new QueryValidatorException(
QueryPlugin.Event.TEIID30164, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30164, param));
}
}
protected RelationalNode convertNode(PlanNode node)
throws TeiidComponentException, TeiidProcessingException {
RelationalNode processNode = null;
switch (node.getType()) {
case NodeConstants.Types.PROJECT:
GroupSymbol intoGroup = (GroupSymbol) node.getProperty(NodeConstants.Info.INTO_GROUP);
if (intoGroup != null) {
try {
Insert insert = (Insert) node.getFirstChild().getProperty(Info.VIRTUAL_COMMAND);
List<ElementSymbol> allIntoElements = insert.getVariables();
Object groupID = intoGroup.getMetadataID();
Object modelID = metadata.getModelID(groupID);
String modelName = metadata.getFullName(modelID);
if (metadata.isVirtualGroup(groupID)) {
InsertPlanExecutionNode ipen = new InsertPlanExecutionNode(getID(), metadata);
ipen.setProcessorPlan(
(ProcessorPlan) node.getFirstChild().getProperty(Info.PROCESSOR_PLAN));
ipen.setReferences(insert.getValues());
processNode = ipen;
} else {
ProjectIntoNode pinode = new ProjectIntoNode(getID());
pinode.setIntoGroup(intoGroup);
pinode.setIntoElements(allIntoElements);
pinode.setModelName(modelName);
pinode.setConstraint((Criteria) node.getProperty(Info.CONSTRAINT));
processNode = pinode;
SourceCapabilities caps = capFinder.findCapabilities(modelName);
if (caps.supportsCapability(Capability.INSERT_WITH_ITERATOR)) {
pinode.setMode(org.teiid.query.processor.relational.ProjectIntoNode.Mode.ITERATOR);
} else if (caps.supportsCapability(Capability.BATCHED_UPDATES)) {
pinode.setMode(org.teiid.query.processor.relational.ProjectIntoNode.Mode.BATCH);
} else {
pinode.setMode(org.teiid.query.processor.relational.ProjectIntoNode.Mode.SINGLE);
}
}
} catch (QueryMetadataException e) {
throw new TeiidComponentException(QueryPlugin.Event.TEIID30247, e);
}
} else {
List<Expression> symbols = (List) node.getProperty(NodeConstants.Info.PROJECT_COLS);
ProjectNode pnode = new ProjectNode(getID());
pnode.setSelectSymbols(symbols);
processNode = pnode;
if (node.hasBooleanProperty(Info.HAS_WINDOW_FUNCTIONS)) {
WindowFunctionProjectNode wfpn = new WindowFunctionProjectNode(getID());
// with partial projection the window function may already be pushed, we'll check for
// that here
ArrayList<Expression> filtered = new ArrayList<Expression>();
List<Expression> childSymbols =
(List) node.getFirstChild().getProperty(NodeConstants.Info.OUTPUT_COLS);
for (Expression ex : symbols) {
ex = SymbolMap.getExpression(ex);
if (childSymbols.contains(ex)) {
continue;
}
filtered.add(ex);
}
Set<WindowFunction> windowFunctions =
RuleAssignOutputElements.getWindowFunctions(filtered);
if (!windowFunctions.isEmpty()) {
// TODO: check for selecting all window functions
List<Expression> outputElements = new ArrayList<Expression>(windowFunctions);
// collect the other projected expressions
for (Expression singleElementSymbol :
(List<Expression>) node.getFirstChild().getProperty(Info.OUTPUT_COLS)) {
outputElements.add(singleElementSymbol);
}
wfpn.setElements(outputElements);
wfpn.init();
pnode.addChild(wfpn);
}
}
}
break;
case NodeConstants.Types.JOIN:
JoinType jtype = (JoinType) node.getProperty(NodeConstants.Info.JOIN_TYPE);
JoinStrategyType stype =
(JoinStrategyType) node.getProperty(NodeConstants.Info.JOIN_STRATEGY);
JoinNode jnode = new JoinNode(getID());
jnode.setJoinType(jtype);
jnode.setLeftDistinct(node.hasBooleanProperty(NodeConstants.Info.IS_LEFT_DISTINCT));
jnode.setRightDistinct(node.hasBooleanProperty(NodeConstants.Info.IS_RIGHT_DISTINCT));
List joinCrits = (List) node.getProperty(NodeConstants.Info.JOIN_CRITERIA);
String depValueSource =
(String) node.getProperty(NodeConstants.Info.DEPENDENT_VALUE_SOURCE);
SortOption leftSort = (SortOption) node.getProperty(NodeConstants.Info.SORT_LEFT);
if (stype == JoinStrategyType.MERGE || stype == JoinStrategyType.ENHANCED_SORT) {
MergeJoinStrategy mjStrategy = null;
if (stype.equals(JoinStrategyType.ENHANCED_SORT)) {
EnhancedSortMergeJoinStrategy esmjStrategy =
new EnhancedSortMergeJoinStrategy(
leftSort, (SortOption) node.getProperty(NodeConstants.Info.SORT_RIGHT));
esmjStrategy.setSemiDep(node.hasBooleanProperty(Info.IS_SEMI_DEP));
mjStrategy = esmjStrategy;
} else {
mjStrategy =
new MergeJoinStrategy(
leftSort, (SortOption) node.getProperty(NodeConstants.Info.SORT_RIGHT), false);
}
jnode.setJoinStrategy(mjStrategy);
List leftExpressions = (List) node.getProperty(NodeConstants.Info.LEFT_EXPRESSIONS);
List rightExpressions = (List) node.getProperty(NodeConstants.Info.RIGHT_EXPRESSIONS);
jnode.setJoinExpressions(leftExpressions, rightExpressions);
joinCrits = (List) node.getProperty(NodeConstants.Info.NON_EQUI_JOIN_CRITERIA);
} else if (stype == JoinStrategyType.NESTED_TABLE) {
NestedTableJoinStrategy ntjStrategy = new NestedTableJoinStrategy();
jnode.setJoinStrategy(ntjStrategy);
SymbolMap references = (SymbolMap) node.getProperty(Info.LEFT_NESTED_REFERENCES);
ntjStrategy.setLeftMap(references);
references = (SymbolMap) node.getProperty(Info.RIGHT_NESTED_REFERENCES);
ntjStrategy.setRightMap(references);
} else {
NestedLoopJoinStrategy nljStrategy = new NestedLoopJoinStrategy();
jnode.setJoinStrategy(nljStrategy);
}
Criteria joinCrit = Criteria.combineCriteria(joinCrits);
jnode.setJoinCriteria(joinCrit);
processNode = jnode;
jnode.setDependentValueSource(depValueSource);
break;
case NodeConstants.Types.ACCESS:
ProcessorPlan plan = (ProcessorPlan) node.getProperty(NodeConstants.Info.PROCESSOR_PLAN);
if (plan != null) {
PlanExecutionNode peNode = null;
Criteria crit = (Criteria) node.getProperty(NodeConstants.Info.PROCEDURE_CRITERIA);
if (crit != null) {
List references = (List) node.getProperty(NodeConstants.Info.PROCEDURE_INPUTS);
List defaults = (List) node.getProperty(NodeConstants.Info.PROCEDURE_DEFAULTS);
peNode = new DependentProcedureExecutionNode(getID(), crit, references, defaults);
} else {
peNode = new PlanExecutionNode(getID());
}
peNode.setProcessorPlan(plan);
processNode = peNode;
} else {
AccessNode aNode = null;
Command command = (Command) node.getProperty(NodeConstants.Info.ATOMIC_REQUEST);
Object modelID = node.getProperty(NodeConstants.Info.MODEL_ID);
if (modelID != null) {
String fullName = metadata.getFullName(modelID);
if (!capFinder.isValid(fullName)) {
// TODO: we ideally want to handle the partial resutls case here differently
// by adding a null node / and a source warning
// for now it's just as easy to say that the user needs to take steps to
// return static capabilities
SourceCapabilities caps = capFinder.findCapabilities(fullName);
Exception cause = null;
if (caps != null) {
cause = (Exception) caps.getSourceProperty(Capability.INVALID_EXCEPTION);
}
throw new QueryPlannerException(
QueryPlugin.Event.TEIID30498,
cause,
QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30498, fullName));
}
}
EvaluatableVisitor ev = null;
if (node.hasBooleanProperty(NodeConstants.Info.IS_DEPENDENT_SET)) {
if (command instanceof StoredProcedure) {
List references = (List) node.getProperty(NodeConstants.Info.PROCEDURE_INPUTS);
List defaults = (List) node.getProperty(NodeConstants.Info.PROCEDURE_DEFAULTS);
Criteria crit = (Criteria) node.getProperty(NodeConstants.Info.PROCEDURE_CRITERIA);
DependentProcedureAccessNode depAccessNode =
new DependentProcedureAccessNode(getID(), crit, references, defaults);
processNode = depAccessNode;
aNode = depAccessNode;
} else {
// create dependent access node
DependentAccessNode depAccessNode = new DependentAccessNode(getID());
if (modelID != null) {
depAccessNode.setPushdown(
CapabilitiesUtil.supports(
Capability.DEPENDENT_JOIN, modelID, metadata, capFinder));
depAccessNode.setMaxSetSize(
CapabilitiesUtil.getMaxInCriteriaSize(modelID, metadata, capFinder));
depAccessNode.setMaxPredicates(
CapabilitiesUtil.getMaxDependentPredicates(modelID, metadata, capFinder));
depAccessNode.setUseBindings(
CapabilitiesUtil.supports(
Capability.DEPENDENT_JOIN_BINDINGS, modelID, metadata, capFinder));
// TODO: allow the translator to drive this property
// simplistic check of whether this query is complex to re-execute
Query query = (Query) command;
if (query.getGroupBy() != null
|| query.getFrom().getClauses().size() > 1
|| !(query.getFrom().getClauses().get(0) instanceof UnaryFromClause)
|| query.getWith() != null) {
depAccessNode.setComplexQuery(true);
} else {
// check to see if there in an index on at least one of the dependent sets
Set<GroupSymbol> groups = new HashSet<GroupSymbol>(query.getFrom().getGroups());
boolean found = false;
for (Criteria crit : Criteria.separateCriteriaByAnd(query.getCriteria())) {
if (crit instanceof DependentSetCriteria) {
DependentSetCriteria dsc = (DependentSetCriteria) crit;
if (NewCalculateCostUtil.getKeyUsed(
ElementCollectorVisitor.getElements(dsc.getExpression(), true),
groups,
metadata,
null)
!= null) {
found = true;
break;
}
}
}
if (!found) {
depAccessNode.setComplexQuery(true);
}
}
}
processNode = depAccessNode;
aNode = depAccessNode;
}
aNode.setShouldEvaluateExpressions(true);
} else {
// create access node
aNode = new AccessNode(getID());
processNode = aNode;
}
// -- special handling for system tables. currently they cannot perform projection
try {
if (command instanceof Query) {
processNode = correctProjectionInternalTables(node, aNode);
}
} catch (QueryMetadataException err) {
throw new TeiidComponentException(QueryPlugin.Event.TEIID30248, err);
}
setRoutingName(aNode, node, command);
boolean shouldEval = false;
if (command instanceof Insert) {
Insert insert = (Insert) command;
if (insert.getQueryExpression() != null) {
insert.setQueryExpression(
(QueryCommand) aliasCommand(aNode, insert.getQueryExpression(), modelID));
} else {
for (int i = 0; i < insert.getValues().size(); i++) {
Expression ex = (Expression) insert.getValues().get(i);
if (!CriteriaCapabilityValidatorVisitor.canPushLanguageObject(
ex, modelID, metadata, capFinder, analysisRecord)) {
// replace with an expression symbol to let the rewriter know that it should be
// replaced
insert.getValues().set(i, new ExpressionSymbol("x", ex));
shouldEval = true;
}
}
}
} else if (command instanceof QueryCommand) {
command = aliasCommand(aNode, command, modelID);
}
ev = EvaluatableVisitor.needsEvaluation(command, modelID, metadata, capFinder);
aNode.setShouldEvaluateExpressions(
ev.requiresEvaluation(EvaluationLevel.PROCESSING) || shouldEval);
aNode.setCommand(command);
Map<GroupSymbol, PlanNode> subPlans =
(Map<GroupSymbol, PlanNode>) node.getProperty(Info.SUB_PLANS);
// it makes more sense to allow the multisource affect to be elevated above just access
// nodes
if (aNode.getModelId() != null && metadata.isMultiSource(aNode.getModelId())) {
VDBMetaData vdb = context.getVdb();
aNode.setShouldEvaluateExpressions(true); // forces a rewrite
aNode.setElements((List) node.getProperty(NodeConstants.Info.OUTPUT_COLS));
if (node.hasBooleanProperty(Info.IS_MULTI_SOURCE)) {
Expression ex = rewriteMultiSourceCommand(aNode.getCommand());
aNode.setConnectorBindingExpression(ex);
aNode.setMultiSource(true);
} else {
String sourceName = (String) node.getProperty(Info.SOURCE_NAME);
aNode.setConnectorBindingExpression(new Constant(sourceName));
}
} else if (subPlans == null) {
if (!aNode.isShouldEvaluate()) {
aNode.minimizeProject(command);
}
// check if valid to share this with other nodes
if (ev != null
&& ev.getDeterminismLevel().compareTo(Determinism.COMMAND_DETERMINISTIC) >= 0
&& command.areResultsCachable()) {
checkForSharedSourceCommand(aNode);
}
}
if (subPlans != null) {
QueryCommand qc = (QueryCommand) command;
if (qc.getWith() == null) {
qc.setWith(new ArrayList<WithQueryCommand>(subPlans.size()));
}
Map<GroupSymbol, RelationalPlan> plans =
new LinkedHashMap<GroupSymbol, RelationalPlan>();
for (Map.Entry<GroupSymbol, PlanNode> entry : subPlans.entrySet()) {
RelationalPlan subPlan = convert(entry.getValue());
List<ElementSymbol> elems =
ResolverUtil.resolveElementsInGroup(entry.getKey(), metadata);
subPlan.setOutputElements(elems);
plans.put(entry.getKey(), subPlan);
WithQueryCommand withQueryCommand = new WithQueryCommand(entry.getKey(), elems, null);
qc.getWith().add(withQueryCommand);
}
aNode.setSubPlans(plans);
}
}
break;
case NodeConstants.Types.SELECT:
Criteria crit = (Criteria) node.getProperty(NodeConstants.Info.SELECT_CRITERIA);
if (!node.hasCollectionProperty(Info.OUTPUT_COLS)) {
// the late optimization to create a dependent join from a subquery introduces
// criteria that have no output elements set
// TODO that should be cleaner, but the logic currently expects to be run after join
// implementation
// and rerunning assign output elements seems excessive
node.setProperty(Info.OUTPUT_COLS, node.getFirstChild().getProperty(Info.OUTPUT_COLS));
}
SelectNode selnode = new SelectNode(getID());
selnode.setCriteria(crit);
// in case the parent was a source
selnode.setProjectedExpressions(
(List<Expression>) node.getProperty(NodeConstants.Info.PROJECT_COLS));
processNode = selnode;
break;
case NodeConstants.Types.SORT:
case NodeConstants.Types.DUP_REMOVE:
if (node.getType() == NodeConstants.Types.DUP_REMOVE) {
processNode = new DupRemoveNode(getID());
} else {
SortNode sortNode = new SortNode(getID());
OrderBy orderBy = (OrderBy) node.getProperty(NodeConstants.Info.SORT_ORDER);
if (orderBy != null) {
sortNode.setSortElements(orderBy.getOrderByItems());
}
if (node.hasBooleanProperty(NodeConstants.Info.IS_DUP_REMOVAL)) {
sortNode.setMode(Mode.DUP_REMOVE_SORT);
}
processNode = sortNode;
}
break;
case NodeConstants.Types.GROUP:
GroupingNode gnode = new GroupingNode(getID());
gnode.setRollup(node.hasBooleanProperty(Info.ROLLUP));
SymbolMap groupingMap = (SymbolMap) node.getProperty(NodeConstants.Info.SYMBOL_MAP);
gnode.setOutputMapping(groupingMap);
gnode.setRemoveDuplicates(node.hasBooleanProperty(NodeConstants.Info.IS_DUP_REMOVAL));
List<Expression> gCols = (List) node.getProperty(NodeConstants.Info.GROUP_COLS);
OrderBy orderBy = (OrderBy) node.getProperty(Info.SORT_ORDER);
if (orderBy == null) {
if (gCols != null) {
LinkedHashSet<Expression> exprs = new LinkedHashSet<Expression>();
for (Expression ex : gCols) {
exprs.add(SymbolMap.getExpression(ex));
}
orderBy =
new OrderBy(
RuleChooseJoinStrategy.createExpressionSymbols(
new ArrayList<Expression>(exprs)));
}
} else {
HashSet<Expression> seen = new HashSet<Expression>();
for (int i = 0; i < gCols.size(); i++) {
if (i < orderBy.getOrderByItems().size()) {
OrderByItem orderByItem = orderBy.getOrderByItems().get(i);
Expression ex = SymbolMap.getExpression(orderByItem.getSymbol());
if (!seen.add(ex)) {
continue;
}
if (ex instanceof ElementSymbol) {
ex = groupingMap.getMappedExpression((ElementSymbol) ex);
orderByItem.setSymbol(new ExpressionSymbol("expr", ex)); // $NON-NLS-1$
}
} else {
orderBy.addVariable(
new ExpressionSymbol("expr", gCols.get(i)), OrderBy.ASC); // $NON-NLS-1$
}
}
}
if (orderBy != null) {
gnode.setOrderBy(orderBy.getOrderByItems());
}
processNode = gnode;
break;
case NodeConstants.Types.SOURCE:
Object source = node.getProperty(NodeConstants.Info.TABLE_FUNCTION);
if (source instanceof XMLTable) {
XMLTable xt = (XMLTable) source;
XMLTableNode xtn = new XMLTableNode(getID());
// we handle the projection filtering once here rather than repeating the
// path analysis on a per plan basis
updateGroupName(node, xt);
Map<Expression, Integer> elementMap =
RelationalNode.createLookupMap(xt.getProjectedSymbols());
List cols = (List) node.getProperty(NodeConstants.Info.OUTPUT_COLS);
int[] projectionIndexes = RelationalNode.getProjectionIndexes(elementMap, cols);
ArrayList<XMLColumn> filteredColumns = new ArrayList<XMLColumn>(projectionIndexes.length);
for (int col : projectionIndexes) {
filteredColumns.add(xt.getColumns().get(col));
}
xt.getXQueryExpression().useDocumentProjection(filteredColumns, analysisRecord);
xtn.setProjectedColumns(filteredColumns);
xtn.setTable(xt);
processNode = xtn;
break;
}
if (source instanceof ObjectTable) {
ObjectTable ot = (ObjectTable) source;
ObjectTableNode otn = new ObjectTableNode(getID());
// we handle the projection filtering once here rather than repeating the
// path analysis on a per plan basis
updateGroupName(node, ot);
Map<Expression, Integer> elementMap =
RelationalNode.createLookupMap(ot.getProjectedSymbols());
List<Expression> cols =
(List<Expression>) node.getProperty(NodeConstants.Info.OUTPUT_COLS);
int[] projectionIndexes = RelationalNode.getProjectionIndexes(elementMap, cols);
ArrayList<ObjectColumn> filteredColumns =
new ArrayList<ObjectColumn>(projectionIndexes.length);
for (int col : projectionIndexes) {
filteredColumns.add(ot.getColumns().get(col));
}
otn.setProjectedColumns(filteredColumns);
otn.setTable(ot);
processNode = otn;
break;
}
if (source instanceof TextTable) {
TextTableNode ttn = new TextTableNode(getID());
TextTable tt = (TextTable) source;
updateGroupName(node, tt);
ttn.setTable(tt);
processNode = ttn;
break;
}
if (source instanceof ArrayTable) {
ArrayTableNode atn = new ArrayTableNode(getID());
ArrayTable at = (ArrayTable) source;
updateGroupName(node, at);
atn.setTable(at);
processNode = atn;
break;
}
SymbolMap symbolMap = (SymbolMap) node.getProperty(NodeConstants.Info.SYMBOL_MAP);
if (symbolMap != null) {
PlanNode child = node.getLastChild();
if (child.getType() == NodeConstants.Types.PROJECT
|| child.getType() == NodeConstants.Types.SELECT) {
// update the project cols based upon the original output
child.setProperty(
NodeConstants.Info.PROJECT_COLS, child.getProperty(NodeConstants.Info.OUTPUT_COLS));
}
child.setProperty(
NodeConstants.Info.OUTPUT_COLS, node.getProperty(NodeConstants.Info.OUTPUT_COLS));
}
return null;
case NodeConstants.Types.SET_OP:
Operation setOp = (Operation) node.getProperty(NodeConstants.Info.SET_OPERATION);
boolean useAll = ((Boolean) node.getProperty(NodeConstants.Info.USE_ALL)).booleanValue();
if (setOp == Operation.UNION) {
RelationalNode unionAllNode = new UnionAllNode(getID());
if (useAll) {
processNode = unionAllNode;
} else {
boolean onlyDupRemoval = node.hasBooleanProperty(NodeConstants.Info.IS_DUP_REMOVAL);
if (onlyDupRemoval) {
processNode = new DupRemoveNode(getID());
} else {
SortNode sNode = new SortNode(getID());
sNode.setMode(Mode.DUP_REMOVE_SORT);
processNode = sNode;
}
unionAllNode.setElements((List) node.getProperty(NodeConstants.Info.OUTPUT_COLS));
processNode.addChild(unionAllNode);
}
} else {
JoinNode joinAsSet = new JoinNode(getID());
joinAsSet.setJoinStrategy(
new MergeJoinStrategy(SortOption.SORT_DISTINCT, SortOption.SORT_DISTINCT, true));
// If we push these sorts, we will have to enforce null order, since nulls are equal here
List leftExpressions =
(List) node.getFirstChild().getProperty(NodeConstants.Info.OUTPUT_COLS);
List rightExpressions =
(List) node.getLastChild().getProperty(NodeConstants.Info.OUTPUT_COLS);
joinAsSet.setJoinType(
setOp == Operation.EXCEPT ? JoinType.JOIN_ANTI_SEMI : JoinType.JOIN_SEMI);
joinAsSet.setJoinExpressions(leftExpressions, rightExpressions);
processNode = joinAsSet;
}
break;
case NodeConstants.Types.TUPLE_LIMIT:
Expression rowLimit = (Expression) node.getProperty(NodeConstants.Info.MAX_TUPLE_LIMIT);
Expression offset = (Expression) node.getProperty(NodeConstants.Info.OFFSET_TUPLE_COUNT);
LimitNode ln = new LimitNode(getID(), rowLimit, offset);
ln.setImplicit(node.hasBooleanProperty(Info.IS_IMPLICIT_LIMIT));
processNode = ln;
break;
case NodeConstants.Types.NULL:
processNode = new NullNode(getID());
break;
default:
throw new QueryPlannerException(
QueryPlugin.Event.TEIID30250,
QueryPlugin.Util.gs(
QueryPlugin.Event.TEIID30250, NodeConstants.getNodeTypeString(node.getType())));
}
if (processNode != null) {
processNode = prepareToAdd(node, processNode);
}
return processNode;
}
/**
* @param command
* @param rsName
* @param procAssignments
* @param mode
* @param usesLocalTemp - only matters in HOLD mode
* @throws TeiidComponentException
* @throws TeiidProcessingException
*/
public void executePlan(
ProcessorPlan command,
String rsName,
Map<ElementSymbol, ElementSymbol> procAssignments,
CreateCursorResultSetInstruction.Mode mode,
boolean usesLocalTemp)
throws TeiidComponentException, TeiidProcessingException {
CursorState state = (CursorState) this.cursorStates.getValue(rsName);
if (state == null || rsName == null) {
if (this.currentState != null && this.currentState.processor.getProcessorPlan() != command) {
// sanity check for non-deterministic paths
removeState(this.currentState);
this.currentState = null;
}
if (this.currentState == null) {
// this may not be the first time the plan is being run
command.reset();
CommandContext subContext = getContext().clone();
subContext.setVariableContext(this.currentVarContext);
state = new CursorState();
state.usesLocalTemp = usesLocalTemp;
state.processor = new QueryProcessor(command, subContext, this.bufferMgr, this);
state.ts = new BatchIterator(state.processor);
if (mode == Mode.HOLD
&& procAssignments != null
&& state.processor.getOutputElements().size() - procAssignments.size() > 0) {
state.resultsBuffer =
bufferMgr.createTupleBuffer(
state
.processor
.getOutputElements()
.subList(
0, state.processor.getOutputElements().size() - procAssignments.size()),
getContext().getConnectionId(),
TupleSourceType.PROCESSOR);
} else if ((this.blockContext != null || this.programs.peek().isTrappingExceptions())
&& (mode == Mode.HOLD || rsName != null)) {
state.resultsBuffer =
bufferMgr.createTupleBuffer(
state.processor.getOutputElements(),
getContext().getConnectionId(),
TupleSourceType.PROCESSOR);
}
this.currentState = state;
}
// force execution to the first batch to ensure that the plan is executed in the context of
// the procedure
this.currentState.ts.hasNext();
if (procAssignments != null) {
// proc assignments force us to scroll through the entire results and save as we go
while (this.currentState.ts.hasNext()) {
if (this.currentState.currentRow != null && this.currentState.resultsBuffer != null) {
this.currentState.resultsBuffer.addTuple(
this.currentState.currentRow.subList(
0, this.currentState.resultsBuffer.getSchema().size()));
this.currentState.currentRow = null;
}
this.currentState.currentRow = this.currentState.ts.nextTuple();
}
// process assignments
Assertion.assertTrue(this.currentState.currentRow != null);
for (Map.Entry<ElementSymbol, ElementSymbol> entry : procAssignments.entrySet()) {
if (entry.getValue() == null
|| !metadata.elementSupports(
entry.getValue().getMetadataID(), SupportConstants.Element.UPDATE)) {
continue;
}
int index = this.currentState.processor.getOutputElements().indexOf(entry.getKey());
getCurrentVariableContext()
.setValue(
entry.getValue(),
DataTypeManager.transformValue(
this.currentState.currentRow.get(index), entry.getValue().getType()));
}
} else if (this.currentState.resultsBuffer != null) {
// result should be saved, typically to respect txn semantics
while (this.currentState.ts.hasNext()) {
List<?> tuple = this.currentState.ts.nextTuple();
this.currentState.resultsBuffer.addTuple(tuple);
}
getCurrentVariableContext().setValue(ProcedurePlan.ROWCOUNT, 0);
} else if (mode == Mode.UPDATE) {
List<?> t = this.currentState.ts.nextTuple();
if (this.currentState.ts.hasNext()) {
throw new AssertionError(
"Invalid update count result - more than 1 row returned"); //$NON-NLS-1$
}
removeState(this.currentState);
this.currentState = null;
int rowCount = 0;
if (t != null) {
rowCount = (Integer) t.get(0);
}
getCurrentVariableContext().setValue(ProcedurePlan.ROWCOUNT, rowCount);
return;
}
if (rsName == null && mode == Mode.NOHOLD) {
// unnamed without hold
// process fully, but don't save
// TODO: could set the rowcount in this case
while (this.currentState.ts.hasNext()) {
this.currentState.ts.nextTuple();
}
this.currentState = null;
getCurrentVariableContext().setValue(ProcedurePlan.ROWCOUNT, 0);
return;
}
if (this.currentState.resultsBuffer != null) {
// close the results buffer and use a buffer backed tuplesource
this.currentState.resultsBuffer.close();
this.currentState.ts = this.currentState.resultsBuffer.createIndexedTupleSource(true);
}
CursorState old = (CursorState) this.cursorStates.setValue(rsName, this.currentState);
if (old != null) {
removeState(old);
}
this.currentState = null;
}
}
/**
* Mark the specified access node to be made dependent
*
* @param sourceNode Node to make dependent
* @param dca
* @throws TeiidComponentException
* @throws QueryMetadataException
*/
boolean markDependent(
PlanNode sourceNode,
PlanNode joinNode,
QueryMetadataInterface metadata,
DependentCostAnalysis dca,
Boolean bound)
throws QueryMetadataException, TeiidComponentException {
boolean isLeft = joinNode.getFirstChild() == sourceNode;
// Get new access join node properties based on join criteria
List independentExpressions =
(List)
(isLeft
? joinNode.getProperty(NodeConstants.Info.RIGHT_EXPRESSIONS)
: joinNode.getProperty(NodeConstants.Info.LEFT_EXPRESSIONS));
List dependentExpressions =
(List)
(isLeft
? joinNode.getProperty(NodeConstants.Info.LEFT_EXPRESSIONS)
: joinNode.getProperty(NodeConstants.Info.RIGHT_EXPRESSIONS));
if (independentExpressions == null || independentExpressions.isEmpty()) {
return false;
}
String id = "$dsc/id" + ID.getAndIncrement(); // $NON-NLS-1$
// Create DependentValueSource and set on the independent side as this will feed the values
joinNode.setProperty(NodeConstants.Info.DEPENDENT_VALUE_SOURCE, id);
PlanNode indNode = isLeft ? joinNode.getLastChild() : joinNode.getFirstChild();
if (bound == null) {
List<PlanNode> sources = NodeEditor.findAllNodes(indNode, NodeConstants.Types.SOURCE);
for (PlanNode planNode : sources) {
for (GroupSymbol gs : planNode.getGroups()) {
if (gs.isTempTable()
&& metadata.getCardinality(gs.getMetadataID())
== QueryMetadataInterface.UNKNOWN_CARDINALITY) {
bound = true;
break;
}
}
}
if (bound == null) {
bound = false;
}
}
PlanNode crit =
getDependentCriteriaNode(
id,
independentExpressions,
dependentExpressions,
indNode,
metadata,
dca,
bound,
(MakeDep) sourceNode.getProperty(Info.MAKE_DEP));
sourceNode.addAsParent(crit);
if (isLeft) {
JoinUtil.swapJoinChildren(joinNode);
}
return true;
}
/**
* @param metadata
* @param group
* @return
* @throws TeiidComponentException
* @throws QueryMetadataException
*/
protected String getPlan(QueryMetadataInterface metadata, GroupSymbol group)
throws TeiidComponentException, QueryMetadataException {
return metadata.getUpdatePlan(group.getMetadataID());
}
public Object lookupCodeValue(
CommandContext context,
String codeTableName,
String returnElementName,
String keyElementName,
Object keyValue)
throws BlockedException, TeiidComponentException, TeiidProcessingException {
// we are not using a resolved form of a lookup, so we canonicallize with upper case
codeTableName = codeTableName.toUpperCase();
keyElementName = keyElementName.toUpperCase();
returnElementName = returnElementName.toUpperCase();
String matTableName =
CODE_PREFIX
+ codeTableName
+ ElementSymbol.SEPARATOR
+ keyElementName
+ ElementSymbol.SEPARATOR
+ returnElementName;
TupleSource ts = context.getCodeLookup(matTableName, keyValue);
if (ts == null) {
QueryMetadataInterface metadata = context.getMetadata();
TempMetadataID id =
context
.getGlobalTableStore()
.getCodeTableMetadataId(
codeTableName, returnElementName, keyElementName, matTableName);
ElementSymbol keyElement = new ElementSymbol(keyElementName, new GroupSymbol(matTableName));
ElementSymbol returnElement =
new ElementSymbol(returnElementName, new GroupSymbol(matTableName));
keyElement.setType(
DataTypeManager.getDataTypeClass(
metadata.getElementType(
metadata.getElementID(
codeTableName + ElementSymbol.SEPARATOR + keyElementName))));
returnElement.setType(
DataTypeManager.getDataTypeClass(
metadata.getElementType(
metadata.getElementID(
codeTableName + ElementSymbol.SEPARATOR + returnElementName))));
Query query =
RelationalPlanner.createMatViewQuery(
id, matTableName, Arrays.asList(returnElement), true);
query.setCriteria(
new CompareCriteria(keyElement, CompareCriteria.EQ, new Constant(keyValue)));
ts = registerQuery(context, context.getTempTableStore(), query);
}
try {
List<?> row = ts.nextTuple();
Object result = null;
if (row != null) {
result = row.get(0);
}
ts.closeSource();
return result;
} catch (BlockedException e) {
context.putCodeLookup(matTableName, keyValue, ts);
throw e;
}
}
private TupleSource handleSystemProcedures(final CommandContext context, StoredProcedure proc)
throws TeiidComponentException, QueryMetadataException, QueryProcessingException,
QueryResolverException, QueryValidatorException, TeiidProcessingException,
ExpressionEvaluationException {
final QueryMetadataInterface metadata = context.getMetadata();
if (StringUtil.endsWithIgnoreCase(proc.getProcedureCallableName(), REFRESHMATVIEW)) {
Object groupID =
validateMatView(
metadata, (String) ((Constant) proc.getParameter(2).getExpression()).getValue());
TempMetadataID matTableId =
context.getGlobalTableStore().getGlobalTempTableMetadataId(groupID);
final GlobalTableStore globalStore = getGlobalStore(context, matTableId);
String matViewName = metadata.getFullName(groupID);
String matTableName = metadata.getFullName(matTableId);
LogManager.logDetail(
LogConstants.CTX_MATVIEWS, "processing refreshmatview for", matViewName); // $NON-NLS-1$
boolean invalidate =
Boolean.TRUE.equals(((Constant) proc.getParameter(3).getExpression()).getValue());
boolean needsLoading =
globalStore.needsLoading(matTableName, globalStore.getAddress(), true, true, invalidate);
if (!needsLoading) {
return CollectionTupleSource.createUpdateCountTupleSource(-1);
}
GroupSymbol matTable = new GroupSymbol(matTableName);
matTable.setMetadataID(matTableId);
return loadGlobalTable(context, matTable, matTableName, globalStore);
} else if (StringUtil.endsWithIgnoreCase(proc.getProcedureCallableName(), REFRESHMATVIEWROW)) {
final Object groupID =
validateMatView(
metadata, (String) ((Constant) proc.getParameter(2).getExpression()).getValue());
TempMetadataID matTableId =
context.getGlobalTableStore().getGlobalTempTableMetadataId(groupID);
final GlobalTableStore globalStore = getGlobalStore(context, matTableId);
Object pk = metadata.getPrimaryKey(groupID);
String matViewName = metadata.getFullName(groupID);
if (pk == null) {
throw new QueryProcessingException(
QueryPlugin.Event.TEIID30230,
QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30230, matViewName));
}
List<?> ids = metadata.getElementIDsInKey(pk);
Constant key = (Constant) proc.getParameter(3).getExpression();
Object initialValue = key.getValue();
SPParameter keyOther = proc.getParameter(4);
Object[] otherCols = null;
int length = 1;
if (keyOther != null) {
otherCols = ((ArrayImpl) ((Constant) keyOther.getExpression()).getValue()).getValues();
if (otherCols != null) {
length += otherCols.length;
}
}
if (ids.size() != length) {
throw new QueryProcessingException(
QueryPlugin.Event.TEIID30231,
QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30231, matViewName, ids.size(), length));
}
final String matTableName = RelationalPlanner.MAT_PREFIX + matViewName.toUpperCase();
MatTableInfo info = globalStore.getMatTableInfo(matTableName);
if (!info.isValid()) {
return CollectionTupleSource.createUpdateCountTupleSource(-1);
}
TempTable tempTable = globalStore.getTempTable(matTableName);
if (!tempTable.isUpdatable()) {
throw new QueryProcessingException(
QueryPlugin.Event.TEIID30232,
QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30232, matViewName));
}
Iterator<?> iter = ids.iterator();
final Object[] params = new Object[length];
StringBuilder criteria = new StringBuilder();
for (int i = 0; i < length; i++) {
Object id = iter.next();
String targetTypeName = metadata.getElementType(id);
Object value = i == 0 ? initialValue : otherCols[i - 1];
value =
DataTypeManager.transformValue(value, DataTypeManager.getDataTypeClass(targetTypeName));
params[i] = value;
if (i != 0) {
criteria.append(" AND "); // $NON-NLS-1$
}
criteria.append(metadata.getFullName(id)).append(" = ?"); // $NON-NLS-1$
}
LogManager.logInfo(
LogConstants.CTX_MATVIEWS,
QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30012, matViewName, Arrays.toString(params)));
String queryString =
Reserved.SELECT
+ " * "
+ Reserved.FROM
+ ' '
+ matViewName
+ ' '
+ Reserved.WHERE
+ ' '
+ //$NON-NLS-1$
criteria.toString()
+ ' '
+ Reserved.OPTION
+ ' '
+ Reserved.NOCACHE;
final QueryProcessor qp =
context
.getQueryProcessorFactory()
.createQueryProcessor(queryString, matViewName.toUpperCase(), context, params);
final TupleSource ts = new BatchCollector.BatchProducerTupleSource(qp);
return new ProxyTupleSource() {
@Override
protected TupleSource createTupleSource()
throws TeiidComponentException, TeiidProcessingException {
List<?> tuple = ts.nextTuple();
boolean delete = false;
if (tuple == null) {
delete = true;
tuple = Arrays.asList(params);
} else {
tuple = new ArrayList<Object>(tuple); // ensure the list is serializable
}
List<?> result = globalStore.updateMatViewRow(matTableName, tuple, delete);
if (eventDistributor != null) {
eventDistributor.updateMatViewRow(
context.getVdbName(),
context.getVdbVersion(),
metadata.getName(metadata.getModelID(groupID)),
metadata.getName(groupID),
tuple,
delete);
}
return CollectionTupleSource.createUpdateCountTupleSource(result != null ? 1 : 0);
}
@Override
public void closeSource() {
super.closeSource();
qp.closeProcessing();
}
};
}
return null;
}
private TupleSource updateMatviewRows(
final CommandContext context,
final QueryMetadataInterface metadata,
final Object groupID,
final GlobalTableStore globalStore,
final String matViewName,
List<?> ids,
Object[][] params)
throws QueryProcessingException, TeiidComponentException, QueryMetadataException,
TransformationException {
final String matTableName = RelationalPlanner.MAT_PREFIX + matViewName.toUpperCase();
MatTableInfo info = globalStore.getMatTableInfo(matTableName);
if (!info.isValid()) {
return CollectionTupleSource.createUpdateCountTupleSource(-1);
}
TempTable tempTable = globalStore.getTempTable(matTableName);
if (!tempTable.isUpdatable()) {
throw new QueryProcessingException(
QueryPlugin.Event.TEIID30232,
QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30232, matViewName));
}
List<Object[]> converted = new ArrayList<Object[]>();
for (Object[] param : params) {
if (param == null || ids.size() != param.length) {
throw new QueryProcessingException(
QueryPlugin.Event.TEIID30231,
QueryPlugin.Util.gs(
QueryPlugin.Event.TEIID30231,
matViewName,
ids.size(),
param == null ? 0 : param.length));
}
final Object[] vals = new Object[param.length];
for (int i = 0; i < ids.size(); i++) {
Object value = param[i];
String targetTypeName = metadata.getElementType(ids.get(i));
value =
DataTypeManager.transformValue(value, DataTypeManager.getDataTypeClass(targetTypeName));
vals[i] = value;
}
converted.add(vals);
}
final Iterator<Object[]> paramIter = converted.iterator();
Iterator<?> iter = ids.iterator();
StringBuilder criteria = new StringBuilder();
for (int i = 0; i < ids.size(); i++) {
Object id = iter.next();
String targetTypeName = metadata.getElementType(id);
if (i != 0) {
criteria.append(" AND "); // $NON-NLS-1$
}
criteria.append(metadata.getFullName(id)).append(" = ?"); // $NON-NLS-1$
}
final String queryString =
Reserved.SELECT
+ " * "
+ Reserved.FROM
+ ' '
+ matViewName
+ ' '
+ Reserved.WHERE
+ ' '
+ //$NON-NLS-1$
criteria.toString()
+ ' '
+ Reserved.OPTION
+ ' '
+ Reserved.NOCACHE;
return new ProxyTupleSource() {
private QueryProcessor qp;
private TupleSource ts;
private Object[] params;
private int count;
@Override
protected TupleSource createTupleSource()
throws TeiidComponentException, TeiidProcessingException {
while (true) {
if (qp == null) {
params = paramIter.next();
LogManager.logInfo(
LogConstants.CTX_MATVIEWS,
QueryPlugin.Util.gs(
QueryPlugin.Event.TEIID30012, matViewName, Arrays.toString(params)));
qp =
context
.getQueryProcessorFactory()
.createQueryProcessor(queryString, matViewName.toUpperCase(), context, params);
ts = new BatchCollector.BatchProducerTupleSource(qp);
}
List<?> tuple = ts.nextTuple();
boolean delete = false;
if (tuple == null) {
delete = true;
tuple = Arrays.asList(params);
} else {
tuple = new ArrayList<Object>(tuple); // ensure the list is serializable
}
List<?> result = globalStore.updateMatViewRow(matTableName, tuple, delete);
if (result != null) {
count++;
}
if (eventDistributor != null) {
eventDistributor.updateMatViewRow(
context.getVdbName(),
context.getVdbVersion(),
metadata.getName(metadata.getModelID(groupID)),
metadata.getName(groupID),
tuple,
delete);
}
qp.closeProcessing();
qp = null;
ts = null;
if (!paramIter.hasNext()) {
break;
}
}
return CollectionTupleSource.createUpdateCountTupleSource(count);
}
@Override
public void closeSource() {
super.closeSource();
if (qp != null) {
qp.closeProcessing();
}
}
};
}
private TupleSource handleSystemProcedures(final CommandContext context, StoredProcedure proc)
throws TeiidComponentException, QueryMetadataException, QueryProcessingException,
QueryResolverException, QueryValidatorException, TeiidProcessingException,
ExpressionEvaluationException {
final QueryMetadataInterface metadata = context.getMetadata();
if (StringUtil.endsWithIgnoreCase(proc.getProcedureCallableName(), REFRESHMATVIEW)) {
Object groupID =
validateMatView(
metadata, (String) ((Constant) proc.getParameter(2).getExpression()).getValue());
TempMetadataID matTableId =
context.getGlobalTableStore().getGlobalTempTableMetadataId(groupID);
final GlobalTableStore globalStore = getGlobalStore(context, matTableId);
String matViewName = metadata.getFullName(groupID);
String matTableName = metadata.getFullName(matTableId);
LogManager.logDetail(
LogConstants.CTX_MATVIEWS, "processing refreshmatview for", matViewName); // $NON-NLS-1$
boolean invalidate =
Boolean.TRUE.equals(((Constant) proc.getParameter(3).getExpression()).getValue());
boolean needsLoading =
globalStore.needsLoading(matTableName, globalStore.getAddress(), true, true, invalidate);
if (!needsLoading) {
return CollectionTupleSource.createUpdateCountTupleSource(-1);
}
GroupSymbol matTable = new GroupSymbol(matTableName);
matTable.setMetadataID(matTableId);
return loadGlobalTable(context, matTable, matTableName, globalStore);
} else if (StringUtil.endsWithIgnoreCase(proc.getProcedureCallableName(), REFRESHMATVIEWROWS)) {
final Object groupID =
validateMatView(
metadata, (String) ((Constant) proc.getParameter(2).getExpression()).getValue());
TempMetadataID matTableId =
context.getGlobalTableStore().getGlobalTempTableMetadataId(groupID);
final GlobalTableStore globalStore = getGlobalStore(context, matTableId);
Object pk = metadata.getPrimaryKey(groupID);
String matViewName = metadata.getFullName(groupID);
if (pk == null) {
throw new QueryProcessingException(
QueryPlugin.Event.TEIID30230,
QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30230, matViewName));
}
List<?> ids = metadata.getElementIDsInKey(pk);
Object[][] params =
(Object[][])
((ArrayImpl) ((Constant) proc.getParameter(3).getExpression()).getValue())
.getValues();
return updateMatviewRows(context, metadata, groupID, globalStore, matViewName, ids, params);
} else if (StringUtil.endsWithIgnoreCase(proc.getProcedureCallableName(), REFRESHMATVIEWROW)) {
final Object groupID =
validateMatView(
metadata, (String) ((Constant) proc.getParameter(2).getExpression()).getValue());
TempMetadataID matTableId =
context.getGlobalTableStore().getGlobalTempTableMetadataId(groupID);
final GlobalTableStore globalStore = getGlobalStore(context, matTableId);
Object pk = metadata.getPrimaryKey(groupID);
final String matViewName = metadata.getFullName(groupID);
if (pk == null) {
throw new QueryProcessingException(
QueryPlugin.Event.TEIID30230,
QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30230, matViewName));
}
List<?> ids = metadata.getElementIDsInKey(pk);
Constant key = (Constant) proc.getParameter(3).getExpression();
Object initialValue = key.getValue();
SPParameter keyOther = proc.getParameter(4);
Object[] param = null;
if (keyOther != null) {
Object[] otherCols =
((ArrayImpl) ((Constant) keyOther.getExpression()).getValue()).getValues();
if (otherCols != null) {
param = new Object[1 + otherCols.length];
param[0] = initialValue;
for (int i = 0; i < otherCols.length; i++) {
param[i + 1] = otherCols[i];
}
}
}
if (param == null) {
param = new Object[] {initialValue};
}
Object[][] params = new Object[][] {param};
return updateMatviewRows(context, metadata, groupID, globalStore, matViewName, ids, params);
}
return null;
}