/** * Creates a ColumnDescriptor from stored procedure parameter. * * @since 1.2 */ public ColumnDescriptor(ProcedureParameter parameter) { this.name = parameter.getName(); this.qualifiedColumnName = name; this.label = name; this.jdbcType = parameter.getType(); this.javaClass = getDefaultJavaClass(parameter.getMaxLength(), parameter .getPrecision()); if (parameter.getProcedure() != null) { this.procedureName = parameter.getProcedure().getName(); } }
protected Object create(String name, Object namingContext) { return new ProcedureParameter(name); }
protected String getParameterDirection(ProcedureParameter parameter) { int direction = parameter.getDirection(); return PARAMETER_DIRECTION_NAMES[direction == -1 ? 0 : direction]; }
public ProcedureParameter(String name, int type, int direction) { this(name); setType(type); setDirection(direction); }
/** * Creates a ColumnDescriptor from stored procedure parameter. * * @since 1.2 */ public ColumnDescriptor(ProcedureParameter parameter) { this(parameter.getName(), parameter.getType()); if (parameter.getProcedure() != null) { this.procedureName = parameter.getProcedure().getName(); } }
/** * Sets a single OUT parameter of the CallableStatement. */ protected void setOutParam(CallableStatement stmt, ProcedureParameter param, int pos) throws Exception { int precision = param.getPrecision(); if (precision >= 0) { stmt.registerOutParameter(pos, param.getType(), precision); } else { stmt.registerOutParameter(pos, param.getType()); } } }
private void processStartProcedureParameter(Attributes attributes) throws SAXException { String name = attributes.getValue("", "name"); if (name == null) { throw new SAXException("MapLoader::processStartProcedureParameter()," + " no procedure parameter name."); } ProcedureParameter parameter = new ProcedureParameter(name); String type = attributes.getValue("", "type"); if (type != null) { parameter.setType(TypesMapping.getSqlTypeByName(type)); } String length = attributes.getValue("", "length"); if (length != null) { parameter.setMaxLength(Integer.parseInt(length)); } String precision = attributes.getValue("", "precision"); if (precision != null) { parameter.setPrecision(Integer.parseInt(precision)); } String direction = attributes.getValue("", "direction"); if ("in".equals(direction)) { parameter.setDirection(ProcedureParameter.IN_PARAMETER); } else if ("out".equals(direction)) { parameter.setDirection(ProcedureParameter.OUT_PARAMETER); } else if ("in_out".equals(direction)) { parameter.setDirection(ProcedureParameter.IN_OUT_PARAMETER); } procedure.addCallParameter(parameter); }
void validate(ProcedureParameter parameter, ValidationResult validationResult) { if (Util.isEmptyString(parameter.getName())) { addFailure(validationResult, parameter, "Unnamed ProcedureParameter"); if (parameter.getType() == TypesMapping.NOT_DEFINED) { addFailure( validationResult, parameter, "ProcedureParameter '%s' has no type", parameter.getName()); if (parameter.getMaxLength() < 0 && (parameter.getType() == Types.VARCHAR || parameter.getType() == Types.NVARCHAR || parameter.getType() == Types.CHAR || parameter.getType() == Types.NCHAR)) { parameter, "Character ProcedureParameter '%s' doesn't have max length", parameter.getName()); if (parameter.getDirection() <= 0) { addFailure( validationResult, parameter, "ProcedureParameter '%s' has no direction", parameter.getName());
@Override public String getNewName() { return (parameter != null) ? parameter.getName() : null; }
public static void setProcedureParameterName( ProcedureParameter parameter, String newName) { String oldName = parameter.getName(); // If name hasn't changed, just return if (Util.nullSafeEquals(oldName, newName)) { return; } Procedure procedure = parameter.getProcedure(); procedure.removeCallParameter(parameter.getName()); parameter.setName(newName); procedure.addCallParameter(parameter); }
protected void initValues() { Map<String, ?> queryValues = getProcedureQuery().getParameters(); // match values with parameters in the correct order. // make an assumption that a missing value is NULL // Any reason why this is bad? for (ProcedureParameter param : callParams) { if (param.getDirection() == ProcedureParameter.OUT_PARAMETER) { values.add(OUT_PARAM); } else { values.add(queryValues.get(param.getName())); } } }
/** * Adds new call parameter to the stored procedure. Also sets <code>param</code>'s * parent to be this procedure. */ public void addCallParameter(ProcedureParameter param) { if (param.getName() == null) { throw new IllegalArgumentException("Attempt to add unnamed parameter."); } if (callParameters.contains(param)) { throw new IllegalArgumentException( "Attempt to add the same parameter more than once:" + param); } param.setProcedure(this); callParameters.add(param); }
ProcedureParameter parameter = (ProcedureParameter) parameters.get(i); if (!parameter.isOutParam()) { continue; if (parameter.getType() == OracleAdapter.getOracleCursorType()) { ResultSet rs = (ResultSet) statement.getObject(i + 1);
public void createProcedureParameter() { Procedure procedure = getProjectController().getCurrentProcedure(); ProcedureParameter parameter = new ProcedureParameter(); parameter.setName(NameBuilder.builder(parameter, procedure).name()); procedure.addCallParameter(parameter); ProjectController mediator = getProjectController(); fireProcedureParameterEvent(this, mediator, procedure, parameter); }
public int getType() { return parameter.getType(); }
public int getMaxLength() { return parameter.getMaxLength(); }
protected void setParameterDirection(String direction, ProcedureParameter parameter) { if (ProcedureParameterTableModel.IN_PARAMETER.equals(direction)) { parameter.setDirection(ProcedureParameter.IN_PARAMETER); } else if (ProcedureParameterTableModel.OUT_PARAMETER.equals(direction)) { parameter.setDirection(ProcedureParameter.OUT_PARAMETER); } else if (ProcedureParameterTableModel.IN_OUT_PARAMETER.equals(direction)) { parameter.setDirection(ProcedureParameter.IN_OUT_PARAMETER); } }
@Override public int getScale() { return parameter.getPrecision(); } }
protected void setPrecision(String newVal, ProcedureParameter parameter) { if (newVal == null || newVal.trim().length() <= 0) { parameter.setPrecision(-1); } else { try { parameter.setPrecision(Integer.parseInt(newVal)); } catch (NumberFormatException ex) { JOptionPane.showMessageDialog( null, "Invalid precision (" + newVal + "), only numbers are allowed.", "Invalid Precision Value", JOptionPane.ERROR_MESSAGE); } } }