private static CsdlParameter buildParameter(ProcedureParameter pp, EdmPrimitiveTypeKind odatatype) { CsdlParameter param = new CsdlParameter(); param.setName(pp.getName()); param.setType(odatatype.getFullQualifiedName()); if (DataTypeManager.isArrayType(pp.getRuntimeType())) { param.setCollection(true); param.setNullable(pp.getNullType() == NullType.Nullable); String runtimeType = pp.getRuntimeType(); param.setMaxLength(pp.getLength()); } else if (runtimeType.equals(DataTypeManager.DefaultDataTypes.BIG_DECIMAL) || runtimeType.equals(DataTypeManager.DefaultDataTypes.BIG_INTEGER)) { if (pp.getScale() < 0) { param.setPrecision((int)Math.min(Integer.MAX_VALUE, (long)pp.getPrecision() - pp.getScale())); } else { param.setPrecision(pp.getPrecision()); param.setScale(Math.max(0, pp.getScale())); } else if (runtimeType.equals(DataTypeManager.DefaultDataTypes.TIMESTAMP) || runtimeType.equals(DataTypeManager.DefaultDataTypes.TIME)) { param.setPrecision(pp.getPrecision() == 0?new Integer(4):pp.getPrecision()); if (pp.getDefaultValue() != null) { String srid = pp.getProperty(BaseColumn.SPATIAL_SRID, false); if (srid != null) {
BaseColumn addProcColumn(MetadataFactory factory, Procedure proc, String name, ParsedDataType type, boolean rs) throws MetadataException { BaseColumn column = null; if (rs) { column = factory.addProcedureResultSetColumn(name, type.type, proc); } else { boolean added = false; for (ProcedureParameter pp : proc.getParameters()) { if (pp.getType() == Type.ReturnValue) { added = true; if (pp.getDatatype() != factory.getDataTypes().get(type.type)) { throw new MetadataException(QueryPlugin.Util.getString("SQLParser.proc_type_conflict", proc.getName(), pp.getDatatype(), type.type)); //$NON-NLS-1$ } } } if (!added) { column = factory.addProcedureParameter(name, type.type, ProcedureParameter.Type.ReturnValue, proc); } } setTypeInfo(type, column); return column; }
final ProcedureParameter paramRd = new ProcedureParameter(); paramRd.setDefaultValue(getObjectValue(tokens.get(tokenIndex++)) ); paramRd.setRuntimeType(getObjectValue(tokens.get(tokenIndex++)) ); paramRd.setDatatypeUUID(getObjectValue(tokens.get(tokenIndex++)) ); paramRd.setLength(Integer.parseInt(tokens.get(tokenIndex++)) ); paramRd.setRadix(Integer.parseInt(tokens.get(tokenIndex++)) ); paramRd.setScale(Integer.parseInt(tokens.get(tokenIndex++)) ); paramRd.setNullType(NullType.values()[Integer.parseInt(tokens.get(tokenIndex++))]); paramRd.setPrecision(Integer.parseInt(tokens.get(tokenIndex++)) ); paramRd.setPosition(Integer.parseInt(tokens.get(tokenIndex++)) ); throw new IllegalArgumentException("Invalid parameter type, please ensure all parameter types are valid in Designer."); //$NON-NLS-1$ paramRd.setType(type); paramRd.setOptional(getBooleanValue(flags[0]));
public void addArgument(ProcedureParameter param, Object payload) { if (payload == null) { return; } String nis = param.getNameInSource(); if (nis == null) { nis = param.getName(); } addArgument(this, nis, payload); }
private Class<?> resolveParameterType(String procedureName, String parameterName) { for (ProcedureParameter pp : this.procedure.getParameters()) { if (pp.getName().equalsIgnoreCase(parameterName)) { return DataTypeManager.getDataTypeClass(pp.getRuntimeType()); } } return null; }
@Override public void execute(String name, String nameInSource, Property property, boolean array) { String type = getPropertyType(property, array); if (procedure.getParameterByName(nameInSource) == null) { ProcedureParameter param = mf.addProcedureParameter(name, type, Type.In, procedure); param.setProperty(PARAMETER_TYPE, parameter.getIn()); if (property != null && !property.getRequired()) { param.setProperty(BaseColumn.DEFAULT_HANDLING, BaseColumn.OMIT_DEFAULT); } param.setNullType(NullType.No_Nulls); param.setAnnotation(property!=null?property.getDescription():null); if (!name.equalsIgnoreCase(nameInSource)) { param.setNameInSource(nameInSource); } } } };
if (pp.getType() == ProcedureParameter.Type.InOut || pp.getType() == ProcedureParameter.Type.Out) { throw new MetadataException(QueryPlugin.Util.getString("SQLParser.function_in", proc.getName())); //$NON-NLS-1$ FunctionParameter fp = new FunctionParameter(pp.getName(), pp.getRuntimeType(), pp.getAnnotation()); fp.setDatatype(pp.getDatatype(), true, pp.getArrayDimensions()); fp.setLength(pp.getLength()); fp.setNameInSource(pp.getNameInSource()); fp.setNativeType(pp.getNativeType()); fp.setNullType(pp.getNullType()); fp.setProperties(pp.getProperties()); fp.setRadix(pp.getRadix()); fp.setScale(pp.getScale()); fp.setUUID(pp.getUUID()); if (pp.getType() == ProcedureParameter.Type.In) { fp.setVarArg(pp.isVarArg()); ins.add(fp); fp.setPosition(ins.size()); fp.setPosition(0); if (pp.getDefaultValue() != null) { throw new MetadataException(QueryPlugin.Util.getString("SQLParser.function_default", proc.getName())); //$NON-NLS-1$
ProcedureParameter paramRecord = (ProcedureParameter) this.getRecordByType(procedureRecord.getParameters().get(i).getUUID(), MetadataConstants.RECORD_TYPE.CALLABLE_PARAMETER); setDataType(paramRecord); procedureRecord.getParameters().set(i, paramRecord); paramRecord.setProcedure(procedureRecord); for (ProcedureParameter param : procedureRecord.getParameters()) { FunctionParameter fp = new FunctionParameter(); fp.setName(param.getName()); fp.setDescription(param.getAnnotation()); fp.setRuntimeType(param.getRuntimeType()); fp.setDatatype(param.getDatatype(), true, param.getArrayDimensions()); fp.setUUID(param.getUUID()); switch (param.getType()) { case ReturnValue: if (outputParam != null) {
for (int i = 0; i < p.getParameters().size(); i++) { ProcedureParameter param = p.getParameters().get(i); if (param.isVarArg() && param != p.getParameters().get(p.getParameters().size() -1)) { if ((param1.getType() == Type.In || param1.getType() == Type.InOut) && (param1.isVarArg() || (param1.getNullType() != NullType.Nullable && param1.getDefaultValue() == null))) { metadataValidator.log(report, model, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID31112, p.getFullName())); if (param.getType() == ProcedureParameter.Type.ReturnValue) { if (hasReturn) { metadataValidator.log(report, model, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID31107, p.getFullName())); } else if (p.isFunction() && param.getType() != ProcedureParameter.Type.In) { metadataValidator.log(report, model, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID31165, p.getFullName(), param.getFullName())); if (!names.add(param.getName())) { metadataValidator.log(report, model, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID31106, p.getFullName(), param.getFullName()));
boolean hasLobInput = false; for (ProcedureParameter p : procedure.getParameters()) { if (p.getType() == Type.In || p.getType() == Type.InOut) { params.add(p); } else if (p.getType() == Type.ReturnValue && procedure.getResultSet() == null) { usingReturn = true; String runtimeType = p.getRuntimeType(); hasLobInput = DataTypeManager.isLOB(runtimeType); paramType = "Ljavax/ws/rs/QueryParam;"; if (pathParms.contains(params.get(i).getName())){ paramType = "Ljavax/ws/rs/PathParam;"; av0.visit("value", params.get(i).getName()); av0.visitEnd(); av0.visit("value", params.get(i).getName()); av0.visitEnd(); for (int i = 0; i < paramsSize; i++) { mv.visitVarInsn(ALOAD, paramsSize+1); mv.visitLdcInsn(params.get(i).getName()); mv.visitVarInsn(ALOAD, i+1); mv.visitMethodInsn(INVOKEINTERFACE, "java/util/Map", "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
String runtimeType = paramRecord.getRuntimeType(); 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()));
assertEquals("p1", proc.getParameters().get(0).getName()); assertEquals("boolean", proc.getParameters().get(0).getDatatype().getName()); assertEquals(ProcedureParameter.Type.Out, proc.getParameters().get(0).getType()); assertEquals("p2", proc.getParameters().get(1).getName()); assertEquals("string", proc.getParameters().get(1).getDatatype().getName()); assertEquals(ProcedureParameter.Type.In, proc.getParameters().get(1).getType()); assertEquals("p3", proc.getParameters().get(2).getName()); assertEquals("bigdecimal", proc.getParameters().get(2).getDatatype().getName()); assertEquals(ProcedureParameter.Type.InOut, proc.getParameters().get(2).getType());
private static boolean isInputParameterLob(Procedure proc) { for (ProcedureParameter pp : proc.getParameters()) { if (!pp.getType().equals(ProcedureParameter.Type.ReturnValue) && DataTypeManager.isLOB(pp.getRuntimeType())) { return true; } } return false; }
if (pp.getName().equals("return")) { //$NON-NLS-1$ httpMethod = "GET"; //$NON-NLS-1$ edmProcedure.setReturnType(ODataTypeManager.odataType(pp.getRuntimeType())); continue; param.setName(pp.getName()); param.setType(ODataTypeManager.odataType(pp.getRuntimeType())); if (pp.getType() == ProcedureParameter.Type.In) { param.setMode(Mode.In); else if (pp.getType() == ProcedureParameter.Type.InOut) { param.setMode(Mode.InOut); else if (pp.getType() == ProcedureParameter.Type.Out) { param.setMode(Mode.Out); param.setNullable(pp.getNullType() == NullType.Nullable); edmProcedure.addParameters(param);
this.buffer.append("&"); //$NON-NLS-1$ this.buffer.append(WSUtil.httpURLEncode(param.getMetadataObject().getName())); this.buffer.append(Tokens.EQ); this.executionFactory.convertToODataInput(param.getArgumentValue(), temp); if (param.getType().equals(ProcedureParameter.Type.ReturnValue)) { this.returnType = param.getRuntimeType(); this.returnTypeClass = param.getJavaType();
switch(elementConstant) { case SupportConstants.Element.NULL: return columnRecord.getNullType() == NullType.Nullable; case SupportConstants.Element.NULL_UNKNOWN: return columnRecord.getNullType() == NullType.Unknown; case SupportConstants.Element.SEARCHABLE_COMPARE: case SupportConstants.Element.SEARCHABLE_LIKE: return false; case SupportConstants.Element.SELECT: return columnRecord.getType() != Type.In; case SupportConstants.Element.UPDATE: return false; case SupportConstants.Element.DEFAULT_VALUE: Object defaultValue = columnRecord.getDefaultValue(); if(defaultValue == null) { return false;
public ProcedureParameter getParameterByName(String param) { for(ProcedureParameter p: this.parameters) { if (p.getName().equals(param)) { return p; } } return null; }
public ProcedureParameter getReturnParameter() { for (ProcedureParameter param : this.metadataObject.getParameters()) { if (param.getType() == Type.ReturnValue) { return param; } } return null; }
@Override public void loadMetadata(MetadataFactory factory, ExecutionFactory executionFactory, Object connectionFactory) throws TranslatorException { if (executionFactory != null && executionFactory.supportsDirectQueryProcedure() && factory.getSchema().getProcedure(executionFactory.getDirectQueryProcedureName()) == null) { Procedure p = factory.addProcedure(executionFactory.getDirectQueryProcedureName()); p.setAnnotation("Invokes translator with a native query that returns results in an array of values"); //$NON-NLS-1$ ProcedureParameter param = factory.addProcedureParameter("request", TypeFacility.RUNTIME_NAMES.STRING, Type.In, p); //$NON-NLS-1$ param.setAnnotation("The native query to execute"); //$NON-NLS-1$ param.setNullType(NullType.No_Nulls); param = factory.addProcedureParameter("variable", TypeFacility.RUNTIME_NAMES.OBJECT, Type.In, p); //$NON-NLS-1$ param.setAnnotation("Any number of varaibles; usage will vary by translator"); //$NON-NLS-1$ param.setNullType(NullType.Nullable); param.setVarArg(true); factory.addProcedureResultSetColumn("tuple", DataTypeManager.getDataTypeName(DataTypeManager.getArrayType(TypeFacility.RUNTIME_TYPES.OBJECT)), p); //$NON-NLS-1$ } } }
param = params.get(i); ProcedureParameter metadata = param.getMetadataObject(); String argName = WSUtil.httpURLEncode(param.getMetadataObject().getName()); if (param.getDirection() == Direction.IN || param.getDirection() == Direction.INOUT) { String in = metadata.getProperty(RestMetadataExtension.PARAMETER_TYPE, false); if (in.equalsIgnoreCase(RestMetadataExtension.ParameterType.QUERY.name())) { if (queryParameters.length() != 0) { if (value instanceof Array) { addArgumentValue(argName, (Array)value, metadata.getProperty(SwaggerMetadataProcessor.COLLECION_FORMAT, false), queryParameters); } else { if (value instanceof Array) { addArgumentValue(argName, (Array)value, metadata.getProperty(SwaggerMetadataProcessor.COLLECION_FORMAT, false), formParameters); } else {