/** Loads the list of lazy load groups from the xml element. */
private void loadLazyLoadGroupsXml(Element element) throws DeploymentException {
Element lazyLoadGroupsElement = MetaData.getOptionalChild(element, "lazy-load-groups");
// If no info, we're done. Default work was already done in constructor.
if (lazyLoadGroupsElement == null) {
return;
}
// only allowed for cmp 2.x
if (isCMP1x) {
throw new DeploymentException("lazy-load-groups is only allowed for CMP 2.x");
}
// get the fields
Iterator loadGroupNames =
MetaData.getChildrenByTagName(lazyLoadGroupsElement, "load-group-name");
while (loadGroupNames.hasNext()) {
String loadGroupName = MetaData.getElementContent((Element) loadGroupNames.next());
if (!loadGroupName.equals("*") && !loadGroups.containsKey(loadGroupName)) {
throw new DeploymentException(
"Lazy load group not found: " + "load-group-name=" + loadGroupName);
}
lazyLoadGroups.add(loadGroupName);
}
}
/** Loads the load groups of cmp fields from the xml element */
private void loadLoadGroupsXml(Element element) throws DeploymentException {
Element loadGroupsElement = MetaData.getOptionalChild(element, "load-groups");
if (loadGroupsElement == null) {
// no info, default work already done in constructor
return;
}
// only allowed for cmp 2.x
if (isCMP1x) {
throw new DeploymentException("load-groups are only allowed " + "for CMP 2.x");
}
// load each group
Iterator groups = MetaData.getChildrenByTagName(loadGroupsElement, "load-group");
while (groups.hasNext()) {
Element groupElement = (Element) groups.next();
// get the load-group-name
String loadGroupName = MetaData.getUniqueChildContent(groupElement, "load-group-name");
if (loadGroups.containsKey(loadGroupName)) {
throw new DeploymentException(
"Load group already defined: " + " load-group-name=" + loadGroupName);
}
if (loadGroupName.equals("*")) {
throw new DeploymentException(
"The * load group is automatically " + "defined and can't be overriden");
}
ArrayList group = new ArrayList();
// add each field
Iterator fields = MetaData.getChildrenByTagName(groupElement, "field-name");
while (fields.hasNext()) {
String fieldName = MetaData.getElementContent((Element) fields.next());
// check if the field is a cmp field that it is not a pk memeber
JDBCCMPFieldMetaData field = getCMPFieldByName(fieldName);
if (field != null && field.isPrimaryKeyMember()) {
throw new DeploymentException(
"Primary key fields can not be"
+ " a member of a load group: "
+ " load-group-name="
+ loadGroupName
+ " field-name="
+ fieldName);
}
group.add(fieldName);
}
loadGroups.put(loadGroupName, Collections.unmodifiableList(group));
}
}
// XmlLoadable implementation ----------------------------------------------
public void importXml(Element element) throws DeploymentException {
// This one is mandatory
String p = MetaData.getElementContent(MetaData.getUniqueChild(element, "cache-policy"));
try {
Class cls = SecurityActions.getContextClassLoader().loadClass(p);
Constructor ctor = cls.getConstructor(new Class[] {AbstractInstanceCache.class});
m_cache = (CachePolicy) ctor.newInstance(new Object[] {this});
} catch (Exception x) {
throw new DeploymentException("Can't create cache policy", x);
}
Element policyConf = MetaData.getOptionalChild(element, "cache-policy-conf");
if (policyConf != null) {
if (m_cache instanceof XmlLoadable) {
try {
((XmlLoadable) m_cache).importXml(policyConf);
} catch (Exception x) {
throw new DeploymentException("Can't import policy configuration", x);
}
}
}
}
/**
* Constructs a JDBCJBossQLQueryMetaData with JBossQL declared in the jboss-ql elemnt and is
* invoked by the specified method.
*/
public JDBCJBossQLQueryMetaData(
boolean resultTypeMappingLocal,
Element element,
Method method,
JDBCReadAheadMetaData readAhead,
Class compiler,
boolean lazyResultSetLoading)
throws DeploymentException {
this.method = method;
this.readAhead = readAhead;
jbossQL = MetaData.getElementContent(element);
if (jbossQL == null || jbossQL.trim().length() == 0) {
throw new DeploymentException("jboss-ql element is empty");
}
this.resultTypeMappingLocal = resultTypeMappingLocal;
this.compiler = compiler;
this.lazyResultSetLoading = lazyResultSetLoading;
}
/**
* Constructs entity meta data with the data contained in the entity xml element from a
* jbosscmp-jdbc xml file. Optional values of the xml element that are not present are loaded from
* the defalutValues parameter.
*
* @param jdbcApplication the application in which this entity is defined
* @param element the xml Element which contains the metadata about this entity
* @param defaultValues the JDBCEntityMetaData which contains the values for optional elements of
* the element
* @throws DeploymentException if the xml element is not semantically correct
*/
public JDBCEntityMetaData(
JDBCApplicationMetaData jdbcApplication, Element element, JDBCEntityMetaData defaultValues)
throws DeploymentException {
// store passed in application... application in defaultValues may
// be different because jdbcApplication is imutable
this.jdbcApplication = jdbcApplication;
// set default values
entityName = defaultValues.getName();
entityClass = defaultValues.getEntityClass();
primaryKeyClass = defaultValues.getPrimaryKeyClass();
isCMP1x = defaultValues.isCMP1x;
primaryKeyFieldName = defaultValues.getPrimaryKeyFieldName();
homeClass = defaultValues.getHomeClass();
remoteClass = defaultValues.getRemoteClass();
localHomeClass = defaultValues.getLocalHomeClass();
localClass = defaultValues.getLocalClass();
queryFactory = new JDBCQueryMetaDataFactory(this);
if (isCMP1x) {
abstractSchemaName =
(defaultValues.getAbstractSchemaName() == null
? entityName
: defaultValues.getAbstractSchemaName());
} else {
abstractSchemaName = defaultValues.getAbstractSchemaName();
}
// datasource name
String dataSourceNameString = MetaData.getOptionalChildContent(element, "datasource");
if (dataSourceNameString != null) {
dataSourceName = dataSourceNameString;
} else {
dataSourceName = defaultValues.getDataSourceName();
}
// get the datasource mapping for this datasource (optional, but always
// set in standardjbosscmp-jdbc.xml)
String datasourceMappingString =
MetaData.getOptionalChildContent(element, "datasource-mapping");
if (datasourceMappingString != null) {
datasourceMappingName = datasourceMappingString;
datasourceMapping = jdbcApplication.getTypeMappingByName(datasourceMappingString);
if (datasourceMapping == null) {
throw new DeploymentException(
"Error in jbosscmp-jdbc.xml : "
+ "datasource-mapping "
+ datasourceMappingString
+ " not found");
}
} else if (defaultValues.datasourceMappingName != null
&& defaultValues.datasourceMapping != null) {
datasourceMappingName = null;
datasourceMapping = defaultValues.datasourceMapping;
} else {
datasourceMappingName = null;
datasourceMapping = obtainTypeMappingFromLibrary(dataSourceName);
}
// get table name
String tableStr = MetaData.getOptionalChildContent(element, "table-name");
if (tableStr != null) {
tableName = tableStr;
} else {
tableName = defaultValues.getDefaultTableName();
}
// create table? If not provided, keep default.
String createStr = MetaData.getOptionalChildContent(element, "create-table");
if (createStr != null) {
createTable = Boolean.valueOf(createStr).booleanValue();
} else {
createTable = defaultValues.getCreateTable();
}
// remove table? If not provided, keep default.
String removeStr = MetaData.getOptionalChildContent(element, "remove-table");
if (removeStr != null) {
removeTable = Boolean.valueOf(removeStr).booleanValue();
} else {
removeTable = defaultValues.getRemoveTable();
}
// alter table? If not provided, keep default.
String alterStr = MetaData.getOptionalChildContent(element, "alter-table");
if (alterStr != null) {
alterTable = Boolean.valueOf(alterStr).booleanValue();
} else {
alterTable = defaultValues.getAlterTable();
}
// get the SQL command to execute after table creation
Element posttc = MetaData.getOptionalChild(element, "post-table-create");
if (posttc != null) {
Iterator it = MetaData.getChildrenByTagName(posttc, "sql-statement");
tablePostCreateCmd = new ArrayList();
while (it.hasNext()) {
Element etmp = (Element) it.next();
tablePostCreateCmd.add(MetaData.getElementContent(etmp));
}
} else {
tablePostCreateCmd = defaultValues.getDefaultTablePostCreateCmd();
}
// read-only
String readOnlyStr = MetaData.getOptionalChildContent(element, "read-only");
if (readOnlyStr != null) {
readOnly = Boolean.valueOf(readOnlyStr).booleanValue();
} else {
readOnly = defaultValues.isReadOnly();
}
// read-time-out
String readTimeOutStr = MetaData.getOptionalChildContent(element, "read-time-out");
if (readTimeOutStr != null) {
try {
readTimeOut = Integer.parseInt(readTimeOutStr);
} catch (NumberFormatException e) {
throw new DeploymentException(
"Invalid number format in " + "read-time-out '" + readTimeOutStr + "': " + e);
}
} else {
readTimeOut = defaultValues.getReadTimeOut();
}
String sForUpStr = MetaData.getOptionalChildContent(element, "row-locking");
if (sForUpStr != null) {
rowLocking = !isReadOnly() && (Boolean.valueOf(sForUpStr).booleanValue());
} else {
rowLocking = defaultValues.hasRowLocking();
}
// primary key constraint? If not provided, keep default.
String pkStr = MetaData.getOptionalChildContent(element, "pk-constraint");
if (pkStr != null) {
primaryKeyConstraint = Boolean.valueOf(pkStr).booleanValue();
} else {
primaryKeyConstraint = defaultValues.hasPrimaryKeyConstraint();
}
// list-cache-max
String listCacheMaxStr = MetaData.getOptionalChildContent(element, "list-cache-max");
if (listCacheMaxStr != null) {
try {
listCacheMax = Integer.parseInt(listCacheMaxStr);
} catch (NumberFormatException e) {
throw new DeploymentException(
"Invalid number format in read-"
+ "ahead list-cache-max '"
+ listCacheMaxStr
+ "': "
+ e);
}
if (listCacheMax < 0) {
throw new DeploymentException(
"Negative value for read ahead " + "list-cache-max '" + listCacheMaxStr + "'.");
}
} else {
listCacheMax = defaultValues.getListCacheMax();
}
// fetch-size
String fetchSizeStr = MetaData.getOptionalChildContent(element, "fetch-size");
if (fetchSizeStr != null) {
try {
fetchSize = Integer.parseInt(fetchSizeStr);
} catch (NumberFormatException e) {
throw new DeploymentException(
"Invalid number format in " + "fetch-size '" + fetchSizeStr + "': " + e);
}
if (fetchSize < 0) {
throw new DeploymentException(
"Negative value for fetch size " + "fetch-size '" + fetchSizeStr + "'.");
}
} else {
fetchSize = defaultValues.getFetchSize();
}
String compiler = MetaData.getOptionalChildContent(element, "ql-compiler");
if (compiler == null) {
qlCompiler = defaultValues.qlCompiler;
} else {
try {
qlCompiler = GetTCLAction.getContextClassLoader().loadClass(compiler);
} catch (ClassNotFoundException e) {
throw new DeploymentException("Failed to load compiler implementation: " + compiler);
}
}
// throw runtime exceptions ? If not provided, keep default.
String throwRuntimeExceptionsStr =
MetaData.getOptionalChildContent(element, "throw-runtime-exceptions");
if (throwRuntimeExceptionsStr != null) {
throwRuntimeExceptions = Boolean.valueOf(throwRuntimeExceptionsStr).booleanValue();
} else {
throwRuntimeExceptions = defaultValues.getThrowRuntimeExceptions();
}
//
// cmp fields
//
// update all existing queries with the new read ahead value
for (Iterator cmpFieldIterator = defaultValues.cmpFields.iterator();
cmpFieldIterator.hasNext(); ) {
JDBCCMPFieldMetaData cmpField =
new JDBCCMPFieldMetaData(this, (JDBCCMPFieldMetaData) cmpFieldIterator.next());
cmpFields.add(cmpField);
cmpFieldsByName.put(cmpField.getFieldName(), cmpField);
}
// apply new configurations to the cmpfields
for (Iterator i = MetaData.getChildrenByTagName(element, "cmp-field"); i.hasNext(); ) {
Element cmpFieldElement = (Element) i.next();
String fieldName = MetaData.getUniqueChildContent(cmpFieldElement, "field-name");
JDBCCMPFieldMetaData oldCMPField = (JDBCCMPFieldMetaData) cmpFieldsByName.get(fieldName);
if (oldCMPField == null) {
throw new DeploymentException("CMP field not found : fieldName=" + fieldName);
}
JDBCCMPFieldMetaData cmpFieldMetaData =
new JDBCCMPFieldMetaData(this, cmpFieldElement, oldCMPField);
// replace the old cmp meta data with the new
cmpFieldsByName.put(fieldName, cmpFieldMetaData);
int index = cmpFields.indexOf(oldCMPField);
cmpFields.remove(oldCMPField);
cmpFields.add(index, cmpFieldMetaData);
}
// unknown primary key field
if (primaryKeyClass == java.lang.Object.class) {
Element upkElement = MetaData.getOptionalChild(element, "unknown-pk");
if (upkElement != null) {
// assume now there is only one upk field
JDBCCMPFieldMetaData oldUpkField = null;
for (Iterator iter = cmpFields.iterator(); iter.hasNext(); ) {
JDBCCMPFieldMetaData cmpField = (JDBCCMPFieldMetaData) iter.next();
if (cmpField.isUnknownPkField()) {
oldUpkField = cmpField;
break;
}
}
// IMO, this is a redundant check
if (oldUpkField == null) {
oldUpkField = new JDBCCMPFieldMetaData(this);
}
JDBCCMPFieldMetaData upkField = new JDBCCMPFieldMetaData(this, upkElement, oldUpkField);
// remove old upk field
cmpFieldsByName.remove(oldUpkField.getFieldName());
cmpFieldsByName.put(upkField.getFieldName(), upkField);
int oldUpkFieldInd = cmpFields.indexOf(oldUpkField);
cmpFields.remove(oldUpkField);
cmpFields.add(oldUpkFieldInd, upkField);
}
}
// load-loads
loadGroups.putAll(defaultValues.loadGroups);
loadLoadGroupsXml(element);
// eager-load
Element eagerLoadGroupElement = MetaData.getOptionalChild(element, "eager-load-group");
if (eagerLoadGroupElement != null) {
String eagerLoadGroupTmp = MetaData.getElementContent(eagerLoadGroupElement);
if (eagerLoadGroupTmp != null && eagerLoadGroupTmp.trim().length() == 0) {
eagerLoadGroupTmp = null;
}
if (eagerLoadGroupTmp != null
&& !eagerLoadGroupTmp.equals("*")
&& !loadGroups.containsKey(eagerLoadGroupTmp)) {
throw new DeploymentException(
"Eager load group not found: " + "eager-load-group=" + eagerLoadGroupTmp);
}
eagerLoadGroup = eagerLoadGroupTmp;
} else {
eagerLoadGroup = defaultValues.getEagerLoadGroup();
}
// lazy-loads
lazyLoadGroups.addAll(defaultValues.lazyLoadGroups);
loadLazyLoadGroupsXml(element);
// read-ahead
Element readAheadElement = MetaData.getOptionalChild(element, "read-ahead");
if (readAheadElement != null) {
readAhead = new JDBCReadAheadMetaData(readAheadElement, defaultValues.getReadAhead());
} else {
readAhead = defaultValues.readAhead;
}
String value = MetaData.getOptionalChildContent(element, "clean-read-ahead-on-load");
if ("true".equalsIgnoreCase(value)) {
cleanReadAheadOnLoad = true;
} else if ("false".equalsIgnoreCase(value)) {
cleanReadAheadOnLoad = false;
} else if (value == null) {
cleanReadAheadOnLoad = defaultValues.cleanReadAheadOnLoad;
} else {
throw new DeploymentException(
"Failed to deploy "
+ entityName
+ ": allowed values for clean-read-ahead-on-load are true and false but got "
+ value);
}
// optimistic locking group
Element optimisticLockingEl = MetaData.getOptionalChild(element, "optimistic-locking");
if (optimisticLockingEl != null) {
optimisticLocking = new JDBCOptimisticLockingMetaData(this, optimisticLockingEl);
} else {
optimisticLocking = defaultValues.getOptimisticLocking();
}
// audit
Element auditElement = MetaData.getOptionalChild(element, "audit");
if (auditElement != null) {
audit = new JDBCAuditMetaData(this, auditElement);
} else {
audit = defaultValues.getAudit();
}
// queries
// update all existing queries with the new read ahead value
for (Iterator queriesIterator = defaultValues.queries.values().iterator();
queriesIterator.hasNext(); ) {
JDBCQueryMetaData query =
JDBCQueryMetaDataFactory.createJDBCQueryMetaData(
(JDBCQueryMetaData) queriesIterator.next(), readAhead, qlCompiler);
queries.put(query.getMethod(), query);
}
// apply new configurations to the queries
for (Iterator queriesIterator = MetaData.getChildrenByTagName(element, "query");
queriesIterator.hasNext(); ) {
Element queryElement = (Element) queriesIterator.next();
Map newQueries =
queryFactory.createJDBCQueryMetaData(queryElement, defaultValues.queries, readAhead);
// overrides defaults added above
queries.putAll(newQueries);
}
// get the entity command for this entity
Element entityCommandEl = MetaData.getOptionalChild(element, "entity-command");
if (entityCommandEl != null) {
// command name in xml
String entityCommandName = entityCommandEl.getAttribute("name");
// default entity command
// The logic to assign the default value:
// - if entity-command isn't specified in the entity element,
// then it is assigned from the defaults;
// - if command name in entity equals command name in defaults
// then it is assigned from the defaults
// - else try to find a command in entity-commands with the command
// name specified in the entity.
// if the match is found it'll be the default, else default is null
JDBCEntityCommandMetaData defaultEntityCommand = defaultValues.getEntityCommand();
if ((defaultEntityCommand == null)
|| (!entityCommandName.equals(defaultEntityCommand.getCommandName()))) {
defaultEntityCommand = jdbcApplication.getEntityCommandByName(entityCommandName);
}
if (defaultEntityCommand != null) {
entityCommand = new JDBCEntityCommandMetaData(entityCommandEl, defaultEntityCommand);
} else {
entityCommand = new JDBCEntityCommandMetaData(entityCommandEl);
}
} else {
entityCommand = defaultValues.getEntityCommand();
}
}