/** * Returns whether this primary key can be fetched now. * * @param pk the PrimaryKey * @param cld the ClassDescriptor that the PrimaryKey is in * @param pksNotDone a Map of pks not yet fetched * @return a boolean */ protected boolean canDoPkNow(PrimaryKey pk, ClassDescriptor cld, Map<PrimaryKey, ClassDescriptor> pksNotDone) { boolean canDoPkNow = true; Iterator<String> fieldNameIter = pk.getFieldNames().iterator(); while (fieldNameIter.hasNext() && canDoPkNow) { String fieldName = fieldNameIter.next(); FieldDescriptor fd = cld.getFieldDescriptorByName(fieldName); if (fd.isReference()) { Iterator<ClassDescriptor> otherCldIter = pksNotDone.values().iterator(); while (otherCldIter.hasNext() && canDoPkNow) { ClassDescriptor otherCld = otherCldIter.next(); Class<? extends FastPathObject> fieldClass = ((ReferenceDescriptor) fd) .getReferencedClassDescriptor().getType(); if (otherCld.getType().isAssignableFrom(fieldClass) || fieldClass.isAssignableFrom(otherCld.getType())) { canDoPkNow = false; } } } } return canDoPkNow; }
for (ReferenceDescriptor merg : merge.getReferenceDescriptors()) { ReferenceDescriptor orig = original.getReferenceDescriptorByName(merg.getName()); if (orig != null) { if (merg.getReverseReferenceFieldName() != null && orig.getReverseReferenceFieldName() == null) { removeFieldDescriptor(newSet, orig.getName()); newSet.add(cloneReferenceDescriptor(merg)); continue; if (!merg.getReferencedClassName().equals(orig.getReferencedClassName())) { String fldName = original.getName() + "." + orig.getName(); throw new ModelMergerException("type mismatch between reference types: " + fldName + ":" + merg.getReferencedClassName() + " != " + fldName + ":" + orig.getReferencedClassName()); if (!StringUtils.equals(merg.getReverseReferenceFieldName(), orig.getReverseReferenceFieldName())) { String fldName = original.getName() + "." + orig.getName(); throw new ModelMergerException("mismatch between reverse reference field name: " + fldName + "<-" + merg.getReverseReferenceFieldName() + " != " + fldName + "<-" + orig.getReverseReferenceFieldName());
private static ReferenceDescriptor cloneReferenceDescriptor(ReferenceDescriptor ref) { return new ReferenceDescriptor(ref.getName(), ref.getReferencedClassName(), ref.getReverseReferenceFieldName()); }
/** * Generates code for a single reference. * * @param ref the ReferenceDescriptor * @param field true if the class should have the associated field, or false if the field is in * the superclass * @return java code */ protected String generate(ReferenceDescriptor ref, boolean field) { StringBuffer sb = new StringBuffer(); if (field) { sb.append(INDENT + "// Ref: " + ref.getClassDescriptor().getName() + "." + ref.getName() + ENDL) .append(INDENT) .append("protected org.intermine.model.InterMineObject ") .append(ref.getName()) .append(";" + ENDL); } sb.append(generateGetSet(ref, field)) .append(ENDL); return sb.toString(); }
String arg1Alias = state.getFieldToAlias(arg1.getQueryClass()).get(arg1Desc.getName()); if (c.getOp().equals(ConstraintOp.IS_NULL) || c.getOp().equals(ConstraintOp .IS_NOT_NULL)) { .IS_NOT_NULL)) { addNullPhrase(state, buffer, c, schema, arg1, arg1Desc); } else if (arg1Desc.relationType() == FieldDescriptor.ONE_N_RELATION) { if (arg2 == null) { ReferenceDescriptor reverse = arg1Desc.getReverseReferenceDescriptor(); .getClassDescriptor()); state.addToFrom(DatabaseUtil.getTableName(tableMaster) + " AS " + indirectTableAlias); if (schema.isTruncated(tableMaster)) { buffer.append(indirectTableAlias + ".tableclass = '" + reverse.getClassDescriptor().getType().getName() + "' AND "); } else { String arg2Alias = state.getFieldToAlias(arg2).get(arg1Desc .getReverseReferenceDescriptor().getName()); if (arg1Qc != null) { queryClassToString(buffer, arg1Qc, q, schema, ID_ONLY, state);
ClassDescriptor cld = desc.getClassDescriptor(); table.addRow(new String[] {desc.getName(), terseClass(desc.getReferencedClassName()), (cld == this ? "" : "from " + terseClass(cld.getName()))});
throw new MetaDataException("Unable to find named reverse reference '" + reverseRefName + "' in class " + referencedClassDesc.getName() + " while processing: " + getClassDescriptor().getName() + "." + getName()); if (reverseRefDesc.getReverseReferenceFieldName() != null) { if (!reverseRefDesc.getReverseReferenceFieldName().equals(this.name)) { modelSet = true; throw new NonFatalMetaDataException("Reverse reference names do not match: " + reverseRefDesc.getReverseReferenceFieldName() + " and " + this.name + " (" + this.cld.getName() + ": " + this.toString() + ", " + referencedType + ": " + reverseRefDesc.toString() + ")"); + this.cld.getName() + ": " + this.toString() + ", " + referencedType + ": " + reverseRefDesc.toString());
private Set<ReferenceDescriptor> getReferences() { Set<ReferenceDescriptor> references = new HashSet<ReferenceDescriptor>(); ReferenceDescriptor rfd1 = new ReferenceDescriptor("rfd1", "String", "reverse1"); ReferenceDescriptor rfd2 = new ReferenceDescriptor("rfd2", "Integer", "reverse2"); references.add(rfd1); references.add(rfd2); return references; }
public void testReverseReferenceValid() throws Exception { // rfd1 in Class1 points to Class2, rfd2 in Class2 points to Class1 ReferenceDescriptor rfd1 = new ReferenceDescriptor("rfd1", "package.name.Class2", "rfd2"); ReferenceDescriptor rfd2 = new ReferenceDescriptor("rfd2", "package.name.Class1", "rfd1"); Set<ReferenceDescriptor> refs1 = Collections.singleton(rfd1); Set<ReferenceDescriptor> refs2 = Collections.singleton(rfd2); ClassDescriptor cld1 = new ClassDescriptor("package.name.Class1", null, false, ClassDescriptorFactory.NO_ATTRS, refs1, ClassDescriptorFactory.NO_COLLS); ClassDescriptor cld2 = new ClassDescriptor("package.name.Class2", null, false, ClassDescriptorFactory.NO_ATTRS, refs2, ClassDescriptorFactory.NO_COLLS); new Model("model", "package.name", Arrays.asList(cld1, cld2)); try { ReferenceDescriptor rfdReverse = rfd1.getReverseReferenceDescriptor(); assertEquals(rfd2, rfdReverse); assertEquals(cld1, rfdReverse.getReferencedClassDescriptor()); } catch (IllegalStateException e) { fail("Should have returned reverse ReferenceDescriptor"); } }
/** * Returns a ClassDescriptor for the object referenced by this field. * @return ClassDescriptor for the referenced object * @throws IllegalStateException if model has not been set */ public ClassDescriptor getReferencedClassDescriptor() { if (!modelSet) { throw new IllegalStateException("This ReferenceDescriptor (" + getName() + ") is not yet part of a metadata Model"); } return referencedClassDesc; }
LOG.info("Querying for empty: " + cld.getUnqualifiedName() + "." + ref.getName()); Query q = new Query(); q.setDistinct(false); QueryClass qc2 = new QueryClass(ref.getReferencedClassDescriptor().getType()); QueryReference qd; if (ref instanceof CollectionDescriptor) { qd = new QueryCollectionReference(qc1, ref.getName()); } else { qd = new QueryObjectReference(qc1, ref.getName()); boolean empty = !results.iterator().hasNext(); LOG.info("Query for empty " + cld.getUnqualifiedName() + "." + ref.getName() + " took " + (System.currentTimeMillis() - startTime) + "ms."); return empty;
public void testReferencedClassNotSet() throws Exception { ReferenceDescriptor rfd1 = new ReferenceDescriptor("rfd1", "Class2", null); Set<ReferenceDescriptor> references = Collections.singleton(rfd1); // cld1 has a ReferenceDescriptor that points to Class2 new ClassDescriptor("Class1", null, false, ClassDescriptorFactory.NO_ATTRS, references, ClassDescriptorFactory.NO_COLLS); new ClassDescriptor("Class2", null, false, ClassDescriptorFactory.NO_ATTRS, ClassDescriptorFactory.NO_REFS, ClassDescriptorFactory.NO_COLLS); try { rfd1.getReferencedClassDescriptor(); fail("Expected IllegalStateException, model has not yet been set"); } catch (IllegalStateException e) { } }
if (arg1Desc.relationType() == FieldDescriptor.ONE_N_RELATION) { ReferenceDescriptor reverse = arg1Desc.getReverseReferenceDescriptor(); .getClassDescriptor()); buffer.append(DatabaseUtil.getTableName(referencedClass) + " AS " + indirectTableAlias); buffer.append(" WHERE " + reverseRefAlias + " = " + arg1Alias); } else if (arg1Desc.relationType() == FieldDescriptor.M_N_RELATION) {
InterMineObject loser = (InterMineObject) dest.getFieldValue(fieldName); ReferenceDescriptor reverseRef = ((ReferenceDescriptor) field) .getReverseReferenceDescriptor(); if (loser != null) { invalidateObjectById(loser.getId()); try { loser.setFieldValue(reverseRef.getName(), null); } catch (NullPointerException e) { throw new NullPointerException("reverseRef must be null: "
if (fieldDescriptor.isReference() || fieldDescriptor.isCollection()) { String referencedClassName = ((ReferenceDescriptor) fieldDescriptor).getReferencedClassName(); if (!TypeUtil.unqualifiedName(referencedClassName) .equals(constraintClassName)) {
ReferenceDescriptor refDesc = (ReferenceDescriptor) schema.getModel() .getFieldDescriptorsForClass(ref.getQcType()).get(ref.getFieldName()); if (refDesc.relationType() == FieldDescriptor.M_N_RELATION) { tablenames.add(DatabaseUtil.getIndirectionTableName((CollectionDescriptor) refDesc)); } else if (cc.getQueryClass() == null) { tablenames.add(DatabaseUtil.getTableName(schema.getTableMaster( refDesc.getReferencedClassDescriptor())));
public void testMultiInheritanceLegalRef() throws Exception { ReferenceDescriptor ref1 = new ReferenceDescriptor("atd1", "package.name.Class2", null); ReferenceDescriptor ref2 = new ReferenceDescriptor("atd1", "package.name.Class2", null); Set<ReferenceDescriptor> refs1 = Collections.singleton(ref1); Set<ReferenceDescriptor> refs2 = Collections.singleton(ref2); ClassDescriptor cld1 = new ClassDescriptor("package.name.Class1", null, true, noAttrs, refs1, noColls); ClassDescriptor cld2 = new ClassDescriptor("package.name.Class2", null, true, noAttrs, refs2, noColls); ClassDescriptor cld3 = makeClass("package.name.Class3", "package.name.Class1 package.name.Class2"); new Model("model", "package.name", Arrays.asList(cld1, cld2, cld3)); ReferenceDescriptor rd = cld3.getReferenceDescriptorByName("atd1", true); assertEquals("package.name.Class2", rd.getReferencedClassName()); }
public void testRelationTypeOneToOne() throws Exception { ReferenceDescriptor ref1 = new ReferenceDescriptor("ref1", "package.name.Class1", "ref2"); ReferenceDescriptor ref2 = new ReferenceDescriptor("ref2", "package.name.Class1", null); ClassDescriptor cld = new ClassDescriptor("package.name.Class1", null, false, ClassDescriptorFactory.NO_ATTRS, Arrays.asList(ref1, ref2), ClassDescriptorFactory.NO_COLLS); new Model("model1", "package.name", Collections.singleton(cld)); assertEquals(FieldDescriptor.ONE_ONE_RELATION, ref1.relationType()); }
ReferenceDescriptor rd = riter.next(); ReferenceDescriptor scdDescriptor = scd.getReferenceDescriptorByName(rd.getName()); if (scdDescriptor != null) { LOG.info("removing reference " + rd.getName() + " redefinition in " + cd.getName() + " (is now defined in " + scd.getName() + ")"); String revName = rd.getReverseReferenceFieldName(); String scdRevFieldName = scdDescriptor.getReverseReferenceFieldName(); if (StringUtils.equals(revName, scdRevFieldName)) { riter.remove(); } else { String message = "replacing the \"" + sup + "." + rd.getName() + "\" reference with " + cd.getName() + "." + rd.getName() + " failed because the reverse references differ"; throw new ModelMergerException(message);
ReferenceDescriptor rd = (ReferenceDescriptor) fd; ReferenceDescriptor rdAlready = (ReferenceDescriptor) fdAlready; String referencedClassName = rd.getReferencedClassName(); String reverseFieldName = rd.getReverseReferenceFieldName(); String alreadyRevFieldName = rdAlready.getReverseReferenceFieldName(); if (!referencedClassName.equals(rdAlready.getReferencedClassName()) || !Util.equals(reverseFieldName, alreadyRevFieldName)) { throw new MetaDataException("Incompatible similarly named fields ("