public static String getTokenValue(DbRelationship rel) { String attributes = ""; if (rel.getJoins().size() == 1) { attributes = rel.getJoins().get(0).getTargetName(); } else { for (DbJoin dbJoin : rel.getJoins()) { attributes += dbJoin.getTargetName() + COMMA_SEPARATOR; } if(attributes.isEmpty()) { attributes = "{}"; } else { attributes = "{" + attributes.substring(0, attributes.length() - COMMA_SEPARATOR_LENGTH) + "}"; } } return rel.getName() + " " + rel.getSourceEntity().getName() + "->" + rel.getTargetEntityName() + "." + attributes; }
private void prependReversedPath(LinkedList<String> finalPath, DbRelationship relationship) { DbRelationship revNextDBR = relationship.getReverseRelationship(); if (revNextDBR == null) { throw new CayenneRuntimeException("Unable to find reverse DbRelationship for %s.%s." , relationship.getSourceEntity().getName(), relationship.getName()); } finalPath.addFirst(revNextDBR.getName()); }
/** * Creates a new relationship with the same set of joins, but going in the opposite * direction. * * @since 1.0.5 */ public DbRelationship createReverseRelationship() { DbRelationship reverse = new DbRelationship(); reverse.setSourceEntity(getTargetEntity()); reverse.setTargetEntityName(getSourceEntity().getName()); // TODO: must set toDepPK correctly // must set toMany correctly reverse.setToMany(!toMany); Iterator it = joins.iterator(); while (it.hasNext()) { DbJoin join = (DbJoin) it.next(); DbJoin reverseJoin = join.createReverseJoin(); reverseJoin.setRelationship(reverse); reverse.addJoin(reverseJoin); } return reverse; }
/** * Returns <code>true</code> if a method <code>isToDependentPK</code> of * reverse relationship of this relationship returns <code>true</code>. */ public boolean isToMasterPK() { if (isToMany() || isToDependentPK()) { return false; } DbRelationship revRel = getReverseRelationship(); return revRel != null && revRel.isToDependentPK(); }
public boolean isCellEditable(int row, int col) { if (col == SOURCE) { return relationship.getSourceEntity() != null && editable; } else if (col == TARGET) { return relationship.getTargetEntity() != null && editable; } return false; }
/** * Returns a boolean indicating whether modifying a target of such * relationship in any way will not change the underlying table row of the * source. * * @since 4.0 */ public boolean isSourceIndependentFromTargetChange() { // note - call "isToPK" at the end of the chain, since // if it is to a dependent PK, we still should return true... return isToMany() || isToDependentPK() || !isToPK(); }
private void processStartDbRelationship(Attributes atts) throws SAXException { String name = atts.getValue("", "name"); if (name == null) { throw new SAXException("MapLoader::processStartDbRelationship()," + " Unable to parse name. Attributes:\n" + printAttributes(atts)); } String sourceName = atts.getValue("", "source"); if (sourceName == null) { throw new SAXException("MapLoader::processStartDbRelationship() - null source entity"); } DbEntity source = dataMap.getDbEntity(sourceName); if (source == null) { return; } String toManyString = atts.getValue("", "toMany"); boolean toMany = toManyString != null && toManyString.equalsIgnoreCase(TRUE); String toDependPkString = atts.getValue("", "toDependentPK"); boolean toDependentPK = toDependPkString != null && toDependPkString.equalsIgnoreCase(TRUE); dbRelationship = new DbRelationship(name); dbRelationship.setSourceEntity(source); dbRelationship.setTargetEntityName(atts.getValue("", "target")); dbRelationship.setToMany(toMany); dbRelationship.setToDependentPK(toDependentPK); source.addRelationship(dbRelationship); }
if (relationship.isToDependentPK() && !relationship.isValidForDepPk()) { relationship.setToDependentPK(false); reverseRelationship = new DbRelationship(); reverseRelationship.setName(NameBuilder .builder(reverseRelationship, relationship.getTargetEntity()) .baseName(reverseName.getText().trim()) .name()); reverseRelationship.setSourceEntity(relationship.getTargetEntity()); reverseRelationship.setTargetEntityName(relationship.getSourceEntity()); reverseRelationship.setToMany(!relationship.isToMany()); relationship.getTargetEntity().addRelationship(reverseRelationship); if (relationship.getSourceEntity() == relationship.getTargetEntity()) { getMediator().fireDbRelationshipEvent( new RelationshipEvent( this, reverseRelationship, reverseRelationship.getSourceEntity(), MapEvent.ADD)); reverseRelationship.setJoins(reverseJoins); if (!relationship.isToDependentPK() && reverseRelationship.isValidForDepPk()) { reverseRelationship.setToDependentPK(true); new RelationshipEvent(this, relationship, relationship.getSourceEntity()));
/** * Prints itself as XML to the provided XMLEncoder. * * @since 1.1 */ public void encodeAsXML(XMLEncoder encoder) { encoder.print("<db-relationship name=\""); encoder.print(Util.encodeXmlAttribute(getName())); encoder.print("\" source=\""); encoder.print(getSourceEntity().getName()); if (getTargetEntityName() != null && getTargetEntity() != null) { encoder.print("\" target=\""); encoder.print(getTargetEntityName()); } if (isToDependentPK() && isValidForDepPk()) { encoder.print("\" toDependentPK=\"true"); } encoder.print("\" toMany=\""); encoder.print(isToMany()); encoder.println("\">"); encoder.indent(1); encoder.print(getJoins()); encoder.indent(-1); encoder.println("</db-relationship>"); }
while (rit.hasNext()) { DbRelationship protoRel = (DbRelationship) rit.next(); DbRelationship rel = new DbRelationship(); rel.setName(protoRel.getName()); rel.setSourceEntity(this); rel.setTargetEntity(protoRel.getTargetEntity()); Iterator joins = protoRel.getJoins().iterator(); while (joins.hasNext()) { DbJoin protoJoin = (DbJoin) joins.next(); join.setSourceName(protoJoin.getSourceName()); join.setTargetName(protoJoin.getTargetName()); rel.addJoin(join);
DbEntity source = dbRel != null ? dbRel.getTargetEntity() : null; DbRelationship dbRelationship = new DbRelationship(); dbRelationship.setSourceEntity(targetModel.getSource()); dbRelationship.setTargetEntityName(targetModel.getTarget()); dbRelationship.setToMany(targetModel.isToMany()); dbRelationship.setName(createNamingStrategy(NameGeneratorPreferences .getInstance() .getLastUsedStrategies() targetModel.getSource().removeRelationship(dbRelationship.getName()); } else { MultiColumnBrowser pathBrowser = getPathBrowser();
protected void createNames() { for (InferredRelationship myir : inferredRelationships) { DbRelationship localRelationship = new DbRelationship(); localRelationship.setToMany(myir.isToMany()); if (myir.getJoinSource().isPrimaryKey()) { localRelationship.addJoin( new DbJoin(localRelationship, myir.getJoinSource().getName(), myir.getJoinTarget().getName()) ); localRelationship.setSourceEntity(myir.getSource()); localRelationship.setTargetEntityName(myir.getTarget().getName()); } else { localRelationship.addJoin( new DbJoin(localRelationship, myir.getJoinTarget().getName(), myir.getJoinSource().getName()) ); localRelationship.setSourceEntity(myir.getTarget()); localRelationship.setTargetEntityName(myir.getSource().getName()); } myir.setName(strategy.relationshipName(localRelationship)); } }
public Object getValueAt(int row, int col) { DbRelationship rel = getRelationship(row); if (rel == null) { return null; } switch (col) { case NAME: return rel.getName(); case TARGET: return rel.getTargetEntity(); case TO_DEPENDENT_KEY: return rel.isToDependentPK() ? Boolean.TRUE : Boolean.FALSE; case CARDINALITY: return rel.isToMany() ? Boolean.TRUE : Boolean.FALSE; default: return null; } }
if (dbRel == null) { dbRel = new DbRelationship(); dbRel.setSourceEntity(dbSrc); dbRel.setTargetEntity(dbTarget); dbRel.setToMany(toMany); dbRel.setName(relName); dbRel.setToDependentPK(toDependentPK); dbSrc.addRelationship(dbRel); targetAttributes, targetAttributeName)); dbRel.addJoin(join);
private void initWithModel() { // init UI components sourceName.setText(relationship.getSourceEntityName()); targetName.setText(relationship.getTargetEntityName()); name.setText(relationship.getName()); if (reverseRelationship != null) { reverseName.setText(reverseRelationship.getName()); } table.setModel(new DbJoinTableModel(relationship, getMediator(), this, true)); TableColumn sourceColumn = table.getColumnModel().getColumn(DbJoinTableModel.SOURCE); JComboBox comboBox = Application.getWidgetFactory().createComboBox( ModelerUtil.getDbAttributeNames(getMediator(), relationship.getSourceEntity()), true); AutoCompletion.enable(comboBox); sourceColumn.setCellEditor(Application.getWidgetFactory().createCellEditor(comboBox)); TableColumn targetColumn = table.getColumnModel().getColumn(DbJoinTableModel.TARGET); comboBox = Application.getWidgetFactory().createComboBox( ModelerUtil.getDbAttributeNames(getMediator(), relationship.getTargetEntity()), true); AutoCompletion.enable(comboBox); targetColumn.setCellEditor(Application.getWidgetFactory().createCellEditor(comboBox)); tablePreferences.bind(table, null, null, null, DbJoinTableModel.SOURCE, true); }
public DbJoinTableModel( DbRelationship relationship, ProjectController mediator, Object src) { super(mediator, src, new ArrayList<>(relationship.getJoins())); this.relationship = relationship; this.source = relationship.getSourceEntity(); this.target = relationship.getTargetEntity(); }
private void checkToMany(DbRelationship relationship, ValidationResult validationResult) { if (relationship != null && relationship.getReverseRelationship() != null) { if (relationship.isToMany() && relationship.getReverseRelationship().isToMany()) { addFailure( validationResult, relationship, "Relationship '%s' and reverse '%s' are both toMany", relationship.getName(), relationship.getReverseRelationship().getName()); } } checkTypesOfAttributesInRelationship(relationship, validationResult); }
private boolean isMultiJoin() { return getDbRelationship().getReverseRelationship().getJoins().size() > 1; } }
forwardRelationship = new DbRelationship(DbLoader .uniqueRelName(pkEntity, fkEntityName, true)); forwardRelationship.setSourceEntity(pkEntity); forwardRelationship.setTargetEntity(fkEntity); pkEntity.addRelationship(forwardRelationship); reverseRelationship = new DbRelationship(uniqueRelName( fkEntity, pkEntName, false)); reverseRelationship.setToMany(false); reverseRelationship.setSourceEntity(fkEntity); reverseRelationship.setTargetEntity(pkEntity); fkEntity.addRelationship(reverseRelationship); forwardRelationship.addJoin(new DbJoin( forwardRelationship, pkName, fkName)); reverseRelationship.addJoin(new DbJoin( reverseRelationship, fkName,
private DbRelationship findMasterToDependentDbRelationship( DbEntity masterDbEntity, DbEntity dependentDbEntity) { Iterator it = masterDbEntity.getRelationshipMap().values().iterator(); while (it.hasNext()) { DbRelationship relationship = (DbRelationship) it.next(); if (dependentDbEntity.equals(relationship.getTargetEntity()) && relationship.isToDependentPK()) { if (relationship.isToMany()) { throw new CayenneRuntimeException( "Only 'to one' master-detail relationships can be processed."); } return relationship; } } return null; } }