public ProcedureParameterTableModel(Procedure procedure, ProjectController mediator, Object eventSource) { super(mediator, eventSource, new ArrayList<>(procedure.getCallParameters())); this.procedure = procedure; }
/** * Invoked when currently selected Procedure object is changed. */ public void currentProcedureChanged(ProcedureDisplayEvent e) { Procedure procedure = e.getProcedure(); if (procedure == null || !e.isProcedureChanged()) { return; } name.setText(procedure.getName()); schema.setText(procedure.getSchema()); catalog.setText(procedure.getCatalog()); ignoreChange = true; returnsValue.setSelected(procedure.isReturningValue()); ignoreChange = false; }
private void processStartProcedure(Attributes attributes) throws SAXException { String name = attributes.getValue("", "name"); if (null == name) { throw new SAXException("MapLoader::processStartProcedure()," + " no procedure name."); } String schema = attributes.getValue("", "schema"); String catalog = attributes.getValue("", "catalog"); String returningValue = attributes.getValue("", "returningValue"); procedure = new Procedure(name); procedure.setReturningValue(returningValue != null && returningValue.equalsIgnoreCase(TRUE)); procedure.setSchema(schema); procedure.setCatalog(catalog); dataMap.addProcedure(procedure); }
/** * Adds stored procedure to the list of procedures. If there is another * procedure registered under the same name, throws an * IllegalArgumentException. */ public void addProcedure(Procedure procedure) { if (procedure.getName() == null) { throw new NullPointerException("Attempt to add procedure with no name."); } // TODO: change method signature to return replaced procedure and make // sure the // Modeler handles it... Object existingProcedure = procedureMap.get(procedure.getName()); if (existingProcedure != null) { if (existingProcedure == procedure) { return; } else { throw new IllegalArgumentException("An attempt to override procedure '" + procedure.getName()); } } procedureMap.put(procedure.getName(), procedure); procedure.setDataMap(this); }
void validate(Procedure procedure, ValidationResult validationResult) { validateName(procedure, validationResult); // check that return value is present if (procedure.isReturningValue()) { List<ProcedureParameter> parameters = procedure.getCallParameters(); if (parameters.isEmpty()) { addFailure( validationResult, procedure, "Procedure '%s' returns a value, but has no parameters", procedure.getName()); } } }
Procedure procedure = new Procedure(name); procedure.setCatalog(catalog); procedure.setSchema(schema); procedure.setReturningValue(false); break; case DatabaseMetaData.procedureReturnsResult: procedure.setReturningValue(true); break; procedures.put(procedure.getFullyQualifiedName(), procedure); break; case DatabaseMetaData.procedureColumnReturn: procedure.setReturningValue(true); break; column.setProcedure(procedure); column.setType(columnType); procedure.addCallParameter(column);
void validateName(Procedure procedure, ValidationResult validationResult) { String name = procedure.getName(); DataMap map = procedure.getDataMap(); if (map == null) { return; if (name.equals(otherProcedure.getName())) { addFailure( validationResult, procedure, "Duplicate Procedure name: %s", procedure.getName()); break;
private boolean syncProcedures(DataMap targetDataMap, DataMap loadedDataMap, FiltersConfig filters) { Collection<Procedure> procedures = loadedDataMap.getProcedures(); if (procedures.isEmpty()) { return false; } boolean hasChanges = false; for (Procedure procedure : procedures) { PatternFilter proceduresFilter = filters.proceduresFilter(procedure.getCatalog(), procedure.getSchema()); if (proceduresFilter == null || !proceduresFilter.isIncluded(procedure.getName())) { continue; } Procedure oldProcedure = targetDataMap.getProcedure(procedure.getName()); // maybe we need to compare oldProcedure's and procedure's fully qualified names? if (oldProcedure != null) { targetDataMap.removeProcedure(procedure.getName()); logger.info("Replace procedure " + procedure.getName()); } else { logger.info("Add new procedure " + procedure.getName()); } targetDataMap.addProcedure(procedure); hasChanges = true; } return hasChanges; }
/** * Returns <code>true</code> if path contains a DataMap object. */ public boolean enableForPath(ConfigurationNode object) { if (object == null) { return false; } return ((Procedure) object).getDataMap() != null; }
/** * Creates an SQL String for the stored procedure call. */ protected String createSqlString() { Procedure procedure = getProcedure(); StringBuffer buf = new StringBuffer(); int totalParams = callParams.size(); // check if procedure returns values if (procedure.isReturningValue()) { totalParams--; buf.append("{? = call "); } else { buf.append("{call "); } buf.append(procedure.getFullyQualifiedName()); if (totalParams > 0) { // unroll the loop buf.append("(?"); for (int i = 1; i < totalParams; i++) { buf.append(", ?"); } buf.append(")"); } buf.append("}"); return buf.toString(); }
procedure.setName(NameBuilder .builder(procedure, dataMap) .baseName(procedure.getName()) .dupesPattern(COPY_PATTERN) .name()); procedure.setName(NameBuilder .builder(procedure, dataMap) .dupesPattern(COPY_PATTERN) .baseName(procedure.getName()) .name()); .name()); procedure.addCallParameter(param); CreateProcedureParameterAction.fireProcedureParameterEvent( this,
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())); } } } }
void setCatalog(String text) { if (text != null && text.trim().length() == 0) { text = null; } Procedure procedure = eventController.getCurrentProcedure(); if (procedure != null && !Util.nullSafeEquals(procedure.getCatalog(), text)) { procedure.setCatalog(text); eventController.fireProcedureEvent(new ProcedureEvent(this, procedure)); } } }
void setSchema(String text) { if (text != null && text.trim().length() == 0) { text = null; } Procedure procedure = eventController.getCurrentProcedure(); if (procedure != null && !Util.nullSafeEquals(procedure.getSchema(), text)) { procedure.setSchema(text); eventController.fireProcedureEvent(new ProcedureEvent(this, procedure)); } }
@Override protected void processResultSetRow(CatalogFilter catalog, SchemaFilter schema, DbLoadDataStore map, ResultSet rs) throws SQLException { String procSchema = rs.getString("PROCEDURE_SCHEM"); String procCatalog = rs.getString("PROCEDURE_CAT"); String name = rs.getString("PROCEDURE_NAME"); String key = Procedure.generateFullyQualifiedName(procCatalog, procSchema, name); Procedure procedure = map.getProcedure(name); // should be filtered out in getResultSet() method, but check full name here too.. if (procedure == null || !key.equals(procedure.getFullyQualifiedName())) { return; } ProcedureParameter column = loadProcedureParams(rs, key, procedure); if (column == null) { return; } procedure.addCallParameter(column); }
public void validateObject(ProjectPath treeNodePath, Validator validator) { Procedure procedure = (Procedure) treeNodePath.getObject(); validateName(procedure, treeNodePath, validator); // check that return value is present if (procedure.isReturningValue()) { List parameters = procedure.getCallParameters(); if (parameters.size() == 0) { validator.registerWarning( "Procedure returns a value, but has no parameters.", treeNodePath); } } }
public void createProcedure(DataMap map, Procedure procedure) { ProjectController mediator = getProjectController(); procedure.setSchema(map.getDefaultSchema()); procedure.setCatalog(map.getDefaultCatalog()); map.addProcedure(procedure); fireProcedureEvent(this, mediator, map, procedure); }
public static void setProcedureName(DataMap map, Procedure procedure, String newName) { String oldName = procedure.getName(); // If name hasn't changed, just return if (Util.nullSafeEquals(oldName, newName)) { return; } procedure.setName(newName); map.removeProcedure(oldName); map.addProcedure(procedure); // important - clear parent namespace: MappingNamespace ns = map.getNamespace(); if (ns instanceof EntityResolver) { ((EntityResolver) ns).refreshMappingCache(); } }
public ValidationResult visitProcedure(Procedure procedure) { procedureValidator.validate(procedure, validationResult); ProcedureParameter parameter = procedure.getResultParam(); if (parameter != null) { visitProcedureParameter(parameter); } for (ProcedureParameter procPar : procedure.getCallOutParameters()) { visitProcedureParameter(procPar); } for (ProcedureParameter procPar : procedure.getCallParameters()) { visitProcedureParameter(procPar); } return validationResult; }