void convertToParameters(List<Expression> values, StoredProcedure storedProcedure, int paramIndex) { for (Expression value : values) { SPParameter parameter = new SPParameter(paramIndex++, value); parameter.setParameterType(SPParameter.IN); storedProcedure.setParameter(parameter); } }
public void visit(StoredProcedure obj) { for (Iterator<SPParameter> paramIter = obj.getInputParameters().iterator(); paramIter.hasNext();) { SPParameter param = paramIter.next(); Expression expr = param.getExpression(); param.setExpression(replaceExpression(expr)); } }
/** * Set a stored procedure's parameter * * @param index the index of the parameter to set * @param parameter <code>StoredProcedureParameter</code> the parameter * @throws IllegalArgumentExcecption if the parameters (index and parameter) * are invalid. */ public void setParameter(SPParameter parameter){ if(parameter == null){ throw new IllegalArgumentException(QueryPlugin.Util.getString("ERR.015.010.0011")); //$NON-NLS-1$ } Integer key = parameter.getIndex(); if(parameter.getParameterType() == ParameterInfo.RESULT_SET){ resultSetParameterKey = key; } mapOfParameters.put(key, parameter); }
/** * Constructor used when constructing a parameter during execution. In this case we * know what the parameter is being filled with but no metadata about the parameter. * * @param index the positional index of this parameter * @param value the Value of this parameter */ public SPParameter(int index, Expression expression){ setIndex(index); setExpression(expression); this.parameterSymbol = new ElementSymbol(""); //$NON-NLS-1$ }
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; }
int adjustIndex = 0; for (SPParameter param : oldParams) { if(param.getExpression() == null) { if (param.getParameterType() == SPParameter.RESULT_SET) { if (namedParameters && param.getParameterType() != SPParameter.RETURN_VALUE) { if (namedExpressions.put(param.getParameterSymbol().getShortName(), param.getExpression()) != null) { throw new QueryResolverException(QueryPlugin.Event.TEIID30138, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30138, param.getName())); positionalExpressions.put(param.getIndex() + adjustIndex, param.getExpression()); for (int i = 0; i < metadataParams.size(); i++) { SPParameter metadataParameter = metadataParams.get(i); if( (metadataParameter.getParameterType()==ParameterInfo.IN) || (metadataParameter.getParameterType()==ParameterInfo.INOUT)){ if (ResolverUtil.hasDefault(metadataParameter.getMetadataID(), metadata) || metadataParameter.isVarArg()) { optional = true; optionalParams++; if (metadataParameter.isVarArg()) { varargs = true; } else if (metadataParameter.getParameterType() == ParameterInfo.OUT) { outParams++; } else if (metadataParameter.getParameterType() == ParameterInfo.RETURN_VALUE) { hasReturnValue = true; SPParameter clonedParam = (SPParameter)metadataParameter.clone();
GroupContext externalGroups = storedProcedureCommand.getExternalGroupContexts(); for (SPParameter param : storedProcedureCommand.getParameters()) { Expression expr = param.getExpression(); if(expr == null) { continue; Class<?> paramType = param.getClassType(); throw new QueryResolverException(QueryPlugin.Event.TEIID30143, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30143, storedProcedureCommand.getProcedureName(), param.getName())); Expression result = null; if (param.getParameterType() == SPParameter.RETURN_VALUE || param.getParameterType() == SPParameter.OUT) { if (!ResolverUtil.canImplicitlyConvert(tgtType, srcType)) { throw new QueryResolverException(QueryPlugin.Event.TEIID30144, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30144, param.getParameterSymbol(), tgtType, srcType)); result = ResolverUtil.convertExpression(expr, tgtType, metadata); } catch (QueryResolverException e) { throw new QueryResolverException(QueryPlugin.Event.TEIID30145, e, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30145, new Object[] { param.getParameterSymbol(), srcType, tgtType})); param.setExpression(result);
for (SPParameter param : sp.getParameters()) { Direction direction = Direction.IN; switch(param.getParameterType()) { case ParameterInfo.IN: direction = Direction.IN; continue; //already part of the metadata case ParameterInfo.RETURN_VALUE: returnType = param.getClassType(); continue; if (param.isUsingDefault() && BaseColumn.OMIT_DEFAULT.equalsIgnoreCase(metadataFactory.getMetadata().getExtensionProperty(param.getMetadataID(), BaseColumn.DEFAULT_HANDLING, false))) { continue; if (param.isVarArg()) { ArrayImpl av = (ArrayImpl) ((Constant)param.getExpression()).getValue(); if (av != null) { for (Object obj : av.getValues()) { Argument arg = new Argument(direction, new Literal(obj, param.getClassType().getComponentType()), param.getClassType().getComponentType(), metadataParam); translatedParameters.add(arg); value = translate(param.getExpression()); Argument arg = new Argument(direction, value, param.getClassType(), metadataParam); translatedParameters.add(arg);
int direction = this.convertParamRecordTypeToStoredProcedureType(paramRecord.getType()); SPParameter spParam = new SPParameter(paramRecord.getPosition(), direction, paramRecord.getFullName()); spParam.setMetadataID(paramRecord); spParam.setClassType(DataTypeManager.getDataTypeClass(runtimeType)); if (paramRecord.isVarArg()) { spParam.setVarArg(true); spParam.setClassType(DataTypeManager.getArrayType(spParam.getClassType())); SPParameter param = new SPParameter(lastParamIndex, SPParameter.RESULT_SET, resultRecord.getFullName()); param.setClassType(java.sql.ResultSet.class); param.setMetadataID(resultRecord); param.addResultSetColumn(columnRecord.getFullName(), DataTypeManager.getDataTypeClass(colType), columnRecord);
parameter = new SPParameter(parameterIndex++, value); parameter.setName(name); parameter.setParameterType(SPParameter.IN); storedProcedure.setParameter(parameter); parameter = null; parameter = new SPParameter(parameterIndex++, value); parameter.setName(name); parameter.setParameterType(SPParameter.IN); storedProcedure.setParameter(parameter); parameter = null;
private void helpCheckParameter(SPParameter param, int paramType, int index, String name, Class<?> type, Expression expr) { assertEquals("Did not get expected parameter type", paramType, param.getParameterType()); //$NON-NLS-1$ assertEquals("Did not get expected index for param", index, param.getIndex()); //$NON-NLS-1$ assertEquals("Did not get expected name for param", name, param.getName()); //$NON-NLS-1$ assertEquals("Did not get expected type for param", type, param.getClassType()); //$NON-NLS-1$ assertEquals("Did not get expected type for param", expr, param.getExpression()); //$NON-NLS-1$ }
/** * @see java.lang.Object#clone() */ public Object clone() { SPParameter copy = new SPParameter(); copy.index = this.index; copy.parameterType = this.parameterType; copy.parameterSymbol = this.parameterSymbol.clone(); if(this.expression != null) { copy.setExpression((Expression)this.expression.clone()); } if(this.resultSetColumns != null) { Iterator<ElementSymbol> iter = this.resultSetColumns.iterator(); Iterator<Object> idIter = this.resultSetIDs.iterator(); while(iter.hasNext()) { ElementSymbol column = iter.next(); copy.addResultSetColumn(column.getName(), column.getType(), idIter.next()); } } copy.setUsingDefault(this.usingDefault); copy.varArg = this.varArg; return copy; }
if (obj.isCalledWithReturn()) { for (SPParameter param : obj.getParameters()) { if (param.getParameterType() == SPParameter.RETURN_VALUE) { if (param.getExpression() == null) { append("?"); //$NON-NLS-1$ } else { visitNode(param.getExpression()); boolean first = true; for (SPParameter param : obj.getParameters()) { if (param.isUsingDefault() || param.getParameterType() == SPParameter.RETURN_VALUE || param.getParameterType() == SPParameter.RESULT_SET || param.getExpression() == null) { continue; append(escapeSinglePart(Symbol.getShortName(param.getParameterSymbol().getOutputName()))); append(" => "); //$NON-NLS-1$ boolean addParens = !obj.displayNamedParameters() && param.getExpression() instanceof CompareCriteria; if (addParens) { append(Tokens.LPAREN); visitNode(param.getExpression()); if (addParens) { append(Tokens.RPAREN);
@Override public void visit(StoredProcedure obj) { for (SPParameter param : obj.getInputParameters()) { try { if (!param.isUsingDefault() && !getMetadata().elementSupports(param.getMetadataID(), SupportConstants.Element.NULL) && EvaluatableVisitor.isFullyEvaluatable(param.getExpression(), true)) { try { // If nextValue is an expression, evaluate it before checking for null Object evaluatedValue = Evaluator.evaluate(param.getExpression()); if(evaluatedValue == null) { handleValidationError(QueryPlugin.Util.getString("ERR.015.012.0055", param.getParameterSymbol()), param.getParameterSymbol()); //$NON-NLS-1$ } else if (evaluatedValue instanceof ArrayImpl && getMetadata().isVariadic(param.getMetadataID())) { ArrayImpl av = (ArrayImpl)evaluatedValue; for (Object o : av.getValues()) { if (o == null) { handleValidationError(QueryPlugin.Util.getString("ERR.015.012.0055", param.getParameterSymbol()), param.getParameterSymbol()); //$NON-NLS-1$ } } } } catch(Exception e) { //ignore for now, we don't have the context which could be the problem } } } catch (TeiidComponentException e) { handleException(e); } } }
private static List<ParameterInfo> getParameterInfo(StoredProcedure procedure) { List<ParameterInfo> paramInfos = new ArrayList<ParameterInfo>(); for (SPParameter param : procedure.getParameters()) { ParameterInfo info = new ParameterInfo(param.getParameterType(), param.getResultSetColumns().size()); paramInfos.add(info); } return paramInfos; }
static List getProcResultSetSymbols(List params){ List result = new ArrayList(); Iterator iter = params.iterator(); while(iter.hasNext()){ SPParameter param = (SPParameter)iter.next(); if(param.getResultSetColumns() != null){ result.addAll(param.getResultSetColumns()); } } iter = params.iterator(); while(iter.hasNext()){ SPParameter param = (SPParameter)iter.next(); if(param.getParameterType() == ParameterInfo.INOUT || param.getParameterType() == ParameterInfo.RETURN_VALUE) { result.add(param.getParameterSymbol()); } } return result; }
@Test public void testExecNamedParams() { 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); SPParameter param2 = new SPParameter(2, new Reference(0)); param2.setName("p2");//$NON-NLS-1$ proc.setParameter(param2); helpTest(proc, "EXEC myproc(p1 => ?, p2 => ?)"); //$NON-NLS-1$ }
@Override public void visit(StoredProcedure obj) { for (SPParameter param : obj.getInputParameters()) { try { if (!getMetadata().elementSupports(param.getMetadataID(), SupportConstants.Element.NULL) && EvaluatableVisitor.isFullyEvaluatable(param.getExpression(), true)) { try { // If nextValue is an expression, evaluate it before checking for null Object evaluatedValue = Evaluator.evaluate(param.getExpression()); if(evaluatedValue == null) { handleValidationError(QueryPlugin.Util.getString("ERR.015.012.0055", param.getParameterSymbol()), param.getParameterSymbol()); //$NON-NLS-1$ } else if (evaluatedValue instanceof ArrayImpl && getMetadata().isVariadic(param.getMetadataID())) { ArrayImpl av = (ArrayImpl)evaluatedValue; for (Object o : av.getValues()) { if (o == null) { handleValidationError(QueryPlugin.Util.getString("ERR.015.012.0055", param.getParameterSymbol()), param.getParameterSymbol()); //$NON-NLS-1$ } } } } catch(ExpressionEvaluationException e) { //ignore for now, we don't have the context which could be the problem } } } catch (TeiidComponentException e) { handleException(e); } } }
/** * The param resolving always constructs an array, which is * not appropriate if passing an array directly * @return */ private boolean checkForArray(SPParameter param, Expression expr) { if (!param.isVarArg() || !(expr instanceof Array)) { return false; } Array array = (Array)expr; if (array.getExpressions().size() == 1) { Expression first = array.getExpressions().get(0); if (first.getType() != null && first.getType() == array.getType()) { param.setExpression(first); return true; } } return false; }
/** * Get the ordered list of all elements returned by this query. These elements * may be ElementSymbols or ExpressionSymbols but in all cases each represents a * single column. * @return Ordered list of ElementSymbol */ public List getProjectedSymbols(){ if (!returnParameters()) { return getResultSetColumns(); } //add result set columns List<ElementSymbol> result = new ArrayList<ElementSymbol>(getResultSetColumns()); int size = result.size(); //add out/inout parameter symbols for (SPParameter parameter : mapOfParameters.values()) { if(parameter.getParameterType() == ParameterInfo.RETURN_VALUE){ ElementSymbol symbol = parameter.getParameterSymbol(); symbol.setGroupSymbol(this.getGroup()); //should be first among parameters, which we'll ensure result.add(size, symbol); } else if(parameter.getParameterType() == ParameterInfo.INOUT || parameter.getParameterType() == ParameterInfo.OUT){ ElementSymbol symbol = parameter.getParameterSymbol(); symbol.setGroupSymbol(this.getGroup()); result.add(symbol); } } return result; }