use of org.datanucleus.metadata.FetchGroupMetaData in project datanucleus-core by datanucleus.
the class FetchGroupManager method createFetchGroup.
/**
* Method to create a new FetchGroup for the class and name.
* <b>Doesn't add it to the internally managed groups.</b>
* @param cls The class
* @param name Name of the group
* @return The FetchGroup
* @param <T> Type that the FetchGroup is for
*/
public <T> FetchGroup<T> createFetchGroup(Class<T> cls, String name) {
// Not present so create a new FetchGroup and add it
FetchGroup<T> fg = new FetchGroup(nucleusCtx, name, cls);
if (name.equals(FetchGroup.DEFAULT)) {
// Special case of wanting to create a group to override the DFG
fg.addCategory(FetchGroup.DEFAULT);
} else {
// Check if this class has a named FetchGroup of this name, so we start from the same members
ClassLoaderResolver clr = nucleusCtx.getClassLoaderResolver(cls.getClassLoader());
AbstractClassMetaData cmd = nucleusCtx.getMetaDataManager().getMetaDataForClass(cls, clr);
if (cmd != null) {
FetchGroupMetaData fgmd = cmd.getFetchGroupMetaData(name);
if (fgmd != null) {
Set<FetchGroupMemberMetaData> fgmmds = fgmd.getMembers();
for (FetchGroupMemberMetaData fgmmd : fgmmds) {
fg.addMember(fgmmd.getName());
if (fgmmd.getRecursionDepth() != 1) {
fg.setRecursionDepth(fgmmd.getName(), fgmmd.getRecursionDepth());
}
}
}
}
}
return fg;
}
use of org.datanucleus.metadata.FetchGroupMetaData in project datanucleus-core by datanucleus.
the class FetchPlanForClass method isToCallPostLoadFetchPlan.
/**
* Whether to call the post load or not.
* Checks if members in actual FetchPlan where not previouly loaded and the post-load is enabled
* in the metadata.
* @param loadedMembers already loaded members
* @return if is to call the postLoad
*/
public boolean isToCallPostLoadFetchPlan(boolean[] loadedMembers) {
BitSet cacheKey = new BitSet(loadedMembers.length);
for (int i = 0; i < loadedMembers.length; i++) {
cacheKey.set(i, loadedMembers[i]);
}
Boolean result = plan.getCachedIsToCallPostLoadFetchPlan(cmd, cacheKey);
if (result == null) {
result = Boolean.FALSE;
int[] fieldsInActualFetchPlan = getMemberNumbers();
for (int i = 0; i < fieldsInActualFetchPlan.length; i++) {
final int fieldNumber = fieldsInActualFetchPlan[i];
String fieldName = cmd.getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber).getFullFieldName();
// if field in actual fetch plan was not previously loaded
if (!loadedMembers[fieldNumber]) {
if (cmd.getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber).isDefaultFetchGroup() && plan.getGroups().contains(FetchPlan.DEFAULT)) {
// to call jdoPostLoad, field must be in default-fetch-group when DFG is active
result = Boolean.TRUE;
} else {
// compute only if necessary, as that's expensive to do
if (cmd.hasFetchGroupWithPostLoad()) {
// field must be in a fetch-group which has post-load set to true
Integer fieldNumberInteger = Integer.valueOf(fieldNumber);
Set<FetchGroupMetaData> fetchGroups = null;
if (fetchGroupsByMemberNumber != null) {
fetchGroups = fetchGroupsByMemberNumber.get(fieldNumberInteger);
}
if (fetchGroups == null) {
fetchGroups = getFetchGroupsForMemberNumber(cmd.getFetchGroupMetaData(), fieldNumber);
// cache those precious results from expensive invocation
if (fetchGroupsByMemberNumber == null) {
fetchGroupsByMemberNumber = new HashMap<Integer, Set<FetchGroupMetaData>>();
}
fetchGroupsByMemberNumber.put(fieldNumberInteger, fetchGroups);
}
for (Iterator it = fetchGroups.iterator(); it.hasNext(); ) {
FetchGroupMetaData fgmd = (FetchGroupMetaData) it.next();
if (fgmd.getPostLoad().booleanValue()) {
result = Boolean.TRUE;
}
}
}
if (plan.dynamicGroups != null) {
Class cls = plan.clr.classForName(cmd.getFullClassName());
for (Iterator<FetchGroup> it = plan.dynamicGroups.iterator(); it.hasNext(); ) {
FetchGroup group = it.next();
Set groupMembers = group.getMembers();
if (group.getType().isAssignableFrom(cls) && groupMembers.contains(fieldName) && group.getPostLoad()) {
result = Boolean.TRUE;
}
}
}
}
}
}
if (result == null) {
result = Boolean.FALSE;
}
plan.cacheIsToCallPostLoadFetchPlan(cmd, cacheKey, result);
}
return result.booleanValue();
}
use of org.datanucleus.metadata.FetchGroupMetaData in project datanucleus-api-jdo by datanucleus.
the class JDOAnnotationReader method processClassAnnotations.
/**
* Method to process the "class" level annotations and create the outline ClassMetaData object.
* Supports classes annotated with @PersistenceCapable, classes annotated with @PersistenceAware, and classes which have neither of those but have @Queries or @Query.
* @param pmd Parent PackageMetaData
* @param cls The class
* @param annotations Annotations for this class
* @param clr ClassLoader resolver
* @return The ClassMetaData/InterfaceMetaData (or null if no annotations)
*/
protected AbstractClassMetaData processClassAnnotations(PackageMetaData pmd, Class cls, AnnotationObject[] annotations, ClassLoaderResolver clr) {
if (annotations == null || annotations.length == 0) {
return null;
}
AbstractClassMetaData cmd = null;
AnnotationObject pcAnnotation = isClassPersistable(annotations);
if (pcAnnotation != null) {
// PersistenceCapable class
cmd = (cls.isInterface()) ? pmd.newInterfaceMetadata(ClassUtils.getClassNameForClass(cls)) : pmd.newClassMetadata(ClassUtils.getClassNameForClass(cls));
cmd.setPersistenceModifier(ClassPersistenceModifier.PERSISTENCE_CAPABLE);
// Process all attributes here in case needed for other annotations
processPersistenceCapableAnnotation(cls, cmd, pcAnnotation.getNameValueMap());
} else if (isClassPersistenceAware(annotations)) {
// PersistenceAware class
cmd = pmd.newClassMetadata(ClassUtils.getClassNameForClass(cls));
cmd.setPersistenceModifier(ClassPersistenceModifier.PERSISTENCE_AWARE);
} else if (doesClassHaveNamedQueries(annotations)) {
// Class with named query specified
cmd = pmd.newClassMetadata(ClassUtils.getClassNameForClass(cls));
cmd.setPersistenceModifier(ClassPersistenceModifier.NON_PERSISTENT);
} else {
// Not involved in the persistence process
return null;
}
// Cater for named queries being specified on a persistence aware, or other class
processNamedQueries(cmd, cls, annotations);
if (cmd.getPersistenceModifier() != ClassPersistenceModifier.PERSISTENCE_CAPABLE) {
// Not persistable, so no further information needed
return cmd;
}
// Class is persistable so process annotations
for (AnnotationObject annotation : annotations) {
String annName = annotation.getName();
if (annName.equals(JDOAnnotationUtils.PERSISTENCE_CAPABLE)) {
// @PersistenceCapable is merged and processed above
continue;
}
Map<String, Object> annotationValues = annotation.getNameValueMap();
if (annName.equals(JDOAnnotationUtils.EMBEDDED_ONLY)) {
cmd.setEmbeddedOnly(true);
} else if (annName.equals(JDOAnnotationUtils.VERSION)) {
VersionStrategy versionStrategy = (VersionStrategy) annotationValues.get("strategy");
String strategy = JDOAnnotationUtils.getVersionStrategyString(versionStrategy);
String indexed = (String) annotationValues.get("indexed");
String column = (String) annotationValues.get("column");
Column[] columns = (Column[]) annotationValues.get("columns");
VersionMetaData vermd = new VersionMetaData();
vermd.setStrategy(strategy);
vermd.setColumnName(column);
vermd.setIndexed(IndexedValue.getIndexedValue(indexed));
if (columns != null && columns.length > 0) {
// Only use the first column
ColumnMetaData colmd = JDOAnnotationUtils.getColumnMetaDataForColumnAnnotation(columns[0]);
vermd.setColumnMetaData(colmd);
}
JDOAnnotationUtils.addExtensionsToMetaData(vermd, (Extension[]) annotationValues.get("extensions"));
vermd.setParent(cmd);
cmd.setVersionMetaData(vermd);
} else if (annName.equals(JDOAnnotationUtils.DATASTORE_IDENTITY)) {
String strategy = JDOAnnotationUtils.getValueGenerationStrategyString((IdGeneratorStrategy) annotationValues.get("strategy"));
String customStrategy = (String) annotationValues.get("customStrategy");
if (!StringUtils.isWhitespace(customStrategy)) {
// User has provided an extension strategy
strategy = customStrategy;
}
String sequence = (String) annotationValues.get("sequence");
String column = (String) annotationValues.get("column");
Column[] columns = (Column[]) annotationValues.get("columns");
IdentityMetaData idmd = new IdentityMetaData();
idmd.setColumnName(column);
idmd.setValueStrategy(ValueGenerationStrategy.getIdentityStrategy(strategy));
idmd.setSequence(sequence);
if (columns != null && columns.length > 0) {
// Only use the first column
ColumnMetaData colmd = JDOAnnotationUtils.getColumnMetaDataForColumnAnnotation(columns[0]);
idmd.setColumnMetaData(colmd);
}
JDOAnnotationUtils.addExtensionsToMetaData(idmd, (Extension[]) annotationValues.get("extensions"));
idmd.setParent(cmd);
cmd.setIdentityMetaData(idmd);
} else if (annName.equals(JDOAnnotationUtils.PRIMARY_KEY)) {
String pkName = (String) annotationValues.get("name");
String pkColumn = (String) annotationValues.get("column");
Column[] columns = (Column[]) annotationValues.get("columns");
PrimaryKeyMetaData pkmd = new PrimaryKeyMetaData();
pkmd.setName(pkName);
pkmd.setColumnName(pkColumn);
if (columns != null && columns.length > 0) {
for (Column column : columns) {
pkmd.addColumn(JDOAnnotationUtils.getColumnMetaDataForColumnAnnotation(column));
}
}
JDOAnnotationUtils.addExtensionsToMetaData(pkmd, (Extension[]) annotationValues.get("extensions"));
pkmd.setParent(cmd);
cmd.setPrimaryKeyMetaData(pkmd);
} else if (annName.equals(JDOAnnotationUtils.JOINS)) {
Join[] js = (Join[]) annotationValues.get("value");
if (js != null && js.length > 0) {
for (Join join : js) {
JoinMetaData joinmd = cmd.newJoinMetaData();
joinmd.setTable(join.table());
joinmd.setColumnName(join.column());
joinmd.setIndexed(IndexedValue.getIndexedValue(join.indexed()));
joinmd.setOuter(MetaDataUtils.getBooleanForString(join.outer(), false));
joinmd.setUnique(join.unique());
joinmd.setDeleteAction(JDOAnnotationUtils.getForeignKeyActionString(join.deleteAction()));
JDOAnnotationUtils.addExtensionsToMetaData(joinmd, join.extensions());
}
}
} else if (annName.equals(JDOAnnotationUtils.JOIN)) {
JoinMetaData joinmd = cmd.newJoinMetaData();
joinmd.setTable((String) annotationValues.get("table"));
joinmd.setColumnName((String) annotationValues.get("column"));
joinmd.setIndexed(IndexedValue.getIndexedValue((String) annotationValues.get("indexed")));
joinmd.setOuter(MetaDataUtils.getBooleanForString((String) annotationValues.get("outer"), false));
joinmd.setUnique((String) annotationValues.get("unique"));
joinmd.setDeleteAction(((ForeignKeyAction) annotationValues.get("deleteAction")).toString());
JDOAnnotationUtils.addExtensionsToMetaData(joinmd, (Extension[]) annotationValues.get("extensions"));
} else if (annName.equals(JDOAnnotationUtils.INHERITANCE)) {
String strategy = JDOAnnotationUtils.getInheritanceStrategyString((InheritanceStrategy) annotationValues.get("strategy"));
String customStrategy = (String) annotationValues.get("customStrategy");
if (!StringUtils.isWhitespace(customStrategy)) {
// User has provided an extension strategy
strategy = customStrategy;
}
InheritanceMetaData inhmd = cmd.getInheritanceMetaData();
if (inhmd == null) {
inhmd = cmd.newInheritanceMetadata();
}
inhmd.setStrategy(strategy);
} else if (annName.equals(JDOAnnotationUtils.DISCRIMINATOR)) {
DiscriminatorStrategy discriminatorStrategy = (DiscriminatorStrategy) annotationValues.get("strategy");
String strategy = JDOAnnotationUtils.getDiscriminatorStrategyString(discriminatorStrategy);
String column = (String) annotationValues.get("column");
String indexed = (String) annotationValues.get("indexed");
String value = (String) annotationValues.get("value");
Column[] columns = (Column[]) annotationValues.get("columns");
InheritanceMetaData inhmd = cmd.getInheritanceMetaData();
if (inhmd == null) {
inhmd = cmd.newInheritanceMetadata();
}
DiscriminatorMetaData dismd = inhmd.newDiscriminatorMetadata();
dismd.setColumnName(column);
dismd.setValue(value);
dismd.setStrategy(strategy);
dismd.setIndexed(indexed);
if (columns != null && columns.length > 0) {
// Only use the first column
ColumnMetaData colmd = JDOAnnotationUtils.getColumnMetaDataForColumnAnnotation(columns[0]);
dismd.setColumnMetaData(colmd);
}
} else if (annName.equals(JDOAnnotationUtils.FETCHPLANS)) {
FileMetaData filemd = (FileMetaData) pmd.getParent();
FetchPlan[] plans = (FetchPlan[]) annotationValues.get("value");
for (FetchPlan plan : plans) {
FetchPlanMetaData fpmd = filemd.newFetchPlanMetadata(plan.name());
fpmd.setFetchSize(plan.fetchSize());
fpmd.setMaxFetchDepth(plan.maxFetchDepth());
int numGroups = plan.fetchGroups().length;
for (int k = 0; k < numGroups; k++) {
fpmd.addFetchGroup(new FetchGroupMetaData(plan.fetchGroups()[k]));
}
}
} else if (annName.equals(JDOAnnotationUtils.FETCHPLAN)) {
FileMetaData filemd = (FileMetaData) pmd.getParent();
FetchPlanMetaData fpmd = filemd.newFetchPlanMetadata((String) annotationValues.get("name"));
fpmd.setFetchSize(((Integer) annotationValues.get("fetchSize")).intValue());
fpmd.setMaxFetchDepth(((Integer) annotationValues.get("maxFetchDepth")).intValue());
String[] fpFetchGroups = (String[]) annotationValues.get("fetchGroups");
for (String fpFetchGroup : fpFetchGroups) {
fpmd.addFetchGroup(new FetchGroupMetaData(fpFetchGroup));
}
} else if (annName.equals(JDOAnnotationUtils.FETCHGROUPS)) {
FetchGroup[] groups = (FetchGroup[]) annotationValues.get("value");
for (FetchGroup group : groups) {
FetchGroupMetaData fgmd = cmd.newFetchGroupMetaData(group.name());
if (!StringUtils.isWhitespace(group.postLoad())) {
fgmd.setPostLoad(Boolean.valueOf(group.postLoad()));
}
int numFields = group.members().length;
for (int k = 0; k < numFields; k++) {
FetchGroupMemberMetaData fgmmd = new FetchGroupMemberMetaData(fgmd, group.members()[k].name());
fgmmd.setRecursionDepth(group.members()[k].recursionDepth());
fgmd.addMember(fgmmd);
}
int numGroups = group.fetchGroups().length;
for (int k = 0; k < numGroups; k++) {
fgmd.addFetchGroup(new FetchGroupMetaData(group.fetchGroups()[k]));
}
}
} else if (annName.equals(JDOAnnotationUtils.FETCHGROUP)) {
FetchGroupMetaData fgmd = cmd.newFetchGroupMetaData((String) annotationValues.get("name"));
String postLoadStr = (String) annotationValues.get("postLoad");
if (!StringUtils.isWhitespace(postLoadStr)) {
fgmd.setPostLoad(Boolean.valueOf(postLoadStr));
}
Persistent[] fields = (Persistent[]) annotationValues.get("members");
if (fields != null) {
for (Persistent field : fields) {
FetchGroupMemberMetaData fgmmd = new FetchGroupMemberMetaData(fgmd, field.name());
fgmmd.setRecursionDepth(field.recursionDepth());
fgmd.addMember(fgmmd);
}
}
} else if (annName.equals(JDOAnnotationUtils.SEQUENCE)) {
String seqName = (String) annotationValues.get("name");
String seqStrategy = JDOAnnotationUtils.getSequenceStrategyString((SequenceStrategy) annotationValues.get("strategy"));
String seqSeq = (String) annotationValues.get("datastoreSequence");
Class seqFactory = (Class) annotationValues.get("factoryClass");
String seqFactoryClassName = null;
if (seqFactory != null && seqFactory != void.class) {
seqFactoryClassName = seqFactory.getName();
}
Integer seqSize = (Integer) annotationValues.get("allocationSize");
Integer seqStart = (Integer) annotationValues.get("initialValue");
if (StringUtils.isWhitespace(seqName)) {
throw new InvalidClassMetaDataException("044155", cmd.getFullClassName());
}
SequenceMetaData seqmd = new SequenceMetaData(seqName, seqStrategy);
seqmd.setFactoryClass(seqFactoryClassName);
seqmd.setDatastoreSequence(seqSeq);
if (seqSize != null) {
seqmd.setAllocationSize(seqSize);
}
if (seqStart != null) {
seqmd.setInitialValue(seqStart);
}
JDOAnnotationUtils.addExtensionsToMetaData(seqmd, (Extension[]) annotationValues.get("extensions"));
// Sequence - currently only allowing 1 per class (should really be on the package)
cmd.getPackageMetaData().addSequence(seqmd);
} else if (annName.equals(JDOAnnotationUtils.INDICES)) {
// Multiple Indices for the class
Index[] values = (Index[]) annotationValues.get("value");
if (values != null && values.length > 0) {
for (Index idx : values) {
IndexMetaData idxmd = JDOAnnotationUtils.getIndexMetaData(idx.name(), idx.table(), "" + idx.unique(), idx.members(), idx.columns());
if (idxmd.getNumberOfColumns() == 0 && idxmd.getNumberOfMembers() == 0) {
NucleusLogger.METADATA.warn(Localiser.msg("044204", cls.getName()));
} else {
cmd.addIndex(idxmd);
idxmd.setParent(cmd);
}
}
}
} else if (annName.equals(JDOAnnotationUtils.INDEX)) {
// Single Index for the class
String name = (String) annotationValues.get("name");
String table = (String) annotationValues.get("table");
String unique = (String) annotationValues.get("unique");
String[] members = (String[]) annotationValues.get("members");
Column[] columns = (Column[]) annotationValues.get("columns");
IndexMetaData idxmd = JDOAnnotationUtils.getIndexMetaData(name, table, unique, members, columns);
JDOAnnotationUtils.addExtensionsToMetaData(idxmd, (Extension[]) annotationValues.get("extensions"));
if (idxmd.getNumberOfColumns() == 0 && idxmd.getNumberOfMembers() == 0) {
NucleusLogger.METADATA.warn(Localiser.msg("044204", cls.getName()));
} else {
cmd.addIndex(idxmd);
idxmd.setParent(cmd);
}
} else if (annName.equals(JDOAnnotationUtils.UNIQUES)) {
// Multiple Unique Constraints for the class
Unique[] values = (Unique[]) annotationValues.get("value");
if (values != null && values.length > 0) {
for (Unique uni : values) {
UniqueMetaData unimd = JDOAnnotationUtils.getUniqueMetaData(uni.name(), uni.table(), "" + uni.deferred(), uni.members(), uni.columns());
if (unimd.getNumberOfColumns() == 0 && unimd.getNumberOfMembers() == 0) {
NucleusLogger.METADATA.warn(Localiser.msg("044205", cls.getName()));
} else {
cmd.addUniqueConstraint(unimd);
unimd.setParent(cmd);
}
}
}
} else if (annName.equals(JDOAnnotationUtils.UNIQUE)) {
// Single Unique constraint for the class
String name = (String) annotationValues.get("name");
String table = (String) annotationValues.get("table");
String deferred = (String) annotationValues.get("deferred");
String[] members = (String[]) annotationValues.get("members");
Column[] columns = (Column[]) annotationValues.get("columns");
UniqueMetaData unimd = JDOAnnotationUtils.getUniqueMetaData(name, table, deferred, members, columns);
JDOAnnotationUtils.addExtensionsToMetaData(unimd, (Extension[]) annotationValues.get("extensions"));
if (unimd.getNumberOfColumns() == 0 && unimd.getNumberOfMembers() == 0) {
NucleusLogger.METADATA.warn(Localiser.msg("044205", cls.getName()));
} else {
cmd.addUniqueConstraint(unimd);
unimd.setParent(cmd);
}
} else if (annName.equals(JDOAnnotationUtils.FOREIGNKEYS)) {
// Multiple FKs for the class
ForeignKey[] values = (ForeignKey[]) annotationValues.get("value");
if (values != null && values.length > 0) {
for (ForeignKey fk : values) {
String deleteAction = JDOAnnotationUtils.getForeignKeyActionString(fk.deleteAction());
String updateAction = JDOAnnotationUtils.getForeignKeyActionString(fk.updateAction());
ForeignKeyMetaData fkmd = JDOAnnotationUtils.getFKMetaData(fk.name(), fk.table(), fk.unique(), "" + fk.deferred(), deleteAction, updateAction, fk.members(), fk.columns());
if (fkmd.getNumberOfColumns() == 0 && fkmd.getNumberOfMembers() == 0) {
NucleusLogger.METADATA.warn(Localiser.msg("044206", cls.getName()));
} else {
cmd.addForeignKey(fkmd);
fkmd.setParent(cmd);
}
}
}
} else if (annName.equals(JDOAnnotationUtils.FOREIGNKEY)) {
// Single FK constraint for the class
String name = (String) annotationValues.get("name");
String table = (String) annotationValues.get("table");
String unique = (String) annotationValues.get("unique");
String deferred = (String) annotationValues.get("deferred");
String deleteAction = JDOAnnotationUtils.getForeignKeyActionString((ForeignKeyAction) annotationValues.get("deleteAction"));
String updateAction = JDOAnnotationUtils.getForeignKeyActionString((ForeignKeyAction) annotationValues.get("updateAction"));
String[] members = (String[]) annotationValues.get("members");
Column[] columns = (Column[]) annotationValues.get("columns");
ForeignKeyMetaData fkmd = JDOAnnotationUtils.getFKMetaData(name, table, unique, deferred, deleteAction, updateAction, members, columns);
JDOAnnotationUtils.addExtensionsToMetaData(fkmd, (Extension[]) annotationValues.get("extensions"));
if (fkmd.getNumberOfColumns() == 0 && fkmd.getNumberOfMembers() == 0) {
NucleusLogger.METADATA.warn(Localiser.msg("044206", cls.getName()));
} else {
cmd.addForeignKey(fkmd);
fkmd.setParent(cmd);
}
} else if (annName.equals(JDOAnnotationUtils.COLUMNS)) {
// Unmapped column specification
Column[] cols = (Column[]) annotationValues.get("value");
if (cols != null && cols.length > 0) {
for (Column col : cols) {
ColumnMetaData colmd = JDOAnnotationUtils.getColumnMetaDataForColumnAnnotation(col);
JDOAnnotationUtils.addExtensionsToMetaData(colmd, col.extensions());
colmd.setParent(cmd);
cmd.addUnmappedColumn(colmd);
}
}
} else if (annName.equals(JDOAnnotationUtils.CACHEABLE)) {
String cache = (String) annotationValues.get("value");
if (cache != null && cache.equalsIgnoreCase("false")) {
cmd.setCacheable(false);
}
} else if (annName.equals(JDOAnnotationUtils.EXTENSIONS)) {
Extension[] values = (Extension[]) annotationValues.get("value");
if (values != null && values.length > 0) {
for (Extension ext : values) {
String vendorName = ext.vendorName();
if (StringUtils.isWhitespace(vendorName)) {
throw new InvalidMetaDataException("044160", vendorName, ext.key().toString(), ext.value().toString());
} else if (vendorName.equalsIgnoreCase(MetaData.VENDOR_NAME)) {
cmd.addExtension(ext.key().toString(), ext.value().toString());
}
}
}
} else if (annName.equals(JDOAnnotationUtils.EXTENSION)) {
String vendorName = (String) annotationValues.get("vendorName");
if (StringUtils.isWhitespace(vendorName)) {
throw new InvalidMetaDataException("044160", vendorName, annotationValues.get("key"), annotationValues.get("value"));
} else if (vendorName.equalsIgnoreCase(MetaData.VENDOR_NAME)) {
cmd.addExtension((String) annotationValues.get("key"), (String) annotationValues.get("value"));
}
} else {
if (!annName.equals(JDOAnnotationUtils.PERSISTENCE_AWARE) && !annName.equals(JDOAnnotationUtils.QUERIES) && !annName.equals(JDOAnnotationUtils.QUERY)) {
NucleusLogger.METADATA.debug(Localiser.msg("044203", cls.getName(), annotation.getName()));
}
}
}
NucleusLogger.METADATA.debug(Localiser.msg("044200", cls.getName(), "JDO"));
return cmd;
}
use of org.datanucleus.metadata.FetchGroupMetaData in project datanucleus-api-jdo by datanucleus.
the class JDOMetaDataHelper method getXMLForMetaData.
/**
* Method to convert an internal class/interface metadata into the associated JDO XML metadata.
* @param cmd Metadata for the class/interface
* @param prefix Prefix for the XML (e.g " ")
* @param indent Indent for each block of XML (e.g " ")
* @return The XML
*/
public String getXMLForMetaData(AbstractClassMetaData cmd, String prefix, String indent) {
StringBuilder str = new StringBuilder();
boolean intf = (cmd instanceof InterfaceMetaData);
if (intf) {
str.append(prefix).append("<interface name=\"" + cmd.getName() + "\"");
} else {
str.append(prefix).append("<class name=\"" + cmd.getName() + "\"");
}
if (cmd.getIdentityType() != null) {
str.append("\n").append(prefix).append(" identity-type=\"" + cmd.getIdentityType() + "\"");
}
if (cmd.getObjectidClass() != null) {
str.append("\n").append(prefix).append(" objectid-class=\"" + cmd.getObjectidClass() + "\"");
}
if (!cmd.isRequiresExtent()) {
str.append("\n").append(prefix).append(" requires-extent=\"" + cmd.isRequiresExtent() + "\"");
}
if (cmd.isEmbeddedOnly()) {
str.append("\n").append(prefix).append(" embedded-only=\"" + cmd.isEmbeddedOnly() + "\"");
}
if (cmd.getPersistenceModifier() != null) {
str.append("\n").append(prefix).append(" persistence-modifier=\"" + cmd.getPersistenceModifier() + "\"");
}
if (cmd.getCatalog() != null) {
str.append("\n").append(prefix).append(" catalog=\"" + cmd.getCatalog() + "\"");
}
if (cmd.getSchema() != null) {
str.append("\n").append(prefix).append(" schema=\"" + cmd.getSchema() + "\"");
}
if (cmd.getTable() != null) {
str.append("\n").append(prefix).append(" table=\"" + cmd.getTable() + "\"");
}
if (cmd.isDetachable()) {
str.append("\n").append(prefix).append(" detachable=\"" + cmd.isDetachable() + "\"");
}
str.append(">\n");
// Identity
if (cmd.getIdentityMetaData() != null) {
str.append(getXMLForMetaData(cmd.getIdentityMetaData(), prefix + indent, indent));
}
// PrimaryKey
if (cmd.getPrimaryKeyMetaData() != null) {
str.append(getXMLForMetaData(cmd.getPrimaryKeyMetaData(), prefix + indent, indent));
}
// Inheritance
if (cmd.getInheritanceMetaData() != null) {
str.append(getXMLForMetaData(cmd.getInheritanceMetaData(), prefix + indent, indent));
}
// Add Version
if (cmd.getVersionMetaData() != null) {
str.append(getXMLForMetaData(cmd.getVersionMetaData(), prefix + indent, indent));
}
// Add joins
List<JoinMetaData> joins = cmd.getJoinMetaData();
if (joins != null) {
for (JoinMetaData joinmd : joins) {
str.append(getXMLForMetaData(joinmd, prefix + indent, indent));
}
}
// Add foreign-keys
List<ForeignKeyMetaData> foreignKeys = cmd.getForeignKeyMetaData();
if (foreignKeys != null) {
for (ForeignKeyMetaData fkmd : foreignKeys) {
str.append(getXMLForMetaData(fkmd, prefix + indent, indent));
}
}
// Add indexes
List<IndexMetaData> indexes = cmd.getIndexMetaData();
if (indexes != null) {
for (IndexMetaData idxmd : indexes) {
str.append(getXMLForMetaData(idxmd, prefix + indent, indent));
}
}
// Add unique constraints
List<UniqueMetaData> uniqueConstraints = cmd.getUniqueMetaData();
if (uniqueConstraints != null) {
for (UniqueMetaData unimd : uniqueConstraints) {
str.append(getXMLForMetaData(unimd, prefix + indent, indent));
}
}
// Add members
int numMembers = cmd.getNoOfMembers();
for (int i = 0; i < numMembers; i++) {
AbstractMemberMetaData mmd = cmd.getMetaDataForMemberAtRelativePosition(i);
str.append(getXMLForMetaData(mmd, prefix + indent, indent));
}
// Add unmapped columns
List<ColumnMetaData> unmappedColumns = cmd.getUnmappedColumns();
if (unmappedColumns != null) {
for (int i = 0; i < unmappedColumns.size(); i++) {
ColumnMetaData col = unmappedColumns.get(i);
str.append(getXMLForMetaData(col, prefix + indent, indent));
}
}
// Add queries
QueryMetaData[] queries = cmd.getQueries();
if (queries != null) {
for (int i = 0; i < queries.length; i++) {
QueryMetaData q = queries[i];
str.append(getXMLForMetaData(q, prefix + indent, indent));
}
}
// Add fetch-groups
Set<FetchGroupMetaData> fetchGroups = cmd.getFetchGroupMetaData();
if (fetchGroups != null) {
for (FetchGroupMetaData fgmd : fetchGroups) {
str.append(getXMLForMetaData(fgmd, prefix + indent, indent));
}
}
// Add extensions
processExtensions(cmd.getExtensions(), str, prefix, indent);
if (intf) {
str.append(prefix + "</interface>\n");
} else {
str.append(prefix + "</class>\n");
}
return str.toString();
}
use of org.datanucleus.metadata.FetchGroupMetaData in project datanucleus-api-jdo by datanucleus.
the class JDOMetaDataHelper method getXMLForMetaData.
public String getXMLForMetaData(FetchPlanMetaData fpmd, String prefix, String indent) {
StringBuilder str = new StringBuilder();
str.append(prefix).append("<fetch-plan name=\"" + fpmd.getName() + "\"" + " max-fetch-depth=\"" + fpmd.getMaxFetchDepth() + "\"" + " fetch-size=\"" + fpmd.getFetchSize() + "\">\n");
// Add fetch-groups
FetchGroupMetaData[] fetchGroups = fpmd.getFetchGroupMetaData();
if (fetchGroups != null) {
for (FetchGroupMetaData fgmd : fetchGroups) {
str.append(getXMLForMetaData(fgmd, prefix + indent, indent));
}
}
str.append(prefix + "</fetch-plan>\n");
return str.toString();
}
Aggregations