<!-- 
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. 
--> 
<html>
<title>Release Notes for Apache OpenJPA 2.2.1</title>
<body>
<h1>Release Notes for Apache OpenJPA 2.2.1</h1>
<p>
<ul>
  <li><a href="#Overview">Overview</a></li>
  <li><a href="#Prerequisites">Prerequisites</a></li>
  <li><a href="#Documentation">Documentation</a></li>
  <li><a href="#GetInvolved">Getting Involved</a></li>
  <li><a href="#License">License</a></li>
  <li><a href="#Notice">Notice</a></li>
  <li><a href="#ReleaseNotes">Release Notes</a></li>
  <li><a href="#Previous">Release Notes for previous OpenJPA releases</a></li>
</ul>
</p>
<BR>
<hr>
<h2><a name="Overview"></a>Overview</h2>

<P>
   The Apache OpenJPA community is proud to release a maintenance distribution of
   OpenJPA 2.2.1. This distribution is based on the final JSR 317 Java
   Persistence API, Version 2.0 specification and passes the JPA 2.0 TCK,
   while remaining backwards compatible with prior releases based on the
   Java Persistence API (JPA 1.0) part of Java Community Process JSR-220
   (Enterprise JavaBeans 3.0).
</P>

<p>Additional information on the OpenJPA project may be found at the project 
web site: <a href="http://openjpa.apache.org">http://openjpa.apache.org</a></p>

<h2><a name="Prerequisites"></a>Prerequisites</h2>
<P>OpenJPA requires Java 6 or higher and a relational 
database of some sort.
</p>

<h2><a name="Documentation"></a>Documentation</h2>
<p>If you have questions about OpenJPA, a good source of information is the 
online product manual. You can find the manual for the current release as well
as older releases of OpenJPA at 
<a href="http://openjpa.apache.org/documentation.html">
http://openjpa.apache.org/documentation.html</a></p>
<p>If you can't find what you are looking for in the manual or would like more
clarification, please post to the OpenJPA development mailing list.
Information on all of the OpenJPA mailing lists may be found here:
<a href="http://openjpa.apache.org/mailing-lists.html">
http://openjpa.apache.org/mailing-lists.html</a></p>

<h2><a name="GetInvolved"></a>Getting Involved</h2>
<p>The Apache OpenJPA project is being built by the open source community for the open source community - 
we welcome your input and contributions!</p>
<P>What we are looking for:
<ul>
    <li> Source code and fixes contributions </li>
    <li> Documentation assistance </li>
    <li> Product and feature suggestions </li>
    <li> Detailed and constructive feedback </li>
    <li> Articles and whitepapers </li>
</ul></p>
<p>How do I contribute?
<ul>
    <li> To discuss Apache OpenJPA topics check out the mailing lists. </li>
    <li> Informal discussion also occurs on the #openjpa IRC channel on 
         freenode.net. </li>
    <li> Bugs and other issues can be posted on
         <a href="https://issues.apache.org/jira/browse/OPENJPA">
         the issue tracker</a>.
     </li>
</ul>
</p>

<BR>
<hr>
<h2><a name="License"></a>License</h2>
<P>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.
<BR>You may obtain a copy of the License at:
<a href="http://www.apache.org/licenses/LICENSE-2.0">
http://www.apache.org/licenses/LICENSE-2.0</a>
<BR>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.</p>
<P>The license may also be found in LICENSE.txt which is included 
in each release of OpenJPA.</P>

