@Override public String getNewName() { return (parameter != null) ? parameter.getName() : null; }
protected String getParameterName(ProcedureParameter parameter) { return parameter.getName(); }
public String getName() { return parameter.getName(); }
public String getNewName() { return (parameter != null) ? parameter.getName() : null; }
/** Removes a named call parameter. */ public void removeCallParameter(String name) { for (int i = 0; i < callParameters.size(); i++) { ProcedureParameter nextParam = callParameters.get(i); if (name.equals(nextParam.getName())) { callParameters.remove(i); break; } } }
/** Removes a named call parameter. */ public void removeCallParameter(String name) { for (int i = 0; i < callParameters.size(); i++) { ProcedureParameter nextParam = (ProcedureParameter) callParameters.get(i); if (name.equals(nextParam.getName())) { callParameters.remove(i); break; } } }
/** * 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); }
@Override public boolean isNameInUse(String name) { // it doesn't matter if we create a parameter with a duplicate name.. parameters are positional anyway.. // still try to use unique names for visual consistency Procedure procedure = (Procedure) parent; for (ProcedureParameter parameter : procedure.getCallParameters()) { if (name.equals(parameter.getName())) { return true; } } return false; } });
protected boolean isNameInUse(String name, Object namingContext) { // it doesn't matter if we create a parameter with // a duplicate name.. parameters are positional anyway.. // still try to use unique names for visual consistency Procedure procedure = (Procedure) namingContext; Iterator it = procedure.getCallParameters().iterator(); while (it.hasNext()) { ProcedureParameter parameter = (ProcedureParameter) it.next(); if (name.equals(parameter.getName())) { return true; } } return false; } }
/** * 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); }
protected ProcedureParameter[] getLastProcedureParameters(Procedure procedure) { List<ProcedureParameter> procedureParameterList = new ArrayList<ProcedureParameter>(); ProcedureParameter[] parameters = new ProcedureParameter[0]; String procedureParams = preferences.getProcedureParams(); if (procedureParams.isEmpty()) { return procedureParameterList.toArray(parameters); } for (String procedureParamName : procedureParams.split(",")) { for (ProcedureParameter procedureParameter : procedure.getCallParameters()) { if (procedureParameter.getName().equals(procedureParamName)) { procedureParameterList.add(procedureParameter); } } } return procedureParameterList.toArray(parameters); } }
protected void initValues() { Map 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? Iterator it = callParams.iterator(); while (it.hasNext()) { ProcedureParameter param = (ProcedureParameter) it.next(); if (param.getDirection() == ProcedureParameter.OUT_PARAMETER) { values.add(OUT_PARAM); } else { values.add(queryValues.get(param.getName())); } } }
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())); } } }
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); }
private void searchInProcedures(Pattern pattern, List<SearchResultEntry> result, DataMap dataMap) { for (Procedure proc : dataMap.getProcedures()) { if (match(proc.getName(), pattern)) { result.add(new SearchResultEntry(proc, proc.getName())); } for(ProcedureParameter param : proc.getCallParameters()) { if(match(param.getName(), pattern)) { result.add(new SearchResultEntry(param, proc.getName() + '.' + param.getName())); } } } }
/** * 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(); } }
public void removeProcedureParameters( Procedure procedure, ProcedureParameter[] parameters) { ProjectController mediator = getProjectController(); for (ProcedureParameter parameter : parameters) { procedure.removeCallParameter(parameter.getName()); ProcedureParameterEvent e = new ProcedureParameterEvent(Application .getFrame(), parameter, MapEvent.REMOVE); mediator.fireProcedureParameterEvent(e); } } }
private void removeProcedureParameters(Procedure procedure, ProcedureParameter[] parameters) { ProjectController mediator = getProjectController(); for (ProcedureParameter parameter : parameters) { procedure.removeCallParameter(parameter.getName()); ProcedureParameterEvent e = new ProcedureParameterEvent(Application.getFrame(), parameter, MapEvent.REMOVE); mediator.fireProcedureParameterEvent(e); } }
@Override public void performAction(ActionEvent e, boolean allowAsking) { ConfirmRemoveDialog dialog = getConfirmDeleteDialog(allowAsking); ProcedureParameter[] params = getProjectController() .getCurrentProcedureParameters(); if (params.length > 0) { if ((params.length == 1 && dialog.shouldDelete( "procedure parameter", params[0].getName())) || (params.length > 1 && dialog .shouldDelete("selected procedure parameters"))) { removeProcedureParameters(); } } }
/** * 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(); } }