| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.openjpa.persistence; |
| |
| import java.lang.reflect.Field; |
| import java.lang.reflect.Member; |
| import java.lang.reflect.Method; |
| import java.security.AccessController; |
| import java.security.PrivilegedActionException; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.EnumSet; |
| import java.util.HashMap; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.Stack; |
| import javax.persistence.CascadeType; |
| import javax.persistence.GenerationType; |
| import static javax.persistence.CascadeType.*; |
| |
| import org.apache.commons.lang.StringUtils; |
| import org.xml.sax.Attributes; |
| import org.xml.sax.Locator; |
| import org.xml.sax.SAXException; |
| import org.apache.openjpa.conf.OpenJPAConfiguration; |
| import org.apache.openjpa.enhance.PersistenceCapable; |
| import org.apache.openjpa.event.BeanLifecycleCallbacks; |
| import org.apache.openjpa.event.LifecycleCallbacks; |
| import org.apache.openjpa.event.LifecycleEvent; |
| import org.apache.openjpa.event.MethodLifecycleCallbacks; |
| import org.apache.openjpa.kernel.QueryLanguages; |
| import org.apache.openjpa.kernel.jpql.JPQLParser; |
| import org.apache.openjpa.lib.conf.Configurations; |
| import org.apache.openjpa.lib.log.Log; |
| import org.apache.openjpa.lib.meta.CFMetaDataParser; |
| import org.apache.openjpa.lib.util.J2DoPrivHelper; |
| import org.apache.openjpa.lib.util.Localizer; |
| import org.apache.openjpa.meta.ClassMetaData; |
| import org.apache.openjpa.meta.DelegatingMetaDataFactory; |
| import org.apache.openjpa.meta.FieldMetaData; |
| import org.apache.openjpa.meta.JavaTypes; |
| import org.apache.openjpa.meta.LifecycleMetaData; |
| import org.apache.openjpa.meta.MetaDataDefaults; |
| import org.apache.openjpa.meta.MetaDataFactory; |
| import static org.apache.openjpa.meta.MetaDataModes.*; |
| import org.apache.openjpa.meta.MetaDataRepository; |
| import org.apache.openjpa.meta.Order; |
| import org.apache.openjpa.meta.QueryMetaData; |
| import org.apache.openjpa.meta.SequenceMetaData; |
| import org.apache.openjpa.meta.ValueMetaData; |
| import static org.apache.openjpa.persistence.MetaDataTag.*; |
| import static org.apache.openjpa.persistence.PersistenceStrategy.*; |
| import org.apache.openjpa.util.ImplHelper; |
| |
| import serp.util.Numbers; |
| |
| /** |
| * Custom SAX parser used by the system to quickly parse persistence i |
| * metadata files. |
| * |
| * @author Steve Kim |
| * @nojavadoc |
| */ |
| public class XMLPersistenceMetaDataParser |
| extends CFMetaDataParser |
| implements PersistenceMetaDataFactory.Parser { |
| |
| // parse constants |
| protected static final String ELEM_PKG = "package"; |
| protected static final String ELEM_ACCESS = "access"; |
| protected static final String ELEM_ATTRS = "attributes"; |
| protected static final String ELEM_LISTENER = "entity-listener"; |
| protected static final String ELEM_CASCADE = "cascade"; |
| protected static final String ELEM_CASCADE_ALL = "cascade-all"; |
| protected static final String ELEM_CASCADE_PER = "cascade-persist"; |
| protected static final String ELEM_CASCADE_MER = "cascade-merge"; |
| protected static final String ELEM_CASCADE_REM = "cascade-remove"; |
| protected static final String ELEM_CASCADE_REF = "cascade-refresh"; |
| protected static final String ELEM_PU_META = "persistence-unit-metadata"; |
| protected static final String ELEM_PU_DEF = "persistence-unit-defaults"; |
| protected static final String ELEM_XML_MAP_META_COMPLETE = |
| "xml-mapping-metadata-complete"; |
| |
| private static final Map<String, Object> _elems = |
| new HashMap<String, Object>(); |
| |
| static { |
| _elems.put(ELEM_PKG, ELEM_PKG); |
| _elems.put(ELEM_ACCESS, ELEM_ACCESS); |
| _elems.put(ELEM_ATTRS, ELEM_ATTRS); |
| _elems.put(ELEM_LISTENER, ELEM_LISTENER); |
| _elems.put(ELEM_CASCADE, ELEM_CASCADE); |
| _elems.put(ELEM_CASCADE_ALL, ELEM_CASCADE_ALL); |
| _elems.put(ELEM_CASCADE_PER, ELEM_CASCADE_PER); |
| _elems.put(ELEM_CASCADE_REM, ELEM_CASCADE_REM); |
| _elems.put(ELEM_CASCADE_MER, ELEM_CASCADE_MER); |
| _elems.put(ELEM_CASCADE_REF, ELEM_CASCADE_REF); |
| _elems.put(ELEM_PU_META, ELEM_PU_META); |
| _elems.put(ELEM_PU_DEF, ELEM_PU_DEF); |
| _elems.put(ELEM_XML_MAP_META_COMPLETE, ELEM_XML_MAP_META_COMPLETE); |
| |
| _elems.put("entity-listeners", ENTITY_LISTENERS); |
| _elems.put("pre-persist", PRE_PERSIST); |
| _elems.put("post-persist", POST_PERSIST); |
| _elems.put("pre-remove", PRE_REMOVE); |
| _elems.put("post-remove", POST_REMOVE); |
| _elems.put("pre-update", PRE_UPDATE); |
| _elems.put("post-update", POST_UPDATE); |
| _elems.put("post-load", POST_LOAD); |
| _elems.put("exclude-default-listeners", EXCLUDE_DEFAULT_LISTENERS); |
| _elems.put("exclude-superclass-listeners", |
| EXCLUDE_SUPERCLASS_LISTENERS); |
| |
| _elems.put("named-query", QUERY); |
| _elems.put("named-native-query", NATIVE_QUERY); |
| _elems.put("query-hint", QUERY_HINT); |
| _elems.put("query", QUERY_STRING); |
| |
| _elems.put("flush-mode", FLUSH_MODE); |
| _elems.put("sequence-generator", SEQ_GENERATOR); |
| |
| _elems.put("id", ID); |
| _elems.put("id-class", ID_CLASS); |
| _elems.put("embedded-id", EMBEDDED_ID); |
| _elems.put("version", VERSION); |
| _elems.put("generated-value", GENERATED_VALUE); |
| _elems.put("map-key", MAP_KEY); |
| _elems.put("order-by", ORDER_BY); |
| _elems.put("lob", LOB); |
| |
| _elems.put("basic", BASIC); |
| _elems.put("many-to-one", MANY_ONE); |
| _elems.put("one-to-one", ONE_ONE); |
| _elems.put("embedded", EMBEDDED); |
| _elems.put("one-to-many", ONE_MANY); |
| _elems.put("many-to-many", MANY_MANY); |
| _elems.put("transient", TRANSIENT); |
| } |
| |
| private static final Localizer _loc = Localizer.forPackage |
| (XMLPersistenceMetaDataParser.class); |
| |
| private final OpenJPAConfiguration _conf; |
| private MetaDataRepository _repos = null; |
| private AnnotationPersistenceMetaDataParser _parser = null; |
| private ClassLoader _envLoader = null; |
| private int _mode = MODE_NONE; |
| private boolean _override = false; |
| |
| private final Stack _elements = new Stack(); |
| private final Stack _parents = new Stack(); |
| |
| private Class _cls = null; |
| private int _fieldPos = 0; |
| private int _clsPos = 0; |
| private int _access = ClassMetaData.ACCESS_UNKNOWN; |
| private PersistenceStrategy _strategy = null; |
| private Set<CascadeType> _cascades = null; |
| private Set<CascadeType> _pkgCascades = null; |
| |
| private Class _listener = null; |
| private Collection<LifecycleCallbacks>[] _callbacks = null; |
| private int[] _highs = null; |
| |
| /** |
| * Constructor; supply configuration. |
| */ |
| public XMLPersistenceMetaDataParser(OpenJPAConfiguration conf) { |
| _conf = conf; |
| setValidating(true); |
| setLog(conf.getLog(OpenJPAConfiguration.LOG_METADATA)); |
| setParseComments(true); |
| setMode(MODE_META | MODE_MAPPING | MODE_QUERY); |
| setParseText(true); |
| } |
| |
| /** |
| * Configuration supplied on construction. |
| */ |
| public OpenJPAConfiguration getConfiguration() { |
| return _conf; |
| } |
| |
| /** |
| * The annotation parser. When class is discovered in an XML file, |
| * we first parse any annotations present, then override with the XML. |
| */ |
| public AnnotationPersistenceMetaDataParser getAnnotationParser() { |
| return _parser; |
| } |
| |
| /** |
| * The annotation parser. When class is discovered in an XML file, |
| * we first parse any annotations present, then override with the XML. |
| */ |
| public void setAnnotationParser(AnnotationPersistenceMetaDataParser parser){ |
| _parser = parser; |
| } |
| |
| /** |
| * Returns the repository for this parser. If none has been set, creates |
| * a new repository and sets it. |
| */ |
| public MetaDataRepository getRepository() { |
| if (_repos == null) { |
| MetaDataRepository repos = _conf.newMetaDataRepositoryInstance(); |
| MetaDataFactory mdf = repos.getMetaDataFactory(); |
| if (mdf instanceof DelegatingMetaDataFactory) |
| mdf = ((DelegatingMetaDataFactory) mdf).getInnermostDelegate(); |
| if (mdf instanceof PersistenceMetaDataFactory) |
| ((PersistenceMetaDataFactory) mdf).setXMLParser(this); |
| _repos = repos; |
| } |
| return _repos; |
| } |
| |
| /** |
| * Set the metadata repository for this parser. |
| */ |
| public void setRepository(MetaDataRepository repos) { |
| _repos = repos; |
| if (repos != null |
| && (repos.getValidate() & repos.VALIDATE_RUNTIME) != 0) |
| setParseComments(false); |
| } |
| |
| /** |
| * Return the environmental class loader to pass on to parsed |
| * metadata instances. |
| */ |
| public ClassLoader getEnvClassLoader() { |
| return _envLoader; |
| } |
| |
| /** |
| * Set the environmental class loader to pass on to parsed |
| * metadata instances. |
| */ |
| public void setEnvClassLoader(ClassLoader loader) { |
| _envLoader = loader; |
| } |
| |
| /** |
| * Whether to allow later parses of mapping information to override |
| * earlier information for the same class. Defaults to false. Useful |
| * when a tool is mapping a class, so that .jdo file partial mapping |
| * information can be used even when mappings are stored in .orm files |
| * or other locations. |
| */ |
| public boolean getMappingOverride() { |
| return _override; |
| } |
| |
| /** |
| * Whether to allow later parses of mapping information to override |
| * earlier information for the same class. Defaults to false. Useful |
| * when a tool is mapping a class, so that .jdo file partial mapping |
| * information can be used even when mappings are stored in .orm files |
| * or other locations. |
| */ |
| public void setMappingOverride(boolean override) { |
| _override = override; |
| } |
| |
| /** |
| * The parse mode according to the expected document type. The |
| * mode constants act as bit flags, and therefore can be combined. |
| */ |
| public int getMode() { |
| return _mode; |
| } |
| |
| /** |
| * The parse mode according to the expected document type. |
| */ |
| public void setMode(int mode, boolean on) { |
| if (mode == MODE_NONE) |
| setMode(MODE_NONE); |
| else if (on) |
| setMode(_mode | mode); |
| else |
| setMode(_mode & ~mode); |
| } |
| |
| /** |
| * The parse mode according to the expected document type. |
| */ |
| public void setMode(int mode) { |
| _mode = mode; |
| if (_parser != null) |
| _parser.setMode(mode); |
| } |
| |
| /** |
| * Convenience method for interpreting {@link #getMode}. |
| */ |
| protected boolean isMetaDataMode() { |
| return (_mode & MODE_META) != 0; |
| } |
| |
| /** |
| * Convenience method for interpreting {@link #getMode}. |
| */ |
| protected boolean isQueryMode() { |
| return (_mode & MODE_QUERY) != 0; |
| } |
| |
| /** |
| * Convenience method for interpreting {@link #getMode}. |
| */ |
| protected boolean isMappingMode() { |
| return (_mode & MODE_MAPPING) != 0; |
| } |
| |
| /** |
| * Returns true if we're in mapping mode or in metadata mode with |
| * mapping override enabled. |
| */ |
| protected boolean isMappingOverrideMode() { |
| return isMappingMode() || (_override && isMetaDataMode()); |
| } |
| |
| /////////////// |
| // XML parsing |
| /////////////// |
| |
| /** |
| * Push a parse element onto the stack. |
| */ |
| protected void pushElement(Object elem) { |
| _elements.push(elem); |
| } |
| |
| /** |
| * Pop a parse element from the stack. |
| */ |
| protected Object popElement() { |
| return _elements.pop(); |
| } |
| |
| /** |
| * Return the current element being parsed. May be a class metadata, |
| * field metadata, query metadata, etc. |
| */ |
| protected Object currentElement() { |
| if (_elements.isEmpty()) |
| return null; |
| return _elements.peek(); |
| } |
| |
| /** |
| * Return the current {@link PersistenceStrategy} if any. |
| */ |
| protected PersistenceStrategy currentStrategy() { |
| return _strategy; |
| } |
| |
| /** |
| * Return the tag of the current parent element. |
| */ |
| protected Object currentParent() { |
| if (_parents.isEmpty()) |
| return null; |
| return _parents.peek(); |
| } |
| |
| /** |
| * Return whether we're running the parser at runtime. |
| */ |
| protected boolean isRuntime() { |
| return (getRepository().getValidate() |
| & MetaDataRepository.VALIDATE_RUNTIME) != 0; |
| } |
| |
| @Override |
| protected Object getSchemaSource() { |
| return XMLPersistenceMetaDataParser.class.getResourceAsStream |
| ("orm-xsd.rsrc"); |
| } |
| |
| @Override |
| protected String getPackageAttributeName() { |
| return null; |
| } |
| |
| @Override |
| protected String getClassAttributeName() { |
| return "class"; |
| } |
| |
| @Override |
| protected int getClassElementDepth() { |
| return 1; |
| } |
| |
| @Override |
| protected boolean isClassElementName(String name) { |
| return "entity".equals(name) |
| || "embeddable".equals(name) |
| || "mapped-superclass".equals(name); |
| } |
| |
| @Override |
| protected void reset() { |
| super.reset(); |
| _elements.clear(); |
| _parents.clear(); |
| _cls = null; |
| _fieldPos = 0; |
| _clsPos = 0; |
| |
| _access = ClassMetaData.ACCESS_UNKNOWN; |
| _strategy = null; |
| _listener = null; |
| _callbacks = null; |
| _highs = null; |
| _cascades = null; |
| _pkgCascades = null; |
| } |
| |
| @Override |
| protected boolean startSystemElement(String name, Attributes attrs) |
| throws SAXException { |
| Object tag = (Object) _elems.get(name); |
| boolean ret = false; |
| if (tag == null) { |
| if (isMappingOverrideMode()) |
| tag = startSystemMappingElement(name, attrs); |
| ret = tag != null; |
| } else if (tag instanceof MetaDataTag) { |
| switch ((MetaDataTag) tag) { |
| case QUERY: |
| ret = startNamedQuery(attrs); |
| break; |
| case QUERY_HINT: |
| ret = startQueryHint(attrs); |
| break; |
| case NATIVE_QUERY: |
| ret = startNamedNativeQuery(attrs); |
| break; |
| case QUERY_STRING: |
| ret = startQueryString(attrs); |
| break; |
| case SEQ_GENERATOR: |
| ret = startSequenceGenerator(attrs); |
| break; |
| case FLUSH_MODE: |
| ret = startFlushMode(attrs); |
| break; |
| case ENTITY_LISTENERS: |
| ret = startEntityListeners(attrs); |
| break; |
| case PRE_PERSIST: |
| case POST_PERSIST: |
| case PRE_REMOVE: |
| case POST_REMOVE: |
| case PRE_UPDATE: |
| case POST_UPDATE: |
| case POST_LOAD: |
| ret = startCallback((MetaDataTag) tag, attrs); |
| break; |
| default: |
| warnUnsupportedTag(name); |
| } |
| } else if (tag == ELEM_PU_META || tag == ELEM_PU_DEF) |
| ret = isMetaDataMode(); |
| else if (tag == ELEM_XML_MAP_META_COMPLETE) |
| setAnnotationParser(null); |
| else if (tag == ELEM_ACCESS) |
| ret = _mode != MODE_QUERY; |
| else if (tag == ELEM_LISTENER) |
| ret = startEntityListener(attrs); |
| else if (tag == ELEM_CASCADE) |
| ret = isMetaDataMode(); |
| else if (tag == ELEM_CASCADE_ALL || tag == ELEM_CASCADE_PER |
| || tag == ELEM_CASCADE_MER || tag == ELEM_CASCADE_REM |
| || tag == ELEM_CASCADE_REF) |
| ret = startCascade(tag, attrs); |
| |
| if (ret) |
| _parents.push(tag); |
| return ret; |
| } |
| |
| @Override |
| protected void endSystemElement(String name) |
| throws SAXException { |
| Object tag = _elems.get(name); |
| if (tag == null && isMappingOverrideMode()) |
| endSystemMappingElement(name); |
| else if (tag instanceof MetaDataTag) { |
| switch ((MetaDataTag) tag) { |
| case QUERY: |
| endNamedQuery(); |
| break; |
| case QUERY_HINT: |
| endQueryHint(); |
| break; |
| case NATIVE_QUERY: |
| endNamedNativeQuery(); |
| break; |
| case QUERY_STRING: |
| endQueryString(); |
| break; |
| case SEQ_GENERATOR: |
| endSequenceGenerator(); |
| break; |
| } |
| } else if (tag == ELEM_ACCESS) |
| endAccess(); |
| else if (tag == ELEM_LISTENER) |
| endEntityListener(); |
| |
| _parents.pop(); |
| } |
| |
| /** |
| * Implement to parse a mapping element outside of any class. |
| * |
| * @return the tag for the given element, or null to skip the element |
| */ |
| protected Object startSystemMappingElement(String name, Attributes attrs) |
| throws SAXException { |
| return null; |
| } |
| |
| /** |
| * Implement to parse a mapping element outside of any class. |
| */ |
| protected void endSystemMappingElement(String name) |
| throws SAXException { |
| } |
| |
| @Override |
| protected boolean startClassElement(String name, Attributes attrs) |
| throws SAXException { |
| Object tag = (Object) _elems.get(name); |
| boolean ret = false; |
| if (tag == null) { |
| if (isMappingOverrideMode()) |
| tag = startClassMappingElement(name, attrs); |
| ret = tag != null; |
| } else if (tag instanceof MetaDataTag) { |
| switch ((MetaDataTag) tag) { |
| case GENERATED_VALUE: |
| ret = startGeneratedValue(attrs); |
| break; |
| case ID: |
| ret = startId(attrs); |
| break; |
| case EMBEDDED_ID: |
| ret = startEmbeddedId(attrs); |
| break; |
| case ID_CLASS: |
| ret = startIdClass(attrs); |
| break; |
| case LOB: |
| ret = startLob(attrs); |
| break; |
| case QUERY: |
| ret = startNamedQuery(attrs); |
| break; |
| case QUERY_HINT: |
| ret = startQueryHint(attrs); |
| break; |
| case NATIVE_QUERY: |
| ret = startNamedNativeQuery(attrs); |
| break; |
| case QUERY_STRING: |
| ret = startQueryString(attrs); |
| break; |
| case SEQ_GENERATOR: |
| ret = startSequenceGenerator(attrs); |
| break; |
| case VERSION: |
| ret = startVersion(attrs); |
| break; |
| case MAP_KEY: |
| ret = startMapKey(attrs); |
| break; |
| case FLUSH_MODE: |
| ret = startFlushMode(attrs); |
| break; |
| case ORDER_BY: |
| case ENTITY_LISTENERS: |
| ret = isMetaDataMode(); |
| break; |
| case EXCLUDE_DEFAULT_LISTENERS: |
| ret = startExcludeDefaultListeners(attrs); |
| break; |
| case EXCLUDE_SUPERCLASS_LISTENERS: |
| ret = startExcludeSuperclassListeners(attrs); |
| break; |
| case PRE_PERSIST: |
| case POST_PERSIST: |
| case PRE_REMOVE: |
| case POST_REMOVE: |
| case PRE_UPDATE: |
| case POST_UPDATE: |
| case POST_LOAD: |
| ret = startCallback((MetaDataTag) tag, attrs); |
| break; |
| default: |
| warnUnsupportedTag(name); |
| } |
| } else if (tag instanceof PersistenceStrategy) { |
| PersistenceStrategy ps = (PersistenceStrategy) tag; |
| ret = startStrategy(ps, attrs); |
| if (ret) |
| _strategy = ps; |
| } else if (tag == ELEM_LISTENER) |
| ret = startEntityListener(attrs); |
| else if (tag == ELEM_ATTRS) |
| ret = _mode != MODE_QUERY; |
| else if (tag == ELEM_CASCADE) |
| ret = isMetaDataMode(); |
| else if (tag == ELEM_CASCADE_ALL || tag == ELEM_CASCADE_PER |
| || tag == ELEM_CASCADE_MER || tag == ELEM_CASCADE_REM |
| || tag == ELEM_CASCADE_REF) |
| ret = startCascade(tag, attrs); |
| |
| if (ret) |
| _parents.push(tag); |
| return ret; |
| } |
| |
| @Override |
| protected void endClassElement(String name) |
| throws SAXException { |
| Object tag = _elems.get(name); |
| if (tag == null && isMappingOverrideMode()) |
| endClassMappingElement(name); |
| else if (tag instanceof MetaDataTag) { |
| switch ((MetaDataTag) tag) { |
| case GENERATED_VALUE: |
| endGeneratedValue(); |
| break; |
| case ID: |
| endId(); |
| break; |
| case EMBEDDED_ID: |
| endEmbeddedId(); |
| break; |
| case ID_CLASS: |
| endIdClass(); |
| break; |
| case LOB: |
| endLob(); |
| break; |
| case QUERY: |
| endNamedQuery(); |
| break; |
| case QUERY_HINT: |
| endQueryHint(); |
| break; |
| case NATIVE_QUERY: |
| endNamedNativeQuery(); |
| break; |
| case QUERY_STRING: |
| endQueryString(); |
| break; |
| case SEQ_GENERATOR: |
| endSequenceGenerator(); |
| break; |
| case VERSION: |
| endVersion(); |
| break; |
| case ORDER_BY: |
| endOrderBy(); |
| break; |
| } |
| } else if (tag instanceof PersistenceStrategy) |
| endStrategy((PersistenceStrategy) tag); |
| else if (tag == ELEM_ACCESS) |
| endAccess(); |
| else if (tag == ELEM_LISTENER) |
| endEntityListener(); |
| |
| _parents.pop(); |
| } |
| |
| /** |
| * Log warning about an unsupported tag. |
| */ |
| private void warnUnsupportedTag(String name) { |
| Log log = getLog(); |
| if (log.isInfoEnabled()) |
| log.trace(_loc.get("unsupported-tag", name)); |
| } |
| |
| /** |
| * Implement to parse a mapping element within a class. |
| * |
| * @return the tag for the given element, or null to skip element |
| */ |
| protected Object startClassMappingElement(String name, Attributes attrs) |
| throws SAXException { |
| return null; |
| } |
| |
| /** |
| * Implement to parse a mapping element within a class. |
| */ |
| protected void endClassMappingElement(String name) |
| throws SAXException { |
| } |
| |
| @Override |
| protected boolean startClass(String elem, Attributes attrs) |
| throws SAXException { |
| super.startClass(elem, attrs); |
| |
| // query mode only? |
| _cls = classForName(currentClassName()); |
| if (_mode == MODE_QUERY) { |
| if (_parser != null && |
| !"true".equals(attrs.getValue("metadata-complete"))) |
| _parser.parse(_cls); |
| return true; |
| } |
| |
| Log log = getLog(); |
| if (log.isTraceEnabled()) |
| log.trace(_loc.get("parse-class", _cls.getName())); |
| |
| MetaDataRepository repos = getRepository(); |
| ClassMetaData meta = repos.getCachedMetaData(_cls); |
| if (meta != null |
| && ((isMetaDataMode() && (meta.getSourceMode() & MODE_META) != 0) |
| || (isMappingMode() && (meta.getSourceMode() & MODE_MAPPING) != 0))) |
| { |
| if (log.isWarnEnabled()) |
| log.warn(_loc.get("dup-metadata", _cls, getSourceName())); |
| _cls = null; |
| return false; |
| } |
| |
| // if we don't know the access type, check to see if a superclass |
| // has already defined the access type |
| int defaultAccess = _access; |
| if (defaultAccess == ClassMetaData.ACCESS_UNKNOWN) { |
| ClassMetaData sup = repos.getCachedMetaData(_cls.getSuperclass()); |
| if (sup != null) |
| defaultAccess = sup.getAccessType(); |
| } |
| |
| if (meta == null) { |
| // add metadata for this type |
| int access = toAccessType(attrs.getValue("access"), defaultAccess); |
| meta = repos.addMetaData(_cls, access); |
| meta.setEnvClassLoader(_envLoader); |
| meta.setSourceMode(MODE_NONE); |
| |
| // parse annotations first so XML overrides them |
| if (_parser != null && |
| !"true".equals(attrs.getValue("metadata-complete"))) |
| _parser.parse(_cls); |
| } |
| |
| boolean mappedSuper = "mapped-superclass".equals(elem); |
| if (isMetaDataMode()) { |
| meta.setSource(getSourceFile(), meta.SRC_XML); |
| meta.setSourceMode(MODE_META, true); |
| Locator locator = getLocation().getLocator(); |
| if (locator != null) { |
| meta.setLineNumber(Numbers.valueOf(locator.getLineNumber())); |
| meta.setColNumber(Numbers.valueOf(locator.getColumnNumber())); |
| } |
| meta.setListingIndex(_clsPos); |
| String name = attrs.getValue("name"); |
| if (!StringUtils.isEmpty(name)) |
| meta.setTypeAlias(name); |
| meta.setAbstract(mappedSuper); |
| meta.setEmbeddedOnly(mappedSuper || "embeddable".equals(elem)); |
| if (mappedSuper) |
| meta.setIdentityType(meta.ID_UNKNOWN); |
| } |
| if (isMappingMode()) |
| meta.setSourceMode(MODE_MAPPING, true); |
| if (isMappingOverrideMode()) |
| startClassMapping(meta, mappedSuper, attrs); |
| if (isQueryMode()) |
| meta.setSourceMode(MODE_QUERY, true); |
| |
| _clsPos++; |
| _fieldPos = 0; |
| addComments(meta); |
| pushElement(meta); |
| return true; |
| } |
| |
| @Override |
| protected void endClass(String elem) |
| throws SAXException { |
| if (_mode != MODE_QUERY) { |
| ClassMetaData meta = (ClassMetaData) popElement(); |
| storeCallbacks(meta); |
| if (isMappingOverrideMode()) |
| endClassMapping(meta); |
| } |
| _cls = null; |
| super.endClass(elem); |
| } |
| |
| /** |
| * Implement to add mapping attributes to class. |
| */ |
| protected void startClassMapping(ClassMetaData mapping, |
| boolean mappedSuper, Attributes attrs) |
| throws SAXException { |
| } |
| |
| /** |
| * Implement to finalize class mapping. |
| */ |
| protected void endClassMapping(ClassMetaData mapping) |
| throws SAXException { |
| } |
| |
| /** |
| * Default access element. |
| */ |
| private void endAccess() { |
| _access = toAccessType(currentText(), ClassMetaData.ACCESS_UNKNOWN); |
| } |
| |
| /** |
| * Parse the given string as an entity access type, defaulting to given |
| * default if string is empty. |
| */ |
| private int toAccessType(String str, int def) { |
| if (StringUtils.isEmpty(str)) |
| return def; |
| if ("PROPERTY".equals(str)) |
| return ClassMetaData.ACCESS_PROPERTY; |
| return ClassMetaData.ACCESS_FIELD; |
| } |
| |
| /** |
| * Parse flush-mode element. |
| */ |
| private boolean startFlushMode(Attributes attrs) |
| throws SAXException { |
| Log log = getLog(); |
| if (log.isWarnEnabled()) |
| log.warn(_loc.get("unsupported", "flush-mode", getSourceName())); |
| return false; |
| } |
| |
| /** |
| * Parse sequence-generator. |
| */ |
| protected boolean startSequenceGenerator(Attributes attrs) { |
| if (!isMappingOverrideMode()) |
| return false; |
| |
| String name = attrs.getValue("name"); |
| Log log = getLog(); |
| if (log.isTraceEnabled()) |
| log.trace(_loc.get("parse-sequence", name)); |
| |
| SequenceMetaData meta = getRepository().getCachedSequenceMetaData(name); |
| if (meta != null && log.isWarnEnabled()) |
| log.warn(_loc.get("override-sequence", name)); |
| |
| meta = getRepository().addSequenceMetaData(name); |
| String seq = attrs.getValue("sequence-name"); |
| String val = attrs.getValue("initial-value"); |
| int initial = val == null ? 1 : Integer.parseInt(val); |
| val = attrs.getValue("allocation-size"); |
| int allocate = val == null ? 50 : Integer.parseInt(val); |
| |
| String clsName, props; |
| if (seq == null || seq.indexOf('(') == -1) { |
| clsName = SequenceMetaData.IMPL_NATIVE; |
| props = null; |
| } else { // plugin |
| clsName = Configurations.getClassName(seq); |
| props = Configurations.getProperties(seq); |
| seq = null; |
| } |
| |
| meta.setSequencePlugin(Configurations.getPlugin(clsName, props)); |
| meta.setSequence(seq); |
| meta.setInitialValue(initial); |
| meta.setAllocate(allocate); |
| |
| Object cur = currentElement(); |
| Object scope = (cur instanceof ClassMetaData) |
| ? ((ClassMetaData) cur).getDescribedType() : null; |
| meta.setSource(getSourceFile(), scope, meta.SRC_XML); |
| Locator locator = getLocation().getLocator(); |
| if (locator != null) { |
| meta.setLineNumber(Numbers.valueOf(locator.getLineNumber())); |
| meta.setColNumber(Numbers.valueOf(locator.getColumnNumber())); |
| } |
| return true; |
| } |
| |
| protected void endSequenceGenerator() { |
| } |
| |
| /** |
| * Parse id. |
| */ |
| protected boolean startId(Attributes attrs) |
| throws SAXException { |
| FieldMetaData fmd = parseField(attrs); |
| fmd.setExplicit(true); |
| fmd.setPrimaryKey(true); |
| return true; |
| } |
| |
| protected void endId() |
| throws SAXException { |
| finishField(); |
| } |
| |
| /** |
| * Parse embedded-id. |
| */ |
| protected boolean startEmbeddedId(Attributes attrs) |
| throws SAXException { |
| FieldMetaData fmd = parseField(attrs); |
| fmd.setExplicit(true); |
| fmd.setPrimaryKey(true); |
| fmd.setEmbedded(true); |
| if (fmd.getEmbeddedMetaData() == null) |
| fmd.addEmbeddedMetaData(); |
| return true; |
| } |
| |
| protected void endEmbeddedId() |
| throws SAXException { |
| finishField(); |
| } |
| |
| /** |
| * Parse id-class. |
| */ |
| protected boolean startIdClass(Attributes attrs) |
| throws SAXException { |
| if (!isMetaDataMode()) |
| return false; |
| |
| ClassMetaData meta = (ClassMetaData) currentElement(); |
| String cls = attrs.getValue("class"); |
| Class idCls = null; |
| try { |
| idCls = classForName(cls); |
| } catch (Throwable t) { |
| throw getException(_loc.get("invalid-id-class", meta, cls), t); |
| } |
| meta.setObjectIdType(idCls, true); |
| return true; |
| } |
| |
| protected void endIdClass() |
| throws SAXException { |
| } |
| |
| /** |
| * Parse lob. |
| */ |
| protected boolean startLob(Attributes attrs) |
| throws SAXException { |
| FieldMetaData fmd = (FieldMetaData) currentElement(); |
| if (fmd.getDeclaredTypeCode() != JavaTypes.STRING |
| && fmd.getDeclaredType() != char[].class |
| && fmd.getDeclaredType() != Character[].class |
| && fmd.getDeclaredType() != byte[].class |
| && fmd.getDeclaredType() != Byte[].class) |
| fmd.setSerialized(true); |
| return true; |
| } |
| |
| protected void endLob() |
| throws SAXException { |
| } |
| |
| /** |
| * Parse generated-value. |
| */ |
| protected boolean startGeneratedValue(Attributes attrs) |
| throws SAXException { |
| if (!isMappingOverrideMode()) |
| return false; |
| |
| String strategy = attrs.getValue("strategy"); |
| String generator = attrs.getValue("generator"); |
| GenerationType type = StringUtils.isEmpty(strategy) |
| ? GenerationType.AUTO : GenerationType.valueOf(strategy); |
| |
| FieldMetaData fmd = (FieldMetaData) currentElement(); |
| AnnotationPersistenceMetaDataParser.parseGeneratedValue(fmd, type, |
| generator); |
| return true; |
| } |
| |
| protected void endGeneratedValue() |
| throws SAXException { |
| } |
| |
| /** |
| * Lazily parse cascades. |
| */ |
| protected boolean startCascade(Object tag, Attributes attrs) |
| throws SAXException { |
| if (!isMetaDataMode()) |
| return false; |
| |
| Set<CascadeType> cascades = null; |
| if (currentElement() instanceof FieldMetaData) { |
| if (_cascades == null) |
| _cascades = EnumSet.noneOf(CascadeType.class); |
| cascades = _cascades; |
| } else { |
| if (_pkgCascades == null) |
| _pkgCascades = EnumSet.noneOf(CascadeType.class); |
| cascades = _pkgCascades; |
| } |
| boolean all = ELEM_CASCADE_ALL == tag; |
| if (all || ELEM_CASCADE_PER == tag) |
| cascades.add(PERSIST); |
| if (all || ELEM_CASCADE_REM == tag) |
| cascades.add(REMOVE); |
| if (all || ELEM_CASCADE_MER == tag) |
| cascades.add(MERGE); |
| if (all || ELEM_CASCADE_REF == tag) |
| cascades.add(REFRESH); |
| return true; |
| } |
| |
| /** |
| * Set the cached cascades into the field. |
| */ |
| protected void setCascades(FieldMetaData fmd) { |
| Set<CascadeType> cascades = _cascades; |
| if (_cascades == null) |
| cascades = _pkgCascades; |
| if (cascades == null) |
| return; |
| |
| ValueMetaData vmd = fmd; |
| switch (_strategy) { |
| case ONE_MANY: |
| case MANY_MANY: |
| vmd = fmd.getElement(); |
| } |
| for (CascadeType cascade : cascades) { |
| switch (cascade) { |
| case PERSIST: |
| vmd.setCascadePersist(ValueMetaData.CASCADE_IMMEDIATE); |
| break; |
| case MERGE: |
| vmd.setCascadeAttach(ValueMetaData.CASCADE_IMMEDIATE); |
| break; |
| case REMOVE: |
| vmd.setCascadeDelete(ValueMetaData.CASCADE_IMMEDIATE); |
| break; |
| case REFRESH: |
| vmd.setCascadeRefresh(ValueMetaData.CASCADE_IMMEDIATE); |
| break; |
| } |
| } |
| _cascades = null; |
| } |
| |
| /** |
| * Parse common field attributes. |
| */ |
| private FieldMetaData parseField(Attributes attrs) |
| throws SAXException { |
| ClassMetaData meta = (ClassMetaData) currentElement(); |
| String name = attrs.getValue("name"); |
| FieldMetaData field = meta.getDeclaredField(name); |
| if ((field == null || field.getDeclaredType() == Object.class) |
| && meta.getDescribedType() != Object.class) { |
| Member member = null; |
| Class type = null; |
| int def = _repos.getMetaDataFactory().getDefaults(). |
| getDefaultAccessType(); |
| try { |
| if (meta.getAccessType() == ClassMetaData.ACCESS_PROPERTY |
| || (meta.getAccessType() == ClassMetaData.ACCESS_UNKNOWN |
| && def == ClassMetaData.ACCESS_PROPERTY)) { |
| String cap = StringUtils.capitalize(name); |
| type = meta.getDescribedType(); |
| try { |
| member = (Method) AccessController.doPrivileged( |
| J2DoPrivHelper.getDeclaredMethodAction( |
| type, "get" + cap, |
| (Class[]) null));// varargs disambiguate |
| } catch (Exception excep) { |
| try { |
| member = (Method) AccessController.doPrivileged( |
| J2DoPrivHelper.getDeclaredMethodAction( |
| type, "is" + cap, (Class[]) null)); |
| } catch (Exception excep2) { |
| throw excep; |
| } |
| } |
| type = ((Method) member).getReturnType(); |
| } else { |
| member = (Field) AccessController.doPrivileged( |
| J2DoPrivHelper.getDeclaredFieldAction( |
| meta.getDescribedType(), name)); |
| type = ((Field) member).getType(); |
| } |
| } catch (Exception e) { |
| if (e instanceof PrivilegedActionException) |
| e = ((PrivilegedActionException) e).getException(); |
| throw getException(_loc.get("invalid-attr", name, meta), e); |
| } |
| |
| if (field == null) { |
| field = meta.addDeclaredField(name, type); |
| PersistenceMetaDataDefaults.setCascadeNone(field); |
| PersistenceMetaDataDefaults.setCascadeNone(field.getKey()); |
| PersistenceMetaDataDefaults.setCascadeNone(field.getElement()); |
| } |
| field.backingMember(member); |
| } else if (field == null) { |
| field = meta.addDeclaredField(name, Object.class); |
| PersistenceMetaDataDefaults.setCascadeNone(field); |
| PersistenceMetaDataDefaults.setCascadeNone(field.getKey()); |
| PersistenceMetaDataDefaults.setCascadeNone(field.getElement()); |
| } |
| |
| if (isMetaDataMode()) |
| field.setListingIndex(_fieldPos); |
| |
| _fieldPos++; |
| pushElement(field); |
| addComments(field); |
| |
| if (isMappingOverrideMode()) |
| startFieldMapping(field, attrs); |
| return field; |
| } |
| |
| /** |
| * Pops field element. |
| */ |
| private void finishField() |
| throws SAXException { |
| FieldMetaData field = (FieldMetaData) popElement(); |
| setCascades(field); |
| if (isMappingOverrideMode()) |
| endFieldMapping(field); |
| _strategy = null; |
| } |
| |
| /** |
| * Implement to add field mapping data. Does nothing by default. |
| */ |
| protected void startFieldMapping(FieldMetaData field, Attributes attrs) |
| throws SAXException { |
| } |
| |
| /** |
| * Implement to finalize field mapping. Does nothing by default. |
| */ |
| protected void endFieldMapping(FieldMetaData field) |
| throws SAXException { |
| } |
| |
| /** |
| * Parse version. |
| */ |
| protected boolean startVersion(Attributes attrs) |
| throws SAXException { |
| FieldMetaData fmd = parseField(attrs); |
| fmd.setExplicit(true); |
| fmd.setVersion(true); |
| return true; |
| } |
| |
| protected void endVersion() |
| throws SAXException { |
| finishField(); |
| } |
| |
| /** |
| * Parse strategy element. |
| */ |
| private boolean startStrategy(PersistenceStrategy strategy, |
| Attributes attrs) |
| throws SAXException { |
| FieldMetaData fmd = parseField(attrs); |
| fmd.setExplicit(true); |
| fmd.setManagement(FieldMetaData.MANAGE_PERSISTENT); |
| |
| String val = attrs.getValue("fetch"); |
| if (val != null) |
| fmd.setInDefaultFetchGroup("EAGER".equals(val)); |
| val = attrs.getValue("optional"); |
| if ("false".equals(val)) |
| fmd.setNullValue(FieldMetaData.NULL_EXCEPTION); |
| else if ("true".equals(val) |
| && fmd.getNullValue() == FieldMetaData.NULL_EXCEPTION) { |
| // Reset value if the field was annotated with optional=false. |
| // Otherwise leave it alone. |
| fmd.setNullValue(FieldMetaData.NULL_UNSET); |
| } |
| if (isMappingOverrideMode()) { |
| val = attrs.getValue("mapped-by"); |
| if (val != null) |
| fmd.setMappedBy(val); |
| } |
| parseStrategy(fmd, strategy, attrs); |
| return true; |
| } |
| |
| private void endStrategy(PersistenceStrategy strategy) |
| throws SAXException { |
| finishField(); |
| } |
| |
| /** |
| * Parse strategy specific attributes. |
| */ |
| private void parseStrategy(FieldMetaData fmd, |
| PersistenceStrategy strategy, Attributes attrs) |
| throws SAXException { |
| switch (strategy) { |
| case BASIC: |
| parseBasic(fmd, attrs); |
| break; |
| case EMBEDDED: |
| parseEmbedded(fmd, attrs); |
| break; |
| case ONE_ONE: |
| parseOneToOne(fmd, attrs); |
| break; |
| case MANY_ONE: |
| parseManyToOne(fmd, attrs); |
| break; |
| case MANY_MANY: |
| parseManyToMany(fmd, attrs); |
| break; |
| case ONE_MANY: |
| parseOneToMany(fmd, attrs); |
| break; |
| case TRANSIENT: |
| fmd.setManagement(FieldMetaData.MANAGE_NONE); |
| break; |
| } |
| } |
| |
| /** |
| * Parse basic. |
| */ |
| protected void parseBasic(FieldMetaData fmd, Attributes attrs) |
| throws SAXException { |
| } |
| |
| /** |
| * Parse embedded. |
| */ |
| protected void parseEmbedded(FieldMetaData fmd, Attributes attrs) |
| throws SAXException { |
| assertPC(fmd, "Embedded"); |
| fmd.setEmbedded(true); |
| fmd.setSerialized(false); // override any Lob annotation |
| if (fmd.getEmbeddedMetaData() == null) |
| fmd.addEmbeddedMetaData(); |
| } |
| |
| /** |
| * Throw proper exception if given value is not possibly persistence |
| * capable. |
| */ |
| private void assertPC(FieldMetaData fmd, String attr) |
| throws SAXException { |
| if (!JavaTypes.maybePC(fmd)) |
| throw getException(_loc.get("bad-meta-anno", fmd, attr)); |
| } |
| |
| /** |
| * Parse one-to-one. |
| */ |
| protected void parseOneToOne(FieldMetaData fmd, Attributes attrs) |
| throws SAXException { |
| String val = attrs.getValue("target-entity"); |
| if (val != null) |
| fmd.setTypeOverride(classForName(val)); |
| assertPC(fmd, "OneToOne"); |
| fmd.setSerialized(false); // override any Lob annotation |
| if (!fmd.isDefaultFetchGroupExplicit()) |
| fmd.setInDefaultFetchGroup(true); |
| } |
| |
| /** |
| * Parse many-to-one. |
| */ |
| protected void parseManyToOne(FieldMetaData fmd, Attributes attrs) |
| throws SAXException { |
| String val = attrs.getValue("target-entity"); |
| if (val != null) |
| fmd.setTypeOverride(classForName(val)); |
| assertPC(fmd, "ManyToOne"); |
| fmd.setSerialized(false); // override any Lob annotation |
| if (!fmd.isDefaultFetchGroupExplicit()) |
| fmd.setInDefaultFetchGroup(true); |
| } |
| |
| /** |
| * Parse many-to-many. |
| */ |
| protected void parseManyToMany(FieldMetaData fmd, Attributes attrs) |
| throws SAXException { |
| String val = attrs.getValue("target-entity"); |
| if (val != null) |
| fmd.getElement().setDeclaredType(classForName(val)); |
| assertPCCollection(fmd, "ManyToMany"); |
| fmd.setSerialized(false); // override Lob in annotation |
| } |
| |
| /** |
| * Throw exception if given field not a collection of possible persistence |
| * capables. |
| */ |
| private void assertPCCollection(FieldMetaData fmd, String attr) |
| throws SAXException { |
| switch (fmd.getDeclaredTypeCode()) { |
| case JavaTypes.ARRAY: |
| case JavaTypes.COLLECTION: |
| case JavaTypes.MAP: |
| if (JavaTypes.maybePC(fmd.getElement())) |
| break; |
| // no break |
| default: |
| throw getException(_loc.get("bad-meta-anno", fmd, attr)); |
| } |
| } |
| |
| /** |
| * Parse one-to-many. |
| */ |
| protected void parseOneToMany(FieldMetaData fmd, Attributes attrs) |
| throws SAXException { |
| String val = attrs.getValue("target-entity"); |
| if (val != null) |
| fmd.getElement().setDeclaredType(classForName(val)); |
| assertPCCollection(fmd, "OneToMany"); |
| fmd.setSerialized(false); // override any Lob annotation |
| } |
| |
| /** |
| * Parse map-key. |
| */ |
| private boolean startMapKey(Attributes attrs) |
| throws SAXException { |
| if (!isMappingOverrideMode()) |
| return false; |
| |
| FieldMetaData fmd = (FieldMetaData) currentElement(); |
| String mapKey = attrs.getValue("name"); |
| if (mapKey == null) |
| fmd.getKey().setValueMappedBy(ValueMetaData.MAPPED_BY_PK); |
| else |
| fmd.getKey().setValueMappedBy(mapKey); |
| return true; |
| } |
| |
| /** |
| * Parse order-by. |
| */ |
| private void endOrderBy() |
| throws SAXException { |
| FieldMetaData fmd = (FieldMetaData) currentElement(); |
| String dec = currentText(); |
| if (StringUtils.isEmpty(dec)) |
| dec = Order.ELEMENT + " asc"; |
| fmd.setOrderDeclaration(dec); |
| } |
| |
| /** |
| * Parse named-query. |
| */ |
| protected boolean startNamedQuery(Attributes attrs) |
| throws SAXException { |
| if (!isQueryMode()) |
| return false; |
| |
| String name = attrs.getValue("name"); |
| Log log = getLog(); |
| if (log.isTraceEnabled()) |
| log.trace(_loc.get("parse-query", name)); |
| |
| QueryMetaData meta = getRepository().getCachedQueryMetaData(null, name); |
| if (meta != null && log.isWarnEnabled()) |
| log.warn(_loc.get("override-query", name, currentLocation())); |
| |
| meta = getRepository().addQueryMetaData(null, name); |
| meta.setDefiningType(_cls); |
| meta.setQueryString(attrs.getValue("query")); |
| meta.setLanguage(JPQLParser.LANG_JPQL); |
| Locator locator = getLocation().getLocator(); |
| if (locator != null) { |
| meta.setLineNumber(Numbers.valueOf(locator.getLineNumber())); |
| meta.setColNumber(Numbers.valueOf(locator.getColumnNumber())); |
| } |
| Object cur = currentElement(); |
| Object scope = (cur instanceof ClassMetaData) |
| ? ((ClassMetaData) cur).getDescribedType() : null; |
| meta.setSource(getSourceFile(), scope, meta.SRC_XML); |
| if (isMetaDataMode()) |
| meta.setSourceMode(MODE_META); |
| else if (isMappingMode()) |
| meta.setSourceMode(MODE_MAPPING); |
| else |
| meta.setSourceMode(MODE_QUERY); |
| pushElement(meta); |
| return true; |
| } |
| |
| protected void endNamedQuery() |
| throws SAXException { |
| popElement(); |
| } |
| |
| protected boolean startQueryString(Attributes attrs) |
| throws SAXException { |
| return true; |
| } |
| |
| protected void endQueryString() |
| throws SAXException { |
| QueryMetaData meta = (QueryMetaData) currentElement(); |
| meta.setQueryString(currentText()); |
| } |
| |
| /** |
| * Parse query-hint. |
| */ |
| protected boolean startQueryHint(Attributes attrs) |
| throws SAXException { |
| QueryMetaData meta = (QueryMetaData) currentElement(); |
| meta.addHint(attrs.getValue("name"), attrs.getValue("value")); |
| return true; |
| } |
| |
| protected void endQueryHint() |
| throws SAXException { |
| } |
| |
| /** |
| * Parse native-named-query. |
| */ |
| protected boolean startNamedNativeQuery(Attributes attrs) |
| throws SAXException { |
| if (!isQueryMode()) |
| return false; |
| |
| String name = attrs.getValue("name"); |
| Log log = getLog(); |
| if (log.isTraceEnabled()) |
| log.trace(_loc.get("parse-native-query", name)); |
| |
| QueryMetaData meta = getRepository().getCachedQueryMetaData(null, name); |
| if (meta != null && log.isWarnEnabled()) |
| log.warn(_loc.get("override-query", name, currentLocation())); |
| |
| meta = getRepository().addQueryMetaData(null, name); |
| meta.setDefiningType(_cls); |
| meta.setQueryString(attrs.getValue("query")); |
| meta.setLanguage(QueryLanguages.LANG_SQL); |
| String val = attrs.getValue("result-class"); |
| if (val != null) { |
| Class type = classForName(val); |
| if (ImplHelper.isManagedType(getConfiguration(), type)) |
| meta.setCandidateType(type); |
| else |
| meta.setResultType(type); |
| } |
| |
| val = attrs.getValue("result-set-mapping"); |
| if (val != null) |
| meta.setResultSetMappingName(val); |
| |
| Object cur = currentElement(); |
| Object scope = (cur instanceof ClassMetaData) |
| ? ((ClassMetaData) cur).getDescribedType() : null; |
| meta.setSource(getSourceFile(), scope, meta.SRC_XML); |
| Locator locator = getLocation().getLocator(); |
| if (locator != null) { |
| meta.setLineNumber(Numbers.valueOf(locator.getLineNumber())); |
| meta.setColNumber(Numbers.valueOf(locator.getColumnNumber())); |
| } |
| if (isMetaDataMode()) |
| meta.setSourceMode(MODE_META); |
| else if (isMappingMode()) |
| meta.setSourceMode(MODE_MAPPING); |
| else |
| meta.setSourceMode(MODE_QUERY); |
| pushElement(meta); |
| return true; |
| } |
| |
| protected void endNamedNativeQuery() |
| throws SAXException { |
| popElement(); |
| } |
| |
| /** |
| * Start entity-listeners |
| */ |
| private boolean startEntityListeners(Attributes attrs) |
| throws SAXException { |
| if (!isMetaDataMode()) |
| return false; |
| if (currentElement() == null) |
| return true; |
| |
| // reset listeners declared in annotations. |
| LifecycleMetaData meta = ((ClassMetaData) currentElement()). |
| getLifecycleMetaData(); |
| for (int i = 0; i < LifecycleEvent.ALL_EVENTS.length; i++) |
| meta.setDeclaredCallbacks(i, null, 0); |
| return true; |
| } |
| |
| /** |
| * Parse exclude-default-listeners. |
| */ |
| private boolean startExcludeDefaultListeners(Attributes attrs) |
| throws SAXException { |
| if (!isMetaDataMode()) |
| return false; |
| ClassMetaData meta = (ClassMetaData) currentElement(); |
| meta.getLifecycleMetaData().setIgnoreSystemListeners(true); |
| return true; |
| } |
| |
| /** |
| * Parse exclude-superclass-listeners. |
| */ |
| private boolean startExcludeSuperclassListeners(Attributes attrs) |
| throws SAXException { |
| if (!isMetaDataMode()) |
| return false; |
| ClassMetaData meta = (ClassMetaData) currentElement(); |
| meta.getLifecycleMetaData().setIgnoreSuperclassCallbacks |
| (LifecycleMetaData.IGNORE_HIGH); |
| return true; |
| } |
| |
| /** |
| * Parse entity-listener. |
| */ |
| private boolean startEntityListener(Attributes attrs) |
| throws SAXException { |
| _listener = classForName(attrs.getValue("class")); |
| boolean system = currentElement() == null; |
| Collection<LifecycleCallbacks>[] parsed = |
| AnnotationPersistenceMetaDataParser.parseCallbackMethods(_listener, |
| null, true, true, _repos); |
| if (parsed == null) |
| return true; |
| |
| if (_callbacks == null) { |
| _callbacks = (Collection<LifecycleCallbacks>[]) |
| new Collection[LifecycleEvent.ALL_EVENTS.length]; |
| if (!system) |
| _highs = new int[LifecycleEvent.ALL_EVENTS.length]; |
| } |
| for (int i = 0; i < parsed.length; i++) { |
| if (parsed[i] == null) |
| continue; |
| if (_callbacks[i] == null) |
| _callbacks[i] = parsed[i]; |
| else |
| _callbacks[i].addAll(parsed[i]); |
| if (!system) |
| _highs[i] += parsed[i].size(); |
| } |
| return true; |
| } |
| |
| private void endEntityListener() |
| throws SAXException { |
| // should be in endEntityListeners I think to merge callbacks |
| // into a single listener. But then the user cannot remove. |
| if (currentElement() == null && _callbacks != null) { |
| _repos.addSystemListener(new PersistenceListenerAdapter |
| (_callbacks)); |
| _callbacks = null; |
| } |
| _listener = null; |
| } |
| |
| private boolean startCallback(MetaDataTag callback, Attributes attrs) |
| throws SAXException { |
| if (!isMetaDataMode()) |
| return false; |
| int[] events = MetaDataParsers.getEventTypes(callback); |
| if (events == null) |
| return false; |
| |
| boolean system = currentElement() == null; |
| Class type = currentElement() == null ? null : |
| ((ClassMetaData) currentElement()).getDescribedType(); |
| if (type == null) |
| type = Object.class; |
| |
| if (_callbacks == null) { |
| _callbacks = (Collection<LifecycleCallbacks>[]) |
| new Collection[LifecycleEvent.ALL_EVENTS.length]; |
| if (!system) |
| _highs = new int[LifecycleEvent.ALL_EVENTS.length]; |
| } |
| |
| MetaDataDefaults def = _repos.getMetaDataFactory().getDefaults(); |
| LifecycleCallbacks adapter; |
| if (_listener != null) |
| adapter = new BeanLifecycleCallbacks(_listener, |
| attrs.getValue("method-name"), false, type); |
| else |
| adapter = new MethodLifecycleCallbacks(_cls, |
| attrs.getValue("method-name"), false); |
| |
| for (int i = 0; i < events.length; i++) { |
| int event = events[i]; |
| if (_listener != null) { |
| MetaDataParsers.validateMethodsForSameCallback(_listener, |
| _callbacks[event], ((BeanLifecycleCallbacks) adapter). |
| getCallbackMethod(), callback, def, getLog()); |
| } else { |
| MetaDataParsers.validateMethodsForSameCallback(_cls, |
| _callbacks[event], ((MethodLifecycleCallbacks) adapter). |
| getCallbackMethod(), callback, def, getLog()); |
| |
| } |
| if (_callbacks[event] == null) |
| _callbacks[event] = new ArrayList<LifecycleCallbacks>(3); |
| _callbacks[event].add(adapter); |
| if (!system && _listener != null) |
| _highs[event]++; |
| } |
| return true; |
| } |
| |
| /** |
| * Store lifecycle metadata. |
| */ |
| private void storeCallbacks(ClassMetaData cls) { |
| LifecycleMetaData meta = cls.getLifecycleMetaData(); |
| Class supCls = cls.getDescribedType().getSuperclass(); |
| Collection<LifecycleCallbacks>[] supCalls = null; |
| if (!Object.class.equals(supCls)) { |
| supCalls = AnnotationPersistenceMetaDataParser.parseCallbackMethods |
| (supCls, null, true, false, _repos); |
| } |
| if (supCalls != null) { |
| for (int event : LifecycleEvent.ALL_EVENTS) { |
| if (supCalls[event] == null) |
| continue; |
| meta.setNonPCSuperclassCallbacks(event, supCalls[event].toArray |
| (new LifecycleCallbacks[supCalls[event].size()]), 0); |
| } |
| } |
| if (_callbacks == null) |
| return; |
| |
| for (int event : LifecycleEvent.ALL_EVENTS) { |
| if (_callbacks[event] == null) |
| continue; |
| meta.setDeclaredCallbacks(event, (LifecycleCallbacks[]) |
| _callbacks[event].toArray |
| (new LifecycleCallbacks[_callbacks[event].size()]), |
| _highs[event]); |
| } |
| _callbacks = null; |
| _highs = null; |
| } |
| |
| /** |
| * Instantiate the given class, taking into account the default package. |
| */ |
| protected Class classForName(String name) |
| throws SAXException { |
| if ("Entity".equals(name)) |
| return PersistenceCapable.class; |
| return super.classForName(name, isRuntime()); |
| } |
| } |