<h2><a name="Notice"></a>Notice</h2>
<p>Copyright 2006,2012 The Apache Software Foundation
<BR>This product includes software developed at The Apache Software Foundation (http://www.apache.org/).</p>
<P>Apache OpenJPA includes the persistence and orm schemas from the JPA specifications.
<BR>Copyright 2005-2009 Sun Microsystems, Inc. All rights reserved.
<BR>Apache OpenJPA elects to include this software in this distribution under the CDDL license.
<BR>You can obtain a copy of the License at:
<a href="https://glassfish.dev.java.net/public/CDDL+GPL.html">https://glassfish.dev.java.net/public/CDDL+GPL.html</a>
<BR>The source code is available at:
<a href="http://java.net/projects/glassfish">http://java.net/projects/glassfish</a></p>
<P>The complete list of notices can be found in NOTICE.txt included in each assembly.</p>

<BR>
<hr>
<h2><a name="ReleaseNotes">Release Notes</h2>

<hr>
<h3><a name="221">OpenJPA 2.2.1</h3>

        Release Notes - OpenJPA - Version 2.2.1
    
<h2>        Sub-task
</h2>
<ul>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2168'>OPENJPA-2168</a>] -         Do not go through LifeCycleEventManager overhead if the Entity has declared to be excluded
</li>
</ul>
            
<h2>        Bug
</h2>
<ul>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2067'>OPENJPA-2067</a>] -         A &#39;length&#39; of &#39;-1&#39; passed to PreparedStatement.setBinaryStream can cause an exception on some, but not all, JDBC drivers.
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2072'>OPENJPA-2072</a>] -         InvalidStateException deleting an instance with a timestamp in its primary key
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2095'>OPENJPA-2095</a>] -         Unhandled exception thrown from within an Externalizer method causes incorrect/incomplete SQL to be generated/executed.
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2118'>OPENJPA-2118</a>] -         Prepared SQL query does not handle collection-valued parameter where collection is empty
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2123'>OPENJPA-2123</a>] -         Minor performance improvements for Connection and ResultSet processing
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2132'>OPENJPA-2132</a>] -         Traversal of a OneToMany relationship returns an empty list when InheritanceType.JOINED or SINGLE_TABLE is used.
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2133'>OPENJPA-2133</a>] -         OpenJPA doesn&#39;t find custom mappings with an applicable class loader
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2136'>OPENJPA-2136</a>] -         NPE when using LiteAutoDetach 
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2142'>OPENJPA-2142</a>] -         Merge of a new object does not handle Entity Id field
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2145'>OPENJPA-2145</a>] -         Missing ASM depending jar in binary zip
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2146'>OPENJPA-2146</a>] -         StateManager for Embeddable may throw Exception while initializing
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2149'>OPENJPA-2149</a>] -         Criteria.function adds wrong casts to parameters making it unsuable
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2153'>OPENJPA-2153</a>] -         NoSuchMethodException of DBCPDriverDataSource.newInstance()
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2154'>OPENJPA-2154</a>] -         test-dynamic-enhancer profile failed for module more than one level deep
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2156'>OPENJPA-2156</a>] -         Fix bug in org.apache.openjpa.persistence.util.SourceCode to correctly generate imports.
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2158'>OPENJPA-2158</a>] -         LiteAutoDetach + DetachProxyFields=false can lead to Broker concurrency exceptions
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2161'>OPENJPA-2161</a>] -         Make some members of StateManagerImpl protected to allow for greater extensability
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2163'>OPENJPA-2163</a>] -         Lifecycle event callback occurs more often than expect
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2172'>OPENJPA-2172</a>] -         openjpa-all jar is missing slf4j runtime dependency
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2174'>OPENJPA-2174</a>] -         Result set mapping was not looked up when retrieving column data from a NamedNativeQuery
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2199'>OPENJPA-2199</a>] -         Constraint violation exception when removing relationship using (orphanRemoval = true)
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2227'>OPENJPA-2227</a>] -         OpenJPA doesn&#39;t find custom SequenceGenerators
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2230'>OPENJPA-2230</a>] -         Event Listener detection didn&#39;t work with MappedSuperClasses or Entity heirarchies
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2236'>OPENJPA-2236</a>] -         Trace of connection info can cause class transform/enhancement to fail
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2247'>OPENJPA-2247</a>] -         JoinColumn annotation is ignored when mapping a unidirectional owned OneToOne that is in a SecondaryTable
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2260'>OPENJPA-2260</a>] -         Parenthesis-augmented parameters are improperly processed at EM level
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2261'>OPENJPA-2261</a>] -         Query SQL Cache issue with NULL parameters
</li>
</ul>
            
<h2>        Improvement
</h2>
<ul>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2134'>OPENJPA-2134</a>] -         Do not close Connections when ConnectionRetainMode is set to &quot;always&quot;
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2137'>OPENJPA-2137</a>] -         Make some members of StateManagerImpl protected to allow for greater extensibility
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2143'>OPENJPA-2143</a>] -         Reduce lock contention on LifecycleEventManager
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2151'>OPENJPA-2151</a>] -         Improve the performance of StateManagerImpl.initialize 
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2152'>OPENJPA-2152</a>] -         Don&#39;t process query hints when LockModeType == NONE
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2159'>OPENJPA-2159</a>] -         Add support for no rounding of Date
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2162'>OPENJPA-2162</a>] -         Avoid delimited identifier processing if it&#39;s not required by application
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2164'>OPENJPA-2164</a>] -         Don&#39;t setPCState if field requested is already loaded
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2167'>OPENJPA-2167</a>] -         Misc changes to improve flush() path performance
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2189'>OPENJPA-2189</a>] -         Update OpenBooks example to build, install, and execute in the WAS Liberty Profile
</li>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2208'>OPENJPA-2208</a>] -         Add additional Java 2 Security doPriv function
</li>
</ul>
                                        
<h2>        Test
</h2>
<ul>
<li>[<a href='https://issues.apache.org/jira/browse/OPENJPA-2169'>OPENJPA-2169</a>] -         TestOracleXmlColumn test failed using Oracle 11.2 driver
</li>
</ul>
        
<BR>
<hr>
<h2><a name="Previous"></a>Previous Releases</h2>
<p>Release notes for earlier releases of OpenJPA may be found in SVN at the following locations. 
<ul>
  <li><a href='http://svn.apache.org/viewvc/openjpa/tags/2.2.0/openjpa-project/RELEASE-NOTES.html?view=co'>OpenJPA 2.2.0 RELEASE-NOTES.html</a></li>
  <li><a href='http://svn.apache.org/viewvc/openjpa/tags/2.1.1/openjpa-project/RELEASE-NOTES.html?view=co'>OpenJPA 2.1.1 RELEASE-NOTES.html</a></li>
  <li><a href='http://svn.apache.org/viewvc/openjpa/tags/2.1.0/openjpa-project/RELEASE-NOTES.html?view=co'>OpenJPA 2.1.0 RELEASE-NOTES.html</a></li>
  <li><a href='http://svn.apache.org/viewvc/openjpa/tags/2.0.1/openjpa-project/RELEASE-NOTES.html?view=co'>OpenJPA 2.0.1 RELEASE-NOTES.html</a></li>
  <li><a href='http://svn.apache.org/viewvc/openjpa/tags/2.0.0/openjpa-project/RELEASE-NOTES.html?view=co'>OpenJPA 2.0.0 RELEASE-NOTES.html</a></li>
  <li><a href='http://svn.apache.org/viewvc/openjpa/tags/2.0.0-beta3/openjpa-project/RELEASE-NOTES.html?view=co'>OpenJPA 2.0.0-Beta 3 RELEASE-NOTES.html</a></li>
  <li><a href='http://svn.apache.org/viewvc/openjpa/tags/2.0.0-beta2/openjpa-project/RELEASE-NOTES.html?view=co'>OpenJPA 2.0.0-Beta 2 RELEASE-NOTES.html</a></li>
  <li><a href='http://svn.apache.org/viewvc/openjpa/tags/2.0.0-beta/openjpa-project/RELEASE-NOTES.html?view=co'>OpenJPA 2.0.0-Beta RELEASE-NOTES.html</a></li>
  <li><a href='http://svn.apache.org/viewvc/openjpa/tags/2.0.0-M3/openjpa-project/RELEASE-NOTES.html?view=co'>OpenJPA 2.0.0-Milestone 3 RELEASE-NOTES.html</a></li>
  <li><a href='http://svn.apache.org/viewvc/openjpa/tags/1.2.2/openjpa-project/RELEASE-NOTES.html?view=co'>OpenJPA 1.2.2 RELEASE-NOTES.html</a></li>
  <li><a href='http://svn.apache.org/viewvc/openjpa/tags/1.2.2/openjpa-project/RELEASE-NOTES.html?view=co'>OpenJPA 1.2.2 RELEASE-NOTES.html</a></li>
  <li><a href='http://svn.apache.org/viewvc/openjpa/tags/1.2.1/openjpa-project/RELEASE-NOTES.html?view=co'>OpenJPA 1.2.1 RELEASE-NOTES.html</a></li>
  <li><a href='http://svn.apache.org/viewvc/openjpa/tags/1.1.0/openjpa-project/RELEASE-NOTES.html?view=co'>OpenJPA 1.1.0 RELEASE-NOTES.html</a></li>
  <li><a href='http://svn.apache.org/viewvc/openjpa/tags/1.0.4/openjpa-project/RELEASE-NOTES.html?view=co'>OpenJPA 1.0.4 RELEASE-NOTES.html</a></li>
  <li><a href='http://svn.apache.org/viewvc/openjpa/tags/1.0.3/openjpa-project/RELEASE-NOTES.html?view=co'>OpenJPA 1.0.3 RELEASE-NOTES.html</a></li>
</ul></p>
 
<hr>
<p>Copyright (C) 2006,2012 Apache Software Foundation. Licensed under Apache License 2.0.<br>
Apache, the Apache feather logo and OpenJPA are trademarks of Apache Software Foundation.<br>
</body>
</html>
