/** tests the PB.retrieveAllReferences() feature */ public void testRetrieveAllReferences() { String name = "testRetrieveAllReferences_" + System.currentTimeMillis(); // ensure there is an item to find Article tmpArticle = createArticle(name); ProductGroup pg = createProductGroup(name); tmpArticle.setProductGroup(pg); broker.beginTransaction(); broker.store(pg); broker.store(tmpArticle); broker.commitTransaction(); Identity tmpOID = broker.serviceIdentity().buildIdentity(tmpArticle); broker.clearCache(); ObjectReferenceDescriptor ord = null; try { // switch to shallow retrieval ClassDescriptor cld = broker.getClassDescriptor(Article.class); ord = (ObjectReferenceDescriptor) cld.getObjectReferenceDescriptors().get(0); ord.setCascadeRetrieve(false); Article article = (Article) broker.getObjectByIdentity(tmpOID); assertNull("now reference should be null", article.getProductGroup()); // now force loading: broker.retrieveAllReferences(article); assertNotNull("now reference should NOT be null", article.getProductGroup()); // clean up cld ord.setCascadeRetrieve(true); } finally { // restore old value if (ord != null) ord.setCascadeRetrieve(true); } }
/** * @see * org.kuali.rice.krad.service.PersistenceStructureService#getBusinessObjectAttributeClass(java.lang.Class, * java.lang.String) */ public Class<? extends PersistableBusinessObjectExtension> getBusinessObjectAttributeClass( Class<? extends PersistableBusinessObject> clazz, String attributeName) { String baseAttributeName = attributeName; String subAttributeString = null; if (attributeName.contains(".")) { baseAttributeName = attributeName.substring(0, attributeName.indexOf('.')); subAttributeString = attributeName.substring(attributeName.indexOf('.') + 1); } // Legacy OJB Class attributeClassLegacy = null; ClassDescriptor classDescriptor = null; try { classDescriptor = this.getClassDescriptor(clazz); } catch (ClassNotPersistableException e) { LOG.warn("Class descriptor for " + clazz.getName() + "was not found"); } ObjectReferenceDescriptor refDescriptor = null; if (classDescriptor != null) { refDescriptor = classDescriptor.getObjectReferenceDescriptorByName(baseAttributeName); } if (refDescriptor != null) { attributeClassLegacy = refDescriptor.getItemClass(); } // recurse if necessary if (subAttributeString != null) { attributeClassLegacy = getBusinessObjectAttributeClass(attributeClassLegacy, subAttributeString); } return attributeClassLegacy; }
public void testShallowAndDeepRetrieval() throws Exception { String name = "testShallowAndDeepRetrieval_" + System.currentTimeMillis(); ObjectReferenceDescriptor ord = null; try { // prepare test, create article with ProductGroup Article tmpArticle = createArticle(name); ProductGroup pg = createProductGroup(name); tmpArticle.setProductGroup(pg); pg.add(tmpArticle); broker.beginTransaction(); // in repository Article 1:1 refererence to PG hasn't enabled auto-update, // so first store the PG. PG has enabled auto-update and will store the // article automatic broker.store(pg); broker.commitTransaction(); // after insert we can build the Article identity Identity tmpOID = broker.serviceIdentity().buildIdentity(tmpArticle); broker.clearCache(); // switch to shallow retrieval ClassDescriptor cld = broker.getClassDescriptor(Article.class); ord = cld.getObjectReferenceDescriptorByName("productGroup"); ord.setCascadeRetrieve(false); Article article = (Article) broker.getObjectByIdentity(tmpOID); assertNull("now reference should be null", article.getProductGroup()); // now switch to deep retrieval ord.setCascadeRetrieve(true); // should work without setting cld // broker.setClassDescriptor(cld); broker.clearCache(); article = (Article) broker.getObjectByIdentity(tmpOID); assertNotNull("now reference should NOT be null", article.getProductGroup()); } finally { // restore old value if (ord != null) ord.setCascadeRetrieve(true); } }
/** tests the PB.retrieveReference() feature */ public void testRetrieveReference() throws Exception { String name = "testRetrieveReference_" + System.currentTimeMillis(); // ensure there is an item to find Article tmpArticle = createArticle(name); ProductGroup pg = createProductGroup(name); tmpArticle.setProductGroup(pg); broker.beginTransaction(); broker.store(pg); broker.store(tmpArticle); broker.commitTransaction(); Identity tmpOID = broker.serviceIdentity().buildIdentity(tmpArticle); broker.clearCache(); ObjectReferenceDescriptor ord = null; try { // switch to shallow retrieval ClassDescriptor cld = broker.getClassDescriptor(Article.class); // article only has one ord ord = cld.getObjectReferenceDescriptorByName("productGroup"); ord.setCascadeRetrieve(false); Article article = (Article) broker.getObjectByIdentity(tmpOID); assertNull("now reference should be null", article.getProductGroup()); // now force loading: broker.retrieveReference(article, "productGroup"); assertNotNull("now reference should NOT be null", article.getProductGroup()); // repair cld ord.setCascadeRetrieve(true); // should work without setting cld // broker.setClassDescriptor(cld); } finally { // restore old value if (ord != null) ord.setCascadeRetrieve(true); } }
@Override public List<DataObjectRelationship> getRelationshipsTo(Class persistableClass) throws ClassNotPersistableException { if (!isPersistable(persistableClass)) { throw new ClassNotPersistableException(persistableClass.getName() + " is not persistable"); } final List<DataObjectRelationship> relationships = new ArrayList<>(); @SuppressWarnings("unchecked") final Set<Map.Entry<String, ClassDescriptor>> entries = (Set<Map.Entry<String, ClassDescriptor>>) getDescriptorRepository().getDescriptorTable().entrySet(); for (Map.Entry<String, ClassDescriptor> entry : entries) { @SuppressWarnings("unchecked") final Collection<ObjectReferenceDescriptor> references = entry.getValue().getObjectReferenceDescriptors(); if (references != null) { for (ObjectReferenceDescriptor reference : references) { if (reference.getItemClass().equals(persistableClass)) { final DataObjectRelationship relationship = new DataObjectRelationship( entry.getValue().getClassOfObject(), reference.getAttributeName(), reference.getItemClass()); final Map<String, String> pToC = new HashMap<>(); for (int i = 0; i < reference.getForeignKeyFields().size(); i++) { final String fkField = (String) reference.getForeignKeyFields().get(i); pToC.put( fkField, getDescriptorRepository() .getDescriptorFor(reference.getItemClass()) .getPkFields()[i] .getAttributeName()); } relationship.setParentToChildReferences(pToC); relationships.add(relationship); } } } } return relationships; }
/** * gets the annotation but also adds an import in the process if a Convert annotation is required. */ @Override protected NodeData getAnnotationNodes( String enclosingClass, String fieldName, String mappedClass) { final ObjectReferenceDescriptor ord = OjbUtil.findObjectReferenceDescriptor(mappedClass, fieldName, descriptorRepositories); if (ord != null) { final List<MemberValuePair> pairs = new ArrayList<MemberValuePair>(); final Collection<ImportDeclaration> additionalImports = new ArrayList<ImportDeclaration>(); final Collection<String> fks = ord.getForeignKeyFields(); if (fks == null || fks.isEmpty()) { LOG.error( ResolverUtil.logMsgForField(enclosingClass, fieldName, mappedClass) + " field has a reference descriptor for " + fieldName + " but does not have any foreign keys configured"); return null; } final Collection<String> pks = OjbUtil.getPrimaryKeyNames(mappedClass, descriptorRepositories); if (!(pks.size() == fks.size() && pks.containsAll(fks))) { final String className = ord.getItemClassName(); if (StringUtils.isBlank(className)) { LOG.error( ResolverUtil.logMsgForField(enclosingClass, fieldName, mappedClass) + " field has a reference descriptor for " + fieldName + " but does not class name attribute"); } else { final String shortClassName = ClassUtils.getShortClassName(className); final String packageName = ClassUtils.getPackageName(className); pairs.add(new MemberValuePair("targetEntity", new NameExpr(shortClassName + ".class"))); additionalImports.add( new ImportDeclaration( new QualifiedNameExpr(new NameExpr(packageName), shortClassName), false, false)); } final boolean proxy = ord.isLazy(); if (proxy) { pairs.add(new MemberValuePair("fetch", new NameExpr("FetchType.LAZY"))); additionalImports.add( new ImportDeclaration( new QualifiedNameExpr(new NameExpr(PACKAGE), "FetchType"), false, false)); } final boolean refresh = ord.isRefresh(); if (refresh) { LOG.error( ResolverUtil.logMsgForField(enclosingClass, fieldName, mappedClass) + " field has refresh set to " + refresh + ", unsupported conversion to @OneToOne attributes"); } final List<Expression> cascadeTypes = new ArrayList<Expression>(); final boolean autoRetrieve = ord.getCascadeRetrieve(); if (autoRetrieve) { cascadeTypes.add(new NameExpr("CascadeType.REFRESH")); } else { // updated default logging - false would result no additional annotations if (LOG.isDebugEnabled()) { LOG.debug( ResolverUtil.logMsgForField(enclosingClass, fieldName, mappedClass) + " field has auto-retrieve set to " + autoRetrieve + ", unsupported conversion to CascadeType"); } } final int autoDelete = ord.getCascadingDelete(); if (autoDelete == ObjectReferenceDescriptor.CASCADE_NONE) { // updated default logging - none would result no additional annotations if (LOG.isDebugEnabled()) { LOG.debug( ResolverUtil.logMsgForField(enclosingClass, fieldName, mappedClass) + " field has auto-delete set to none, unsupported conversion to CascadeType"); } } else if (autoDelete == ObjectReferenceDescriptor.CASCADE_LINK) { LOG.warn( ResolverUtil.logMsgForField(enclosingClass, fieldName, mappedClass) + " field has auto-delete set to link, unsupported conversion to CascadeType"); } else if (autoDelete == ObjectReferenceDescriptor.CASCADE_OBJECT) { cascadeTypes.add(new NameExpr("CascadeType.REMOVE")); } else { LOG.error( ResolverUtil.logMsgForField(enclosingClass, fieldName, mappedClass) + " field has auto-delete set to an invalid value"); } final int autoUpdate = ord.getCascadingStore(); if (autoUpdate == ObjectReferenceDescriptor.CASCADE_NONE) { // updated default logging - none would result no additional annotations if (LOG.isDebugEnabled()) { LOG.debug( ResolverUtil.logMsgForField(enclosingClass, fieldName, mappedClass) + " field has auto-update set to none, unsupported conversion to CascadeType"); } } else if (autoUpdate == ObjectReferenceDescriptor.CASCADE_LINK) { LOG.warn( ResolverUtil.logMsgForField(enclosingClass, fieldName, mappedClass) + " field has auto-update set to link, unsupported conversion to CascadeType"); } else if (autoUpdate == ObjectReferenceDescriptor.CASCADE_OBJECT) { cascadeTypes.add(new NameExpr("CascadeType.PERSIST")); } else { LOG.error( ResolverUtil.logMsgForField(enclosingClass, fieldName, mappedClass) + " field has auto-update set to an invalid value"); } if (!cascadeTypes.isEmpty()) { pairs.add(new MemberValuePair("cascade", new ArrayInitializerExpr(cascadeTypes))); additionalImports.add( new ImportDeclaration( new QualifiedNameExpr(new NameExpr(PACKAGE), "CascadeType"), false, false)); } return new NodeData( new NormalAnnotationExpr(new NameExpr(SIMPLE_NAME), pairs), new ImportDeclaration( new QualifiedNameExpr(new NameExpr(PACKAGE), SIMPLE_NAME), false, false), additionalImports); } } return null; }