use of org.datanucleus.metadata.FileMetaData in project tests by datanucleus.
the class BasicTest method testMetaDataManagerI18N.
/**
* Test for the MetaDataManager.
*/
public void testMetaDataManagerI18N() {
JDOMetaDataHelper mdProc = new JDOMetaDataHelper();
String filename = "/org/jpox/samples/i18n/UTF8.jdo";
MetaDataManager mmgr1 = new JDOMetaDataManager(new PersistenceNucleusContextImpl("JDO", null));
MetaDataParser parser1 = new MetaDataParser(mmgr1, mmgr1.getNucleusContext().getPluginManager(), true, true);
mmgr1.setValidate(false);
FileMetaData fmd = (FileMetaData) parser1.parseMetaDataStream(MetaDataParser.class.getResourceAsStream(filename), filename, "jdo");
fmd.getPackage("org.jpox.samples.i18n").getClass("UTF8");
org.datanucleus.metadata.AbstractClassMetaData cmd1 = fmd.getPackage("org.jpox.samples.i18n").getClass("UTF8");
cmd1.populate(new ClassLoaderResolverImpl(), null, mmgr1);
cmd1.initialise(new ClassLoaderResolverImpl());
MetaDataManager mmgr2 = new JDOMetaDataManager(new PersistenceNucleusContextImpl("JDO", null));
mmgr2.setValidate(false);
org.datanucleus.metadata.AbstractClassMetaData cmd = mmgr2.getMetaDataForClass(UTF8.class, new ClassLoaderResolverImpl());
if (!mdProc.getXMLForMetaData(cmd, "", "").equals(mdProc.getXMLForMetaData(cmd1, "", ""))) {
fail("i18n UTF-8 issues in parser");
}
filename = "/org/jpox/samples/i18n/ISO8859_2.jdo";
MetaDataManager mmgr3 = new JDOMetaDataManager(new PersistenceNucleusContextImpl("JDO", null));
MetaDataParser parser3 = new MetaDataParser(mmgr3, mmgr3.getNucleusContext().getPluginManager(), true, true);
mmgr3.setValidate(false);
fmd = (FileMetaData) parser3.parseMetaDataStream(MetaDataParser.class.getResourceAsStream(filename), filename, "jdo");
fmd.getPackage("org.jpox.samples.i18n").getClass("ISO8859_2");
MetaDataManager mmgr4 = new JDOMetaDataManager(new PersistenceNucleusContextImpl("JDO", null));
mmgr4.setValidate(false);
cmd1 = fmd.getPackage("org.jpox.samples.i18n").getClass("ISO8859_2");
cmd1.populate(new ClassLoaderResolverImpl(), null, mmgr4);
cmd1.initialise(null);
cmd = mmgr4.getMetaDataForClass(ISO8859_2.class, new ClassLoaderResolverImpl());
if (!mdProc.getXMLForMetaData(cmd, "", "").equals(mdProc.getXMLForMetaData(cmd1, "", ""))) {
fail("i18n ISO8859_2 issues in parser");
}
}
use of org.datanucleus.metadata.FileMetaData in project datanucleus-api-jdo by datanucleus.
the class JDOEnhancer method registerMetadata.
/* (non-Javadoc)
* @see javax.jdo.JDOEnhancer#registerMetadata(javax.jdo.metadata.JDOMetadata)
*/
public void registerMetadata(javax.jdo.metadata.JDOMetadata metadata) {
MetaDataManager mmgr = enhancer.getMetaDataManager();
FileMetaData filemd = ((JDOMetadataImpl) metadata).getInternal();
mmgr.loadUserMetaData(filemd, enhancer.getClassLoader());
}
use of org.datanucleus.metadata.FileMetaData in project datanucleus-api-jdo by datanucleus.
the class JDOMetaDataHandler method startElement.
/**
* Handler method called at the start of an element.
* @param uri URI of the tag
* @param localName Local name
* @param qName Element name
* @param attrs Attributes for this element
* @throws SAXException in parsing errors
*/
public void startElement(String uri, String localName, String qName, Attributes attrs) throws SAXException {
if (charactersBuffer.length() > 0) {
// Cater for subelements that appear before the end of the body text (save the body text with the
// parent)
String currentString = getString().trim();
if (getStack() instanceof QueryMetaData) {
((QueryMetaData) getStack()).setQuery(currentString.trim());
}
}
if (localName.length() < 1) {
localName = qName;
}
try {
if (localName.equals("jdo")) {
FileMetaData filemd = (FileMetaData) getStack();
filemd.setType(MetadataFileType.JDO_FILE);
filemd.setCatalog(getAttr(attrs, "catalog"));
filemd.setSchema(getAttr(attrs, "schema"));
} else if (localName.equals("orm")) {
FileMetaData filemd = (FileMetaData) getStack();
filemd.setType(MetadataFileType.JDO_ORM_FILE);
filemd.setCatalog(getAttr(attrs, "catalog"));
filemd.setSchema(getAttr(attrs, "schema"));
} else if (localName.equals("jdoquery")) {
FileMetaData filemd = (FileMetaData) getStack();
filemd.setType(MetadataFileType.JDO_QUERY_FILE);
} else if (localName.equals("fetch-plan")) {
FileMetaData filemd = (FileMetaData) metadata;
FetchPlanMetaData fpmd = filemd.newFetchPlanMetadata(getAttr(attrs, "name"));
fpmd.setMaxFetchDepth(getAttr(attrs, "max-fetch-depth"));
fpmd.setFetchSize(getAttr(attrs, "fetch-size"));
pushStack(fpmd);
} else if (localName.equals("package")) {
FileMetaData filemd = (FileMetaData) getStack();
PackageMetaData pmd = filemd.newPackageMetadata(getAttr(attrs, "name"));
pmd.setCatalog(getAttr(attrs, "catalog"));
pmd.setSchema(getAttr(attrs, "schema"));
pushStack(pmd);
} else if (localName.equals("class")) {
PackageMetaData pmd = (PackageMetaData) getStack();
ClassMetaData cmd = newClassObject(pmd, attrs);
pmd.addClass(cmd);
pushStack(cmd);
} else if (localName.equals("interface")) {
PackageMetaData pmd = (PackageMetaData) getStack();
InterfaceMetaData imd = newInterfaceObject(pmd, attrs);
pmd.addInterface(imd);
pushStack(imd);
} else if (localName.equals("primary-key")) {
MetaData md = getStack();
PrimaryKeyMetaData pkmd = new PrimaryKeyMetaData();
pkmd.setName(getAttr(attrs, "name"));
pkmd.setColumnName(getAttr(attrs, "column"));
if (md instanceof AbstractClassMetaData) {
((AbstractClassMetaData) md).setPrimaryKeyMetaData(pkmd);
} else if (md instanceof JoinMetaData) {
((JoinMetaData) md).setPrimaryKeyMetaData(pkmd);
}
pushStack(pkmd);
} else if (localName.equals("implements")) {
ClassMetaData cmd = (ClassMetaData) getStack();
ImplementsMetaData imd = new ImplementsMetaData(getAttr(attrs, "name"));
cmd.addImplements(imd);
pushStack(imd);
} else if (localName.equals("property")) {
MetaData parent = getStack();
if (parent instanceof AbstractClassMetaData) {
AbstractClassMetaData acmd = (AbstractClassMetaData) parent;
PropertyMetaData propmd = newPropertyObject(acmd, attrs);
acmd.addMember(propmd);
pushStack(propmd);
} else if (parent instanceof EmbeddedMetaData) {
EmbeddedMetaData emd = (EmbeddedMetaData) parent;
PropertyMetaData propmd = newPropertyObject(emd, attrs);
emd.addMember(propmd);
pushStack(propmd);
} else if (parent instanceof ImplementsMetaData) {
ImplementsMetaData implmd = (ImplementsMetaData) parent;
PropertyMetaData propmd = newPropertyObject(implmd, attrs);
implmd.addProperty(propmd);
pushStack(propmd);
} else if (parent instanceof FetchGroupMetaData) {
FetchGroupMetaData fgmd = (FetchGroupMetaData) parent;
FetchGroupMemberMetaData fgmmd = new FetchGroupMemberMetaData(fgmd, getAttr(attrs, "name"));
fgmmd.setRecursionDepth(getAttr(attrs, "recursion-depth"));
fgmmd.setProperty();
fgmd.addMember(fgmmd);
pushStack(fgmmd);
}
} else if (localName.equals("datastore-identity")) {
AbstractClassMetaData acmd = (AbstractClassMetaData) getStack();
IdentityMetaData idmd = new IdentityMetaData();
idmd.setColumnName(getAttr(attrs, "column"));
idmd.setValueStrategy(ValueGenerationStrategy.getIdentityStrategy(getAttr(attrs, "strategy")));
idmd.setSequence(getAttr(attrs, "sequence"));
acmd.setIdentityMetaData(idmd);
pushStack(idmd);
} else if (localName.equals("inheritance")) {
MetaData parent = getStack();
AbstractClassMetaData acmd = (AbstractClassMetaData) parent;
InheritanceMetaData inhmd = new InheritanceMetaData();
inhmd.setStrategy(getAttr(attrs, "strategy"));
acmd.setInheritanceMetaData(inhmd);
pushStack(inhmd);
} else if (localName.equals("discriminator")) {
MetaData md = getStack();
if (md instanceof InheritanceMetaData) {
InheritanceMetaData inhmd = (InheritanceMetaData) md;
DiscriminatorMetaData dismd = inhmd.newDiscriminatorMetadata();
dismd.setColumnName(getAttr(attrs, "column"));
dismd.setValue(getAttr(attrs, "value"));
dismd.setStrategy(getAttr(attrs, "strategy"));
dismd.setIndexed(getAttr(attrs, "indexed"));
pushStack(dismd);
} else if (md instanceof EmbeddedMetaData) {
EmbeddedMetaData embmd = (EmbeddedMetaData) md;
DiscriminatorMetaData dismd = embmd.newDiscriminatorMetadata();
dismd.setColumnName(getAttr(attrs, "column"));
dismd.setValue(getAttr(attrs, "value"));
dismd.setStrategy(getAttr(attrs, "strategy"));
dismd.setIndexed(getAttr(attrs, "indexed"));
pushStack(dismd);
}
} else if (localName.equals("query")) {
MetaData emd = getStack();
String name = getAttr(attrs, "name");
String lang = getAttr(attrs, "language");
if (!StringUtils.isWhitespace(lang)) {
if (// Convert to JDOQL
lang.equals(JDOQuery.JDOQL_QUERY_LANGUAGE)) {
lang = QueryLanguage.JDOQL.toString();
} else if (// Convert to SQL
lang.equals(JDOQuery.SQL_QUERY_LANGUAGE)) {
lang = QueryLanguage.SQL.toString();
} else if (// Convert to JPQL
lang.equals(JDOQuery.JPQL_QUERY_LANGUAGE)) {
lang = QueryLanguage.JPQL.toString();
}
}
if (emd instanceof ClassMetaData) {
ClassMetaData cmd = (ClassMetaData) emd;
if (StringUtils.isWhitespace(name)) {
throw new InvalidClassMetaDataException("044154", cmd.getFullClassName());
}
QueryMetaData qmd = new QueryMetaData(name);
qmd.setScope(cmd.getFullClassName());
qmd.setLanguage(lang);
qmd.setUnmodifiable(getAttr(attrs, "unmodifiable"));
qmd.setResultClass(getAttr(attrs, "result-class"));
qmd.setUnique(getAttr(attrs, "unique"));
qmd.setFetchPlanName(getAttr(attrs, "fetch-plan"));
cmd.addQuery(qmd);
pushStack(qmd);
} else if (emd instanceof InterfaceMetaData) {
InterfaceMetaData imd = (InterfaceMetaData) emd;
if (StringUtils.isWhitespace(name)) {
throw new InvalidClassMetaDataException("044154", imd.getFullClassName());
}
QueryMetaData qmd = new QueryMetaData(name);
qmd.setScope(imd.getFullClassName());
qmd.setLanguage(lang);
qmd.setUnmodifiable(getAttr(attrs, "unmodifiable"));
qmd.setResultClass(getAttr(attrs, "result-class"));
qmd.setUnique(getAttr(attrs, "unique"));
qmd.setFetchPlanName(getAttr(attrs, "fetch-plan"));
imd.addQuery(qmd);
pushStack(qmd);
} else if (emd instanceof FileMetaData) {
FileMetaData filemd = (FileMetaData) emd;
QueryMetaData qmd = filemd.newQueryMetadata(name);
qmd.setLanguage(lang);
qmd.setUnmodifiable(getAttr(attrs, "unmodifiable"));
qmd.setResultClass(getAttr(attrs, "result-class"));
qmd.setUnique(getAttr(attrs, "unique"));
qmd.setFetchPlanName(getAttr(attrs, "fetch-plan"));
pushStack(qmd);
}
} else if (localName.equals("sequence")) {
PackageMetaData pmd = (PackageMetaData) getStack();
SequenceMetaData seqmd = pmd.newSequenceMetadata(getAttr(attrs, "name"), getAttr(attrs, "strategy"));
seqmd.setFactoryClass(getAttr(attrs, "factory-class"));
seqmd.setDatastoreSequence(getAttr(attrs, "datastore-sequence"));
String seqSize = getAttr(attrs, "allocation-size");
if (seqSize != null) {
seqmd.setAllocationSize(seqSize);
}
String seqStart = getAttr(attrs, "initial-value");
if (seqStart != null) {
seqmd.setInitialValue(seqStart);
}
pushStack(seqmd);
} else if (localName.equals("field")) {
MetaData md = getStack();
if (md instanceof FetchGroupMetaData) {
FetchGroupMetaData fgmd = (FetchGroupMetaData) md;
FetchGroupMemberMetaData fgmmd = new FetchGroupMemberMetaData(md, getAttr(attrs, "name"));
fgmmd.setRecursionDepth(getAttr(attrs, "recursion-depth"));
fgmd.addMember(fgmmd);
pushStack(fgmmd);
return;
}
FieldMetaData fmd = newFieldObject(md, attrs);
if (md instanceof ClassMetaData) {
ClassMetaData cmd = (ClassMetaData) md;
cmd.addMember(fmd);
} else if (md instanceof EmbeddedMetaData) {
EmbeddedMetaData emd = (EmbeddedMetaData) md;
emd.addMember(fmd);
} else if (md instanceof ForeignKeyMetaData) {
ForeignKeyMetaData fkmd = (ForeignKeyMetaData) md;
fkmd.addMember(fmd.getName());
} else if (md instanceof IndexMetaData) {
IndexMetaData imd = (IndexMetaData) md;
imd.addMember(fmd.getName());
} else if (md instanceof UniqueMetaData) {
UniqueMetaData umd = (UniqueMetaData) md;
umd.addMember(fmd.getName());
}
pushStack(fmd);
} else if (localName.equals("join")) {
MetaData parent = getStack();
String tableName = getAttr(attrs, "table");
String columnName = getAttr(attrs, "column");
String outer = getAttr(attrs, "outer");
IndexedValue indexed = IndexedValue.getIndexedValue(getAttr(attrs, "indexed"));
String unique = getAttr(attrs, "unique");
String deleteAction = getAttr(attrs, "delete-action");
JoinMetaData joinmd = null;
if (parent instanceof AbstractMemberMetaData) {
AbstractMemberMetaData fmd = (AbstractMemberMetaData) parent;
joinmd = fmd.newJoinMetaData();
} else if (parent instanceof AbstractClassMetaData) {
AbstractClassMetaData cmd = (AbstractClassMetaData) parent;
joinmd = new JoinMetaData();
cmd.addJoin(joinmd);
} else if (parent instanceof InheritanceMetaData) {
InheritanceMetaData inhmd = (InheritanceMetaData) parent;
joinmd = inhmd.newJoinMetadata();
} else {
throw new NucleusUserException("Error processing JDO XML metadata. Found \"join\" with parent " + StringUtils.toJVMIDString(parent) + " - not supported");
}
joinmd.setTable(tableName);
joinmd.setColumnName(columnName);
joinmd.setOuter(MetaDataUtils.getBooleanForString(outer, false));
joinmd.setIndexed(indexed);
joinmd.setUnique(unique);
joinmd.setDeleteAction(deleteAction);
pushStack(joinmd);
} else if (localName.equals("map")) {
AbstractMemberMetaData fmd = (AbstractMemberMetaData) getStack();
MapMetaData mapmd = fmd.newMapMetaData();
mapmd.setKeyType(getAttr(attrs, "key-type"));
String embKeyStr = getAttr(attrs, "embedded-key");
if (!StringUtils.isWhitespace(embKeyStr)) {
mapmd.setEmbeddedKey(Boolean.valueOf(embKeyStr));
}
String serKeyStr = getAttr(attrs, "serialized-key");
if (!StringUtils.isWhitespace(serKeyStr)) {
mapmd.setSerializedKey(Boolean.valueOf(serKeyStr));
}
String depKeyStr = getAttr(attrs, "dependent-key");
if (!StringUtils.isWhitespace(depKeyStr)) {
mapmd.setDependentKey(Boolean.valueOf(depKeyStr));
}
mapmd.setValueType(getAttr(attrs, "value-type"));
String embValStr = getAttr(attrs, "embedded-value");
if (!StringUtils.isWhitespace(embValStr)) {
mapmd.setEmbeddedValue(Boolean.valueOf(embValStr));
}
String serValStr = getAttr(attrs, "serialized-value");
if (!StringUtils.isWhitespace(serValStr)) {
mapmd.setSerializedValue(Boolean.valueOf(serValStr));
}
String depValStr = getAttr(attrs, "dependent-value");
if (!StringUtils.isWhitespace(depValStr)) {
mapmd.setDependentValue(Boolean.valueOf(depValStr));
}
pushStack(mapmd);
} else if (localName.equals("array")) {
AbstractMemberMetaData fmd = (AbstractMemberMetaData) getStack();
ArrayMetaData arrmd = fmd.newArrayMetaData();
arrmd.setElementType(getAttr(attrs, "element-type"));
String embElemStr = getAttr(attrs, "embedded-element");
if (!StringUtils.isWhitespace(embElemStr)) {
arrmd.setEmbeddedElement(Boolean.valueOf(embElemStr));
}
String serElemStr = getAttr(attrs, "serialized-element");
if (!StringUtils.isWhitespace(serElemStr)) {
arrmd.setSerializedElement(Boolean.valueOf(serElemStr));
}
String depElemStr = getAttr(attrs, "dependent-element");
if (!StringUtils.isWhitespace(depElemStr)) {
arrmd.setDependentElement(Boolean.valueOf(depElemStr));
}
pushStack(arrmd);
} else if (localName.equals("collection")) {
AbstractMemberMetaData fmd = (AbstractMemberMetaData) getStack();
CollectionMetaData collmd = fmd.newCollectionMetaData();
collmd.setElementType(getAttr(attrs, "element-type"));
String embElemStr = getAttr(attrs, "embedded-element");
if (!StringUtils.isWhitespace(embElemStr)) {
collmd.setEmbeddedElement(Boolean.valueOf(embElemStr));
}
String serElemStr = getAttr(attrs, "serialized-element");
if (!StringUtils.isWhitespace(serElemStr)) {
collmd.setSerializedElement(Boolean.valueOf(serElemStr));
}
String depElemStr = getAttr(attrs, "dependent-element");
if (!StringUtils.isWhitespace(depElemStr)) {
collmd.setDependentElement(Boolean.valueOf(depElemStr));
}
pushStack(collmd);
} else if (localName.equals("column")) {
MetaData md = getStack();
ColumnMetaData colmd = new ColumnMetaData();
colmd.setName(getAttr(attrs, "name"));
colmd.setTarget(getAttr(attrs, "target"));
colmd.setTargetMember(getAttr(attrs, "target-field"));
colmd.setJdbcType(getAttr(attrs, "jdbc-type"));
colmd.setSqlType(getAttr(attrs, "sql-type"));
colmd.setLength(getAttr(attrs, "length"));
colmd.setScale(getAttr(attrs, "scale"));
colmd.setAllowsNull(getAttr(attrs, "allows-null"));
colmd.setDefaultValue(getAttr(attrs, "default-value"));
colmd.setInsertValue(getAttr(attrs, "insert-value"));
// JDO 3.1+
String pos = getAttr(attrs, "position");
if (pos != null) {
colmd.setPosition(pos);
}
if (md instanceof AbstractMemberMetaData) {
AbstractMemberMetaData fmd = (AbstractMemberMetaData) md;
fmd.addColumn(colmd);
} else if (md instanceof AbstractElementMetaData) {
AbstractElementMetaData elemd = (AbstractElementMetaData) md;
elemd.addColumn(colmd);
} else if (md instanceof JoinMetaData) {
JoinMetaData jnmd = (JoinMetaData) md;
jnmd.addColumn(colmd);
} else if (md instanceof IdentityMetaData) {
IdentityMetaData idmd = (IdentityMetaData) md;
idmd.setColumnMetaData(colmd);
} else if (md instanceof ForeignKeyMetaData) {
ForeignKeyMetaData fkmd = (ForeignKeyMetaData) md;
fkmd.addColumn(colmd);
} else if (md instanceof IndexMetaData) {
IndexMetaData idxmd = (IndexMetaData) md;
idxmd.addColumn(colmd.getName());
} else if (md instanceof UniqueMetaData) {
UniqueMetaData unimd = (UniqueMetaData) md;
unimd.addColumn(colmd.getName());
} else if (md instanceof OrderMetaData) {
OrderMetaData ormd = (OrderMetaData) md;
ormd.addColumn(colmd);
} else if (md instanceof DiscriminatorMetaData) {
DiscriminatorMetaData dismd = (DiscriminatorMetaData) md;
dismd.setColumnMetaData(colmd);
} else if (md instanceof VersionMetaData) {
VersionMetaData vermd = (VersionMetaData) md;
vermd.setColumnMetaData(colmd);
} else if (md instanceof AbstractClassMetaData) {
AbstractClassMetaData cmd = (AbstractClassMetaData) md;
cmd.addUnmappedColumn(colmd);
} else if (md instanceof PrimaryKeyMetaData) {
PrimaryKeyMetaData pkmd = (PrimaryKeyMetaData) md;
pkmd.addColumn(colmd);
}
pushStack(colmd);
} else if (localName.equals("element")) {
AbstractMemberMetaData fmd = (AbstractMemberMetaData) getStack();
ElementMetaData elemmd = new ElementMetaData();
elemmd.setTable(getAttr(attrs, "table"));
elemmd.setColumnName(getAttr(attrs, "column"));
elemmd.setDeleteAction(getAttr(attrs, "delete-action"));
elemmd.setUpdateAction(getAttr(attrs, "update-action"));
elemmd.setIndexed(IndexedValue.getIndexedValue(getAttr(attrs, "indexed")));
elemmd.setUnique(MetaDataUtils.getBooleanForString(getAttr(attrs, "unique"), false));
String mappedBy = getAttr(attrs, "mapped-by");
elemmd.setMappedBy(mappedBy);
if (!StringUtils.isWhitespace(mappedBy) && fmd.getMappedBy() == null) {
// With collection/array this is the same as mapped-by on the field
fmd.setMappedBy(mappedBy);
}
String converterAttr = getAttr(attrs, "converter");
String disableConverterAttr = getAttr(attrs, "use-default-conversion");
if (disableConverterAttr != null && Boolean.getBoolean(disableConverterAttr)) {
// TODO Disable on the element?
} else if (!StringUtils.isWhitespace(converterAttr)) {
TypeManager typeMgr = mmgr.getNucleusContext().getTypeManager();
ClassLoaderResolver clr = mmgr.getNucleusContext().getClassLoaderResolver(null);
Class converterCls = clr.classForName(converterAttr);
if (typeMgr.getTypeConverterForName(converterCls.getName()) == null) {
// Not yet cached an instance of this converter so create one
AttributeConverter conv = JDOTypeConverterUtils.createAttributeConverter((PersistenceNucleusContext) mmgr.getNucleusContext(), converterCls);
// TODO element type
Class attrType = JDOTypeConverterUtils.getAttributeTypeForAttributeConverter(converterCls, null);
Class dbType = JDOTypeConverterUtils.getDatastoreTypeForAttributeConverter(converterCls, attrType, null);
// Register the TypeConverter under the name of the AttributeConverter class
JDOTypeConverter typeConv = new JDOTypeConverter(conv);
typeMgr.registerConverter(converterAttr, typeConv, attrType, dbType, false, null);
}
elemmd.addExtension(MetaData.EXTENSION_MEMBER_TYPE_CONVERTER_NAME, converterAttr);
}
fmd.setElementMetaData(elemmd);
pushStack(elemmd);
} else if (localName.equals("key")) {
AbstractMemberMetaData fmd = (AbstractMemberMetaData) getStack();
KeyMetaData keymd = new KeyMetaData();
keymd.setTable(getAttr(attrs, "table"));
keymd.setColumnName(getAttr(attrs, "column"));
keymd.setDeleteAction(getAttr(attrs, "delete-action"));
keymd.setUpdateAction(getAttr(attrs, "update-action"));
keymd.setIndexed(IndexedValue.getIndexedValue(getAttr(attrs, "indexed")));
keymd.setUnique(MetaDataUtils.getBooleanForString(getAttr(attrs, "unique"), false));
keymd.setMappedBy(getAttr(attrs, "mapped-by"));
String converterAttr = getAttr(attrs, "converter");
String disableConverterAttr = getAttr(attrs, "use-default-conversion");
if (disableConverterAttr != null && Boolean.getBoolean(disableConverterAttr)) {
// TODO Disable on the key?
} else if (!StringUtils.isWhitespace(converterAttr)) {
TypeManager typeMgr = mmgr.getNucleusContext().getTypeManager();
ClassLoaderResolver clr = mmgr.getNucleusContext().getClassLoaderResolver(null);
Class converterCls = clr.classForName(converterAttr);
if (typeMgr.getTypeConverterForName(converterCls.getName()) == null) {
// Not yet cached an instance of this converter so create one
AttributeConverter conv = JDOTypeConverterUtils.createAttributeConverter((PersistenceNucleusContext) mmgr.getNucleusContext(), converterCls);
// TODO key type
Class attrType = JDOTypeConverterUtils.getAttributeTypeForAttributeConverter(converterCls, null);
Class dbType = JDOTypeConverterUtils.getDatastoreTypeForAttributeConverter(converterCls, attrType, null);
// Register the TypeConverter under the name of the AttributeConverter class
JDOTypeConverter typeConv = new JDOTypeConverter(conv);
typeMgr.registerConverter(converterAttr, typeConv, attrType, dbType, false, null);
}
keymd.addExtension(MetaData.EXTENSION_MEMBER_TYPE_CONVERTER_NAME, converterAttr);
}
fmd.setKeyMetaData(keymd);
pushStack(keymd);
} else // New value
if (localName.equals("value")) {
AbstractMemberMetaData fmd = (AbstractMemberMetaData) getStack();
ValueMetaData valuemd = new ValueMetaData();
valuemd.setTable(getAttr(attrs, "table"));
valuemd.setColumnName(getAttr(attrs, "column"));
valuemd.setDeleteAction(getAttr(attrs, "delete-action"));
valuemd.setUpdateAction(getAttr(attrs, "update-action"));
valuemd.setIndexed(IndexedValue.getIndexedValue(getAttr(attrs, "indexed")));
valuemd.setUnique(MetaDataUtils.getBooleanForString(getAttr(attrs, "unique"), false));
valuemd.setMappedBy(getAttr(attrs, "mapped-by"));
String converterAttr = getAttr(attrs, "converter");
String disableConverterAttr = getAttr(attrs, "use-default-conversion");
if (disableConverterAttr != null && Boolean.getBoolean(disableConverterAttr)) {
// TODO Disable on the value?
} else if (!StringUtils.isWhitespace(converterAttr)) {
TypeManager typeMgr = mmgr.getNucleusContext().getTypeManager();
ClassLoaderResolver clr = mmgr.getNucleusContext().getClassLoaderResolver(null);
Class converterCls = clr.classForName(converterAttr);
if (typeMgr.getTypeConverterForName(converterCls.getName()) == null) {
// Not yet cached an instance of this converter so create one
AttributeConverter conv = JDOTypeConverterUtils.createAttributeConverter((PersistenceNucleusContext) mmgr.getNucleusContext(), converterCls);
// TODO value type
Class attrType = JDOTypeConverterUtils.getAttributeTypeForAttributeConverter(converterCls, null);
Class dbType = JDOTypeConverterUtils.getDatastoreTypeForAttributeConverter(converterCls, attrType, null);
// Register the TypeConverter under the name of the AttributeConverter class
JDOTypeConverter typeConv = new JDOTypeConverter(conv);
typeMgr.registerConverter(converterAttr, typeConv, attrType, dbType, false, null);
}
valuemd.addExtension(MetaData.EXTENSION_MEMBER_TYPE_CONVERTER_NAME, converterAttr);
}
fmd.setValueMetaData(valuemd);
pushStack(valuemd);
} else // New fetch-group
if (localName.equals("fetch-group")) {
MetaData md = getStack();
FetchGroupMetaData fgmd = new FetchGroupMetaData(getAttr(attrs, "name"));
String postLoadStr = getAttr(attrs, "post-load");
if (!StringUtils.isWhitespace(postLoadStr)) {
fgmd.setPostLoad(Boolean.valueOf(postLoadStr));
}
if (md instanceof FetchGroupMetaData) {
FetchGroupMetaData fgmdParent = (FetchGroupMetaData) md;
fgmdParent.addFetchGroup(fgmd);
} else if (md instanceof AbstractClassMetaData) {
AbstractClassMetaData cmd = (AbstractClassMetaData) md;
cmd.addFetchGroup(fgmd);
} else if (md instanceof FetchPlanMetaData) {
FetchPlanMetaData fpmd = (FetchPlanMetaData) md;
fpmd.addFetchGroup(fgmd);
}
pushStack(fgmd);
} else if (localName.equals("extension")) {
MetaData md = getStack();
String vendorName = getAttr(attrs, "vendor-name");
if (StringUtils.isWhitespace(vendorName)) {
throw new InvalidMetaDataException("044160", vendorName, getAttr(attrs, "key"), getAttr(attrs, "value"));
}
if (vendorName != null && vendorName.equalsIgnoreCase(MetaData.VENDOR_NAME)) {
md.addExtension(getAttr(attrs, "key"), getAttr(attrs, "value"));
}
} else if (localName.equals("version")) {
AbstractClassMetaData cmd = (AbstractClassMetaData) getStack();
VersionMetaData vermd = cmd.newVersionMetadata();
String strategy = getAttr(attrs, "strategy");
if (!StringUtils.isWhitespace(strategy)) {
vermd.setStrategy(strategy);
}
vermd.setColumnName(getAttr(attrs, "column"));
vermd.setIndexed(IndexedValue.getIndexedValue(getAttr(attrs, "indexed")));
pushStack(vermd);
} else if (localName.equals("index")) {
MetaData md = getStack();
IndexMetaData idxmd = new IndexMetaData();
idxmd.setName(getAttr(attrs, "name"));
idxmd.setTable(getAttr(attrs, "table"));
String uniStr = getAttr(attrs, "unique");
if (!StringUtils.isWhitespace(uniStr)) {
idxmd.setUnique(Boolean.valueOf(uniStr));
}
if (md instanceof AbstractClassMetaData) {
AbstractClassMetaData cmd = (AbstractClassMetaData) md;
cmd.addIndex(idxmd);
} else if (md instanceof AbstractMemberMetaData) {
AbstractMemberMetaData fmd = (AbstractMemberMetaData) md;
fmd.setIndexMetaData(idxmd);
} else if (md instanceof JoinMetaData) {
JoinMetaData jmd = (JoinMetaData) md;
jmd.setIndexMetaData(idxmd);
} else if (md instanceof AbstractElementMetaData) {
AbstractElementMetaData elmd = (AbstractElementMetaData) md;
elmd.setIndexMetaData(idxmd);
} else if (md instanceof OrderMetaData) {
OrderMetaData omd = (OrderMetaData) md;
omd.setIndexMetaData(idxmd);
} else if (md instanceof VersionMetaData) {
VersionMetaData vermd = (VersionMetaData) md;
vermd.setIndexMetaData(idxmd);
} else if (md instanceof DiscriminatorMetaData) {
DiscriminatorMetaData dismd = (DiscriminatorMetaData) md;
dismd.setIndexMetaData(idxmd);
}
pushStack(idxmd);
} else if (localName.equals("unique")) {
MetaData md = getStack();
UniqueMetaData unimd = new UniqueMetaData();
unimd.setName(getAttr(attrs, "name"));
unimd.setTable(getAttr(attrs, "table"));
String defStr = getAttr(attrs, "deferred");
if (!StringUtils.isWhitespace(defStr)) {
unimd.setDeferred(Boolean.valueOf(defStr));
}
if (md instanceof AbstractClassMetaData) {
AbstractClassMetaData cmd = (AbstractClassMetaData) md;
cmd.addUniqueConstraint(unimd);
} else if (md instanceof AbstractMemberMetaData) {
AbstractMemberMetaData fmd = (AbstractMemberMetaData) md;
fmd.setUniqueMetaData(unimd);
} else if (md instanceof JoinMetaData) {
JoinMetaData jmd = (JoinMetaData) md;
jmd.setUniqueMetaData(unimd);
} else if (md instanceof AbstractElementMetaData) {
AbstractElementMetaData elmd = (AbstractElementMetaData) md;
elmd.setUniqueMetaData(unimd);
}
pushStack(unimd);
} else if (localName.equals("foreign-key")) {
MetaData md = getStack();
ForeignKeyMetaData fkmd = new ForeignKeyMetaData();
fkmd.setName(getAttr(attrs, "name"));
fkmd.setTable(getAttr(attrs, "table"));
fkmd.setUnique(getAttr(attrs, "unique"));
fkmd.setDeferred(getAttr(attrs, "deferred"));
fkmd.setDeleteAction(ForeignKeyAction.getForeignKeyAction(getAttr(attrs, "delete-action")));
fkmd.setUpdateAction(ForeignKeyAction.getForeignKeyAction(getAttr(attrs, "update-action")));
if (md instanceof AbstractClassMetaData) {
AbstractClassMetaData cmd = (AbstractClassMetaData) md;
cmd.addForeignKey(fkmd);
} else if (md instanceof AbstractMemberMetaData) {
AbstractMemberMetaData fmd = (AbstractMemberMetaData) md;
fmd.setForeignKeyMetaData(fkmd);
} else if (md instanceof JoinMetaData) {
JoinMetaData jmd = (JoinMetaData) md;
jmd.setForeignKeyMetaData(fkmd);
} else if (md instanceof AbstractElementMetaData) {
AbstractElementMetaData elmd = (AbstractElementMetaData) md;
elmd.setForeignKeyMetaData(fkmd);
}
pushStack(fkmd);
} else if (localName.equals("order")) {
OrderMetaData ordmd = new OrderMetaData();
ordmd.setIndexed(IndexedValue.getIndexedValue(getAttr(attrs, "indexed")));
ordmd.setColumnName(getAttr(attrs, "column"));
ordmd.setMappedBy(getAttr(attrs, "mapped-by"));
AbstractMemberMetaData fmd = (AbstractMemberMetaData) getStack();
fmd.setOrderMetaData(ordmd);
pushStack(ordmd);
} else if (localName.equals("embedded")) {
MetaData md = getStack();
EmbeddedMetaData embmd = new EmbeddedMetaData();
embmd.setOwnerMember(getAttr(attrs, "owner-field"));
embmd.setNullIndicatorColumn(getAttr(attrs, "null-indicator-column"));
embmd.setNullIndicatorValue(getAttr(attrs, "null-indicator-value"));
if (md instanceof AbstractMemberMetaData) {
AbstractMemberMetaData fmd = (AbstractMemberMetaData) md;
fmd.setEmbeddedMetaData(embmd);
} else if (md instanceof KeyMetaData) {
KeyMetaData kmd = (KeyMetaData) md;
kmd.setEmbeddedMetaData(embmd);
} else if (md instanceof ValueMetaData) {
ValueMetaData vmd = (ValueMetaData) md;
vmd.setEmbeddedMetaData(embmd);
} else if (md instanceof ElementMetaData) {
ElementMetaData elmd = (ElementMetaData) md;
elmd.setEmbeddedMetaData(embmd);
}
pushStack(embmd);
} else {
String message = Localiser.msg("044037", qName);
NucleusLogger.METADATA.error(message);
throw new RuntimeException(message);
}
} catch (RuntimeException ex) {
NucleusLogger.METADATA.error(Localiser.msg("044042", qName, getStack(), uri), ex);
throw ex;
}
}
use of org.datanucleus.metadata.FileMetaData in project datanucleus-api-jdo by datanucleus.
the class JDOMetaDataManager method loadXMLMetaDataForClass.
/**
* Method to find the Meta-Data file for a specified class.
* Checks the locations one-by-one, and checks for existence of the specified class in the file.
* If a valid file is found it is loaded no matter if the file contains the actual class.
* When a file is found containing the class the process stops and the FileMetaData for that file (containing the class) returned.
* <P>
* Allows 2 variations on the naming above.
* The first is a modifier which caters for a JDO 2.0 requirement whereby the user can specify a modifier such as "mysql",
* which would mean that this should search for filenames "package-mysql.jdo". The second variation is the suffix of the file.
* This is "jdo" by default, but JDO 2.0 has situations where "orm", or "jdoquery" are required as a suffix.
* </P>
* @param pc_class The class/interface to retrieve the metadata file for
* @param clr the ClassLoaderResolver
* @param mappingModifier Any modifier for the filename for mapping
* @param metadataFileExtension File extension of metadata files (e.g "jdo")
* @param metadataType Type of metadata file to load
* @param populate Whether to populate any loaded MetaData classes
* @return FileMetaData for the file containing the class
*/
protected FileMetaData loadXMLMetaDataForClass(Class pc_class, ClassLoaderResolver clr, String mappingModifier, String metadataFileExtension, MetadataFileType metadataType, boolean populate) {
// MetaData file locations
List<String> validLocations = getValidMetaDataLocationsForClass(metadataFileExtension, mappingModifier, pc_class.getName());
for (String location : validLocations) {
Enumeration resources;
try {
resources = clr.getResources(location, pc_class.getClassLoader());
} catch (IOException e) {
throw new NucleusException("Error loading resource", e).setFatal();
}
if (!resources.hasMoreElements() && NucleusLogger.METADATA.isDebugEnabled()) {
NucleusLogger.METADATA.debug(Localiser.msg("044049", metadataFileExtension, pc_class.getName(), location));
}
while (resources.hasMoreElements()) {
URL url = (URL) resources.nextElement();
if (url != null) {
// Check if we already have this file parsed/registered
FileMetaData filemd = fileMetaDataByURLString.get(url.toString());
if (filemd == null) {
// Not registered so load the file from the URL
filemd = parseFile(url);
if (filemd.getType() != metadataType) {
// Wrong type of file so ignore it
NucleusLogger.METADATA.warn(Localiser.msg("044045", url, filemd.getType(), metadataType));
filemd = null;
break;
}
registerFile(url.toString(), filemd, clr);
if (populate) {
// Populate all classes in this file we've just parsed
populateFileMetaData(filemd, clr, pc_class.getClassLoader());
}
}
if (((filemd.getType() == MetadataFileType.JDO_FILE && classMetaDataByClass.get(pc_class.getName()) != null) || (filemd.getType() == MetadataFileType.JDO_ORM_FILE && ormClassMetaDataByClass.get(pc_class.getName()) != null))) {
// We now have the class, so it must have been in this file
if (NucleusLogger.METADATA.isDebugEnabled()) {
NucleusLogger.METADATA.debug(Localiser.msg("044052", metadataFileExtension, pc_class.getName(), url));
}
return filemd;
}
}
}
}
if (NucleusLogger.METADATA.isDebugEnabled()) {
NucleusLogger.METADATA.debug(Localiser.msg("044048", metadataFileExtension, pc_class.getName()));
}
return null;
}
use of org.datanucleus.metadata.FileMetaData in project datanucleus-api-jdo by datanucleus.
the class JDOMetaDataManager method getMetaDataForQuery.
/**
* Accessor for the MetaData for a named query for a class.
* If the query is not found, will check all valid JDO file locations and try to load it.
* @param cls The class which has the query defined for it
* @param clr the ClassLoaderResolver
* @param queryName Name of the query
* @return The QueryMetaData for the query for this class
*/
public QueryMetaData getMetaDataForQuery(Class cls, ClassLoaderResolver clr, String queryName) {
QueryMetaData qmd = super.getMetaDataForQuery(cls, clr, queryName);
if (qmd != null) {
return qmd;
}
String query_key = queryName;
if (cls != null) {
query_key = cls.getName() + "_" + queryName;
}
// No query found, so try to load one from a valid JDO location
if (cls != null) {
// Query is scoped to a candidate class, so load the class as necessary
AbstractClassMetaData cmd = getMetaDataForClass(cls, clr);
if (cmd == null) {
// No metadata for this class so no chance of finding the query for it
return null;
}
if (queryMetaDataByName != null) {
Object obj = queryMetaDataByName.get(query_key);
if (obj != null) {
return (QueryMetaData) obj;
}
}
if (allowXML) {
// Query not stored in JDO/ORM files so try JDOQUERY
List<String> locations = new ArrayList<>();
locations.addAll(getValidMetaDataLocationsForClass(getJDOQueryFileSuffix(), null, cls.getName()));
for (String location : locations) {
// Process all resources for this location
Enumeration resources;
try {
resources = clr.getResources(location, cls.getClassLoader());
} catch (IOException e) {
throw new NucleusException("Error loading resource", e).setFatal();
}
while (resources.hasMoreElements()) {
URL fileURL = (URL) resources.nextElement();
if (fileMetaDataByURLString.get(fileURL.toString()) == null) {
// File hasn't been loaded so load it
FileMetaData filemd = parseFile(fileURL);
// TODO Remove this since set in the parser at <jdoquery>
filemd.setType(MetadataFileType.JDO_QUERY_FILE);
registerFile(fileURL.toString(), filemd, clr);
// Populate all classes in this file we've just parsed
// TODO Populate the classes found in this file
}
}
cmd = getMetaDataForClass(cls, clr);
if (queryMetaDataByName != null) {
qmd = queryMetaDataByName.get(query_key);
if (qmd != null) {
if (NucleusLogger.METADATA.isDebugEnabled()) {
NucleusLogger.METADATA.debug(Localiser.msg("044053", query_key, location));
}
return qmd;
}
if (NucleusLogger.METADATA.isDebugEnabled()) {
NucleusLogger.METADATA.debug(Localiser.msg("044050", query_key, location));
}
}
}
}
return null;
}
// Query isn't scoped to a candidate class, so search the valid package-independent locations
List<String> locations = new ArrayList<>();
locations.addAll(getValidMetaDataLocationsForItem(getJDOFileSuffix(), null, null, false));
locations.addAll(getValidMetaDataLocationsForItem(getORMFileSuffix(), getORMMappingName(), null, false));
locations.addAll(getValidMetaDataLocationsForItem(getJDOQueryFileSuffix(), null, null, false));
for (String location : locations) {
// Process all resources for this location
Enumeration resources;
try {
resources = clr.getResources(location, null);
} catch (IOException e) {
throw new NucleusException("Error loading resources", e).setFatal();
}
while (resources.hasMoreElements()) {
URL fileURL = (URL) resources.nextElement();
if (fileMetaDataByURLString.get(fileURL.toString()) == null) {
// File hasn't been loaded so load it
FileMetaData filemd = parseFile(fileURL);
registerFile(fileURL.toString(), filemd, clr);
// Populate all classes in this file we've just parsed
// TODO Populate the classes found in this file
}
}
if (queryMetaDataByName != null) {
qmd = queryMetaDataByName.get(query_key);
if (qmd != null) {
if (NucleusLogger.METADATA.isDebugEnabled()) {
NucleusLogger.METADATA.debug(Localiser.msg("044053", query_key, location));
}
return qmd;
}
}
if (NucleusLogger.METADATA.isDebugEnabled()) {
NucleusLogger.METADATA.debug(Localiser.msg("044050", query_key, location));
}
}
return null;
}
Aggregations