@Override Collection<DbRelationship> getAll() { return container.getRelationships(); }
public DbRelationshipTableModel(DbEntity entity, ProjectController mediator, Object eventSource) { super(mediator, eventSource, new ArrayList(entity.getRelationships())); this.entity = entity; }
protected List<DbRelationship> getRelationshipsToAdd(ObjEntity objEntity) { List<DbRelationship> missing = new ArrayList<>(); for (DbRelationship dbRel : objEntity.getDbEntity().getRelationships()) { if (shouldAddToObjEntity(objEntity, dbRel)) { missing.add(dbRel); } } return missing; }
protected List getRelationshipsToAdd(ObjEntity objEntity) { List missing = new ArrayList(); Iterator it = objEntity.getDbEntity().getRelationships().iterator(); while (it.hasNext()) { DbRelationship dbrel = (DbRelationship) it.next(); // check if adding it makes sense at all if (dbrel.getName() == null) { continue; } if (objEntity.getRelationshipForDbRelationship(dbrel) == null) { missing.add(dbrel); } } return missing; }
private Optional<DbJoin> findAnyJoin(DbAttribute attribute) { String attributeName = attribute.getName(); for (DbRelationship relationship : attribute.getEntity().getRelationships()) { for (DbJoin join : relationship.getJoins()) { if (attributeName.equals(join.getSourceName())) { return Optional.of(join); } } } return Optional.empty(); } }
private Collection<DbRelationship> getIncomingRelationships(DbEntity entity) { Collection<DbRelationship> incoming = new ArrayList<>(); for (DbEntity nextEntity : entity.getDataMap().getDbEntities()) { for (DbRelationship relationship : nextEntity.getRelationships()) { // TODO: PERFORMANCE 'getTargetEntity' is generally slow, called // in this iterator it is showing (e.g. in YourKit profiles).. // perhaps use cheaper 'getTargetEntityName()' or even better - // pre-cache all relationships by target entity to avoid O(n) // search ? // (need to profile to prove the difference) if (entity == relationship.getTargetEntity()) { incoming.add(relationship); } } } return incoming; }
/** * Generate Create Table in model token * @param original DbEntity found in model but not found in DB */ @Override Collection<MergerToken> createTokensForMissingImported(DbEntity original) { Collection<MergerToken> tokens = new LinkedList<>(); // add entity tokens.add(getTokenFactory().createCreateTableToDb(original)); // add it's relationships for (DbRelationship rel : original.getRelationships()) { tokens.add(getTokenFactory().createAddRelationshipToDb(original, rel)); } return tokens; }
boolean isPropagated(DbAttribute attribute) { for (DbRelationship dbRel : attribute.getEntity().getRelationships()) { if (!dbRel.isToMasterPK()) { continue; } for (DbJoin join : dbRel.getJoins()) { if (attribute.getName().equals(join.getSourceName())) { return true; } } } return false; } }
public ValidationResult visitDbEntity(DbEntity entity) { dbEntityValidator.validate(entity, validationResult); for (DbAttribute attr : entity.getAttributes()) { visitDbAttribute(attr); } for (DbRelationship rel : entity.getRelationships()) { visitDbRelationship(rel); } return validationResult; }
public void createReversRelationship(DbEntity eSourse, DbEntity eTarget) { InferredRelationship myir = new InferredRelationship(); for (DbRelationship relationship : eSourse.getRelationships()) { for (DbJoin join : relationship.getJoins()) { if (((DbEntity) join.getSource().getEntity()).equals(eSourse) && ((DbEntity) join.getTarget().getEntity()).equals(eTarget)) { return; } } } myir.setSource(eSourse); myir.setTarget(eTarget); inferredRelationships.add(myir); }
/** * Create reverse DbRelationships that were not created so far, since Cayenne requires * them. * * @since 1.0.5 */ protected void makeReverseDbRelationships(DbEntity dbEntity) { if (dbEntity == null) { throw new NullPointerException( "Attempt to create reverse relationships for the null DbEntity."); } // iterate over a copy of the collection, since in case of // reflexive relationships, we may modify source entity relationship map Collection clone = new ArrayList(dbEntity.getRelationships()); Iterator it = clone.iterator(); while (it.hasNext()) { DbRelationship relationship = (DbRelationship) it.next(); if (relationship.getReverseRelationship() == null) { DbRelationship reverse = relationship.createReverseRelationship(); String name = NamedObjectFactory.createName(DbRelationship.class, reverse .getSourceEntity(), relationship.getName() + "Reverse"); reverse.setName(name); relationship.getTargetEntity().addRelationship(reverse); } } }
/** * Removes attribute from the entity, removes any relationship joins * containing this attribute. Does nothing if the attribute name is not * found. * * @see org.apache.cayenne.map.Entity#removeAttribute(String) */ @Override public void removeAttribute(String attrName) { Attribute attr = getAttribute(attrName); if (attr == null) { return; } DataMap map = getDataMap(); if (map != null) { for (DbEntity ent : map.getDbEntities()) { for (DbRelationship relationship : ent.getRelationships()) { Iterator<DbJoin> joins = relationship.getJoins().iterator(); while (joins.hasNext()) { DbJoin join = joins.next(); if (join.getSource() == attr || join.getTarget() == attr) { joins.remove(); } } } } } super.removeAttribute(attrName); this.dbAttributeRemoved(new AttributeEvent(this, attr, this, MapEvent.REMOVE)); }
/** * Updates missing mapping artifacts that can be guessed from other mapping * information. This implementation creates missing reverse relationships, * marking newly created relationships as "runtime". * * @since 3.0 */ public void applyDBLayerDefaults() { // connect DB layer for (DataMap map : getDataMaps()) { for (DbEntity entity : map.getDbEntities()) { // iterate by copy to avoid concurrency modification errors on // reflexive relationships DbRelationship[] relationships = entity.getRelationships().toArray( new DbRelationship[entity.getRelationships().size()]); for (DbRelationship relationship : relationships) { if (relationship.getReverseRelationship() == null) { DbRelationship reverse = relationship.createReverseRelationship(); Entity targetEntity = reverse.getSourceEntity(); reverse.setName(getUniqueRelationshipName(targetEntity)); reverse.setRuntime(true); targetEntity.addRelationship(reverse); logger.info("added runtime complimentary DbRelationship from " + targetEntity.getName() + " to " + reverse.getTargetEntityName()); } } } } }
/** * Returns <code>true</code> if the DB column represented by this attribute * is a foreign key, referencing another table. * * @since 1.1 */ public boolean isForeignKey() { String name = getName(); if (name == null) { // won't be able to match joins... return false; } for (DbRelationship relationship : getEntity().getRelationships()) { for (DbJoin join : relationship.getJoins()) { if (name.equals(join.getSourceName())) { DbAttribute target = join.getTarget(); if (target != null && target.isPrimaryKey()) { return true; } } } } return false; }
/** * Create reverse DbRelationships that were not created so far, since * Cayenne requires them. * * @since 1.0.5 */ protected void makeReverseDbRelationships(DbEntity dbEntity) { if (dbEntity == null) { throw new NullPointerException("Attempt to create reverse relationships for the null DbEntity."); } // iterate over a copy of the collection, since in case of // reflexive relationships, we may modify source entity relationship map for (DbRelationship relationship : new ArrayList<>(dbEntity.getRelationships())) { if (relationship.getReverseRelationship() == null) { DbRelationship reverse = relationship.createReverseRelationship(); reverse.setName(NameBuilder.builder(reverse, reverse.getSourceEntity()) // TODO: we can do better with ObjectNameGenerator .baseName(relationship.getName() + "Reverse") .name()); relationship.getTargetEntity().addRelationship(reverse); } } }
private boolean shouldAddToObjEntity(ObjEntity entity, DbAttribute dbAttribute, Collection<DbRelationship> incomingRels) { if (dbAttribute.getName() == null || entity.getAttributeForDbAttribute(dbAttribute) != null) { return false; } boolean addMeaningfulPK = meaningfulPKsFilter.isIncluded(entity.getDbEntityName()); if (dbAttribute.isPrimaryKey()) { return addMeaningfulPK; } // check FK's if(isFK(dbAttribute, dbAttribute.getEntity().getRelationships(), true)) { return false; } // check incoming relationships return !isFK(dbAttribute, incomingRels, false); }
for (DbRelationship comparisonRelationship : entity.getRelationships()) { if (relationship != comparisonRelationship) { String comparisonDbRelationshipPath =
private void searchInDbEntities(Pattern pattern, List<SearchResultEntry> result, DataMap dataMap) { for (DbEntity ent : dataMap.getDbEntities()) { if (match(ent.getName(), pattern)) { result.add(new SearchResultEntry(ent, ent.getName())); } for (DbAttribute attr : ent.getAttributes()) { if (match(attr.getName(), pattern)) { result.add(new SearchResultEntry(attr, ent.getName() + "." + attr.getName())); } } for (DbRelationship rel : ent.getRelationships()) { if (match(rel.getName(), pattern)) { result.add(new SearchResultEntry(rel, ent.getName() + "." + rel.getName())); } } checkCatalogOrSchema(pattern, result, ent, ent.getCatalog()); checkCatalogOrSchema(pattern, result, ent, ent.getSchema()); } }
for (DbRelationship relationship : dbe.getRelationships()) { if (relationship.getTargetEntity() == this) { relationship.setTargetEntityName(newName);
.getRelationships()); for (DbRelationship dbRelationship : dbRelationships) { for (DbJoin join : dbRelationship.getJoins()) {