<?xml version="1.0" encoding="utf-8"?>

<!-- 
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.
-->

<!-- 
This is the template for the release summary which the Release Manager
writes. The ReleaseNotesGenerator uses this summary in order to
generate various sections of the release notes. Please replace all placeholders
with real information.
-->

<summary>

<!--
    Identifier of previous release. The release notes describe the
    delta between releaseID and previousReleaseID.

    E.g.: 10.2.1.7

-->
<previousReleaseID>10.11.1.1</previousReleaseID>

<!--
    Identifier(s) of previously released versions. Any issue that was fixed in
    any of these versions will be excluded from the fixed bugs list, and the
    release notes list.

    E.g.: 10.3.1.4 and 10.3.2.1
    
-->

<buildInfo>

  <!-- Machine environment. E.g.:  Cygwin on Microsoft Windows XP Professional Version 2002 Service Pack 2. -->
  <machine>Mac OSX 10.7.5.</machine>

  <!-- Ant version. E.g.:  Apache Ant version 1.6.5 compiled on June 2 2005. -->
  <antVersion>Apache Ant(TM) version 1.9.2 compiled on July 8 2013.</antVersion>

  <!--
         Say which compilers you used.
         E.g.:

           The 1.4.2_12-b03 javac was used to compile all classes
           except for the JDBC4 drivers. The JDBC4 driver classes were compiled using the 1.6.0-b105 javac.
  -->
  <compilers>All classes were compiled by the javac from the 1.8.0-b132 JDK, Java HotSpot(TM) 64-Bit Server VM (build 25.0-b70, mixed mode).</compilers>

</buildInfo>

<overview>

<p>
The most up to date information about Derby releases can be found on the
<a href="http://db.apache.org/derby/derby_downloads.html">Derby download page</a>.
</p>

<p>
Apache Derby is a pure Java relational database engine using standard SQL and
JDBC as its APIs. More information about Derby can be found on the
<a href="http://db.apache.org/derby/">Apache web site</a>.
Derby functionality includes:
</p>

<ul>
<li>Embedded engine with JDBC drivers</li>
<li>Network Server</li>
<li>Network client JDBC drivers</li>
<li>Command line tools: ij (SQL scripting), dblook (schema dump) and sysinfo (system info)</li>
</ul>

<p>
Support for Java SE 6 and Java SE 7 is being sunsetted. The 10.13 release family will not support those platforms. The 10.12 release family supports the following Java and JDBC versions:
</p>
<ul>
  <li>Java SE 6 and higher with JDBC 4.0, 4.1, and 4.2.</li>
  <li>Java SE 8 compact profile 2.</li>
</ul>
</overview>

<newFeatures>

<p>
This is a feature release. The following new features were added:
</p>

<ul>

<li><b>ALTER TABLE and identity columns</b> - The ALTER TABLE command can be used to add identity columns now. See the section on this statement in the Derby Reference Manual.</li>

<li><b>Cache-monitoring MBean</b> - An MBean has been added for monitoring internal Derby caches. See the description of <i>CacheManagerMBean</i> in the "Introduction to the Derby MBeans" section of the Derby Server and Administration Guide.</li>

<li><b>Optional Tool for Handling JSON Data</b> - An optional tool has been added for packing query results into JSON documents and for unpacking JSON documents into tabular result sets. See the section on the <i>simpleJson</i> optional tool in the Derby Tools and Utilities Guide.</li>

<li><b>Statistics aggregates</b> - SQL Standard VAR_POP(), VAR_SAMP(), STDDEV_POP(), and STDDEV_SAMP() aggregates have been added. See the "Aggregates (set functions)" section in the Derby Reference Manual.</li>

</ul>

</newFeatures>

<!--
    These are the instructions for verifying the signed distributions. Probably you
    won't need to touch this section.
    
-->

<releaseVerification>

<p>It is essential that you verify the integrity of the downloaded
files using the PGP and MD5 signatures.  MD5 verification ensures the
file was not corrupted during the download process.  PGP verification
ensures that the file came from a certain person.</p>

<p>The PGP signatures can be verified using
<a href="http://www.pgpi.org/">PGP</a> or
<a href="http://www.gnupg.org/">GPG</a>.
First download the Apache Derby
<a href="https://dist.apache.org/repos/dist/release/db/derby/KEYS">KEYS</a>
as well as the <code>asc</code> signature file for the particular
distribution. It is important that you get these files from the ultimate
trusted source - the main ASF distribution site, rather than from a mirror.
Then verify the signatures using ...</p>

<pre>
% pgpk -a KEYS
% pgpv db-derby-X.Y.tar.gz.asc

<em>or</em>

% pgp -ka KEYS
% pgp db-derby-X.Y.tar.gz.asc

<em>or</em>

% gpg --import KEYS
% gpg --verify db-derby-X.Y.tar.gz.asc

</pre>

<p>To verify the MD5 signature on the files, you need to use a program
called <code>md5</code> or <code>md5sum</code>, which is
included in many unix distributions.  It is also available as part of
<a href="http://www.gnu.org/software/textutils/textutils.html">GNU
Textutils</a>.  Windows users can get binary md5 programs from <a
href="http://www.fourmilab.ch/md5/">here</a>, <a
href="http://www.pc-tools.net/win32/freeware/console/">here</a>, or
<a href="http://www.slavasoft.com/fsum/">here</a>.</p>

<p>We strongly recommend that you verify your downloads with both PGP and MD5.</p>


</releaseVerification>

</summary>


