public Object clone() { StoredProcedure copy = new StoredProcedure(); copy.setModelID(getModelID()); copy.setProcedureName(getProcedureName()); copy.setProcedureCallableName(getProcedureCallableName()); copy.setProcedureID(getProcedureID()); copy.setGroup(getGroup().clone()); copy.callableName = callableName; copy.calledWithReturn = calledWithReturn; Collection<SPParameter> params = getParameters(); for (SPParameter spParameter : params) { copy.setParameter((SPParameter)spParameter.clone()); } copy.resultSetParameterKey = resultSetParameterKey; this.copyMetadataState(copy); copy.displayNamedParameters = displayNamedParameters; copy.isCallableStatement = isCallableStatement; copy.isProcedureRelational = isProcedureRelational; copy.pushedInQuery = pushedInQuery; return copy; }
public LinkedHashMap<ElementSymbol, Expression> getProcedureParameters() { LinkedHashMap<ElementSymbol, Expression> map = new LinkedHashMap<ElementSymbol, Expression>(); for (SPParameter element : this.getInputParameters()) { map.put(element.getParameterSymbol(), element.getExpression()); } // for return map; }
@Override public boolean isReturingParams() { if (userCommand instanceof StoredProcedure) { StoredProcedure sp = (StoredProcedure)userCommand; if (sp.isCallableStatement() && sp.returnsResultSet()) { for (SPParameter param : sp.getMapOfParameters().values()) { int type = param.getParameterType(); if (type == SPParameter.INOUT || type == SPParameter.OUT || type == SPParameter.RETURN_VALUE) { return true; } } } } return false; }
public static boolean hasOutputParams(Command command) { boolean hasOutParams = false; if (command instanceof StoredProcedure) { StoredProcedure sp = (StoredProcedure)command; hasOutParams = sp.returnParameters() && sp.getProjectedSymbols().size() > sp.getResultSetColumns().size(); } return hasOutParams; }
/** * @see org.teiid.query.sql.lang.Command#areResultsCachable() */ public boolean areResultsCachable() { if (getUpdateCount() > 0) { return false; } return Query.areColumnsCachable(getProjectedSymbols()); }
@Test public void testExecReturnParam() { StoredProcedure proc = new StoredProcedure(); proc.setProcedureName("myproc"); //$NON-NLS-1$ SPParameter param = new SPParameter(1, ParameterInfo.RETURN_VALUE, "ret"); //$NON-NLS-1$ proc.setParameter(param); helpTest(proc, "EXEC myproc()"); //$NON-NLS-1$ }
StoredProcedure storedProcedureCommand = new StoredProcedure(); storedProcedureCommand.setProcedureRelational(true); storedProcedureCommand.setProcedureName(fullName); clonedParam.setExpression(ref); clonedParam.setIndex(paramIndex++); storedProcedureCommand.setParameter(clonedParam); id.setOriginalMetadataID(storedProcedureCommand.getProcedureID()); if (!accessPatternElementNames.isEmpty()) { List<TempMetadataID> accessPatternIds = new LinkedList<TempMetadataID>();
@Test public void testExecNamedParam() { StoredProcedure proc = new StoredProcedure(); proc.setDisplayNamedParameters(true); proc.setProcedureName("myproc"); //$NON-NLS-1$ SPParameter param = new SPParameter(1, new Reference(0)); param.setName("p1");//$NON-NLS-1$ proc.setParameter(param); helpTest(proc, "EXEC myproc(p1 => ?)"); //$NON-NLS-1$ }
@Test public void testCacheHintCallableStatement() { String sql = "/*+ cache */ { ? = call proc() }"; //$NON-NLS-1$ StoredProcedure sp = new StoredProcedure(); SPParameter param = new SPParameter(1, null); param.setParameterType(SPParameter.RETURN_VALUE); sp.setParameter(param); sp.setProcedureName("proc"); sp.setCallableStatement(true); CacheHint hint = new CacheHint(); sp.setCacheHint(hint); TestParser.helpTest(sql, "/*+ cache */ ? = EXEC proc()", sp); //$NON-NLS-1$ }
private TupleSource handleCachedProcedure(final CommandContext context, StoredProcedure proc) throws TeiidComponentException, QueryMetadataException, TeiidProcessingException { String fullName = context.getMetadata().getFullName(proc.getProcedureID()); LogManager.logDetail(LogConstants.CTX_DQP, "processing cached procedure request for", fullName); //$NON-NLS-1$ LinkedList<Object> vals = new LinkedList<Object>(); for (SPParameter param : proc.getInputParameters()) { vals.add(((Constant)param.getExpression()).getValue()); final CacheHint hint = proc.getCacheHint(); proc.setCacheHint(null); Option option = new Option(); option.setNoCache(true); option.addNoCacheGroup(fullName); proc.setOption(option); StoredProcedure cloneProc = (StoredProcedure)proc.clone(); int i = 0; for (SPParameter param : cloneProc.getInputParameters()) { param.setExpression(new Reference(i++)); final QueryProcessor qp = context.getQueryProcessorFactory().createQueryProcessor(cloneProc.toString(), fullName.toUpperCase(), context, vals.toArray()); final BatchCollector bc = qp.createBatchCollector();
public void testExecParamElement() { StoredProcedure exec = new StoredProcedure(); exec.setProcedureName("pm1.proc1"); //$NON-NLS-1$ exec.setProcedureID("proc"); //$NON-NLS-1$ SPParameter param1 = new SPParameter(1, exampleElement(true, 1)); exec.setParameter(param1); // Run symbol mapper StaticSymbolMappingVisitor visitor = new StaticSymbolMappingVisitor(getSymbolMap()); DeepPreOrderNavigator.doVisit(exec, visitor); // Check that element got switched assertEquals("Stored proc param did not get mapped correctly: ", exampleElement(false, 1), param1.getExpression()); //$NON-NLS-1$ }
Call translate(StoredProcedure sp) { Procedure proc = null; if(sp.getProcedureID() != null) { try { proc = this.metadataFactory.getProcedure(sp.getGroup().getName()); } catch (TranslatorException e) { throw new TeiidRuntimeException(QueryPlugin.Event.TEIID30486, e); for (SPParameter param : sp.getParameters()) { Direction direction = Direction.IN; switch(param.getParameterType()) { Call call = new Call(removeSchemaName(sp.getProcedureName()), translatedParameters, proc); call.setReturnType(returnType); return call;
public void testExecName() { StoredProcedure exec = new StoredProcedure(); exec.setProcedureName(exampleGroup(true, 1).getName()); exec.setProcedureID("proc"); //$NON-NLS-1$ // Run symbol mapper StaticSymbolMappingVisitor visitor = new StaticSymbolMappingVisitor(getSymbolMap()); DeepPreOrderNavigator.doVisit(exec, visitor); // Check that group got mapped assertEquals("Procedure name did not get mapped correctly: ", exampleGroup(false, 1).getName(), exec.getProcedureName()); //$NON-NLS-1$ }
/** * Swap name of stored proc and elements in stored procedure parameter expressions * @param obj Object to remap */ public void visit(StoredProcedure obj) { // Swap procedure name String execName = obj.getProcedureName(); GroupSymbol fakeGroup = new GroupSymbol(execName); Object procedureID = obj.getProcedureID(); if(procedureID != null) { fakeGroup.setMetadataID(procedureID); } GroupSymbol mappedGroup = getMappedGroup(fakeGroup); obj.setProcedureName(mappedGroup.getName()); super.visit(obj); }
PlanNode createStoredProcedurePlan(StoredProcedure storedProc) throws QueryMetadataException, TeiidComponentException, TeiidProcessingException { // Create top project node - define output columns for stored query / procedure PlanNode projectNode = attachProject(null, storedProc.getProjectedSymbols()); // Define source of data for stored query / procedure PlanNode sourceNode = NodeFactory.getNewNode(NodeConstants.Types.SOURCE); sourceNode.setProperty(NodeConstants.Info.VIRTUAL_COMMAND, storedProc); addNestedProcedure(sourceNode, storedProc, storedProc.getProcedureID()); hints.hasRelationalProc |= storedProc.isProcedureRelational(); if (!hints.hasRowBasedSecurity && RowBasedSecurityHelper.applyRowSecurity(metadata, storedProc.getGroup(), context)) { hints.hasRowBasedSecurity = true; } // Set group on source node sourceNode.addGroup(storedProc.getGroup()); attachLast(projectNode, sourceNode); return projectNode; }
@Override public void visit( StoredProcedure obj ) { addCacheHint(obj.getCacheHint()); if (obj.isCalledWithReturn()) { for (SPParameter param : obj.getParameters()) { if (param.getParameterType() == SPParameter.RETURN_VALUE) { if (param.getExpression() == null) { append(obj.getProcedureName()); append("("); //$NON-NLS-1$ boolean first = true; for (SPParameter param : obj.getParameters()) { if (param.isUsingDefault() || param.getParameterType() == SPParameter.RETURN_VALUE || param.getParameterType() == SPParameter.RESULT_SET || param.getExpression() == null) { append(", "); //$NON-NLS-1$ if (obj.displayNamedParameters()) { append(escapeSinglePart(Symbol.getShortName(param.getParameterSymbol().getOutputName()))); append(" => "); //$NON-NLS-1$ boolean addParens = !obj.displayNamedParameters() && param.getExpression() instanceof CompareCriteria; if (addParens) { append(Tokens.LPAREN); if (obj.getOption() != null) { beginClause(1); visitNode(obj.getOption());
for (SPParameter param : proc.getInputParameters()) { ProcedurePlan.checkNotNull(param.getParameterSymbol(), ((Constant)param.getExpression()).getValue(), context.getMetadata()); if (StringUtil.startsWithIgnoreCase(proc.getProcedureCallableName(), CoreConstants.SYSTEM_ADMIN_MODEL)) { final SystemAdminProcs sysProc = SystemAdminProcs.valueOf(proc.getProcedureCallableName().substring(CoreConstants.SYSTEM_ADMIN_MODEL.length() + 1).toUpperCase()); switch (sysProc) { case LOGMSG: case ISLOGGABLE: String level = (String)((Constant)proc.getParameter(2).getExpression()).getValue(); String logContext = (String)((Constant)proc.getParameter(3).getExpression()).getValue(); Object message = null; if (sysProc == SystemAdminProcs.LOGMSG) { message = ((Constant)proc.getParameter(4).getExpression()).getValue(); if (proc.returnParameters()) { rows.add(Arrays.asList(logged)); case SETPROPERTY: try { String uuid = (String)((Constant)proc.getParameter(2).getExpression()).getValue(); String key = (String)((Constant)proc.getParameter(3).getExpression()).getValue(); Clob value = (Clob)((Constant)proc.getParameter(4).getExpression()).getValue(); key = MetadataFactory.resolvePropertyKey(null, key); String strVal = null; if (proc.returnParameters()) { if (result == null) { rows.add(Arrays.asList((Clob)null));
private Command rewriteExec(StoredProcedure storedProcedure) throws TeiidComponentException, TeiidProcessingException{ //After this method, no longer need to display named parameters storedProcedure.setDisplayNamedParameters(false); for (SPParameter param : storedProcedure.getInputParameters()) { if (!processing || storedProcedure.isPushedInQuery()) { param.setExpression(rewriteExpressionDirect(param.getExpression())); } else if (!(param.getExpression() instanceof Constant)) { boolean isBindEligible = !isConstantConvert(param.getExpression()); param.setExpression(evaluate(param.getExpression(), isBindEligible)); } } return storedProcedure; }
@Override public void visit(StoredProcedure obj) { if (!obj.isPushedInQuery()) { return; } List<ElementSymbol> selectSymbols = obj.getProjectedSymbols(); LinkedHashMap<Expression, String> symbols = new LinkedHashMap<Expression, String>(selectSymbols.size()); for (int i = 0; i < selectSymbols.size(); i++) { ElementSymbol symbol = selectSymbols.get(i); symbols.put(symbol, symbol.getShortName()); } for (SPParameter param : obj.getParameters()) { visitNode(param.getExpression()); } visitor.namingContext.currentSymbols = symbols; }
GroupContext externalGroups = storedProcedureCommand.getExternalGroupContexts(); for (SPParameter param : storedProcedureCommand.getParameters()) { Expression expr = param.getExpression(); if(expr == null) { throw new QueryResolverException(QueryPlugin.Event.TEIID30143, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30143, storedProcedureCommand.getProcedureName(), param.getName()));