<?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.14.2.0</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.11.6.</machine>

  <!-- Ant version. E.g.:  Apache Ant version 1.6.5 compiled on June 2 2005. -->
  <antVersion>Apache Ant(TM) version 1.10.2 compiled on February 3 2018.</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 OpenJDK 64-Bit Server VM 18.9 (build 11+28, 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>
The 10.15 release family supports the following Java and JDBC versions:
</p>
<ul>
  <li>Java SE 9 and higher with JDBC 4.2.</li>
</ul>
</overview>

<newFeatures>

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

<ul>

<li><b>JPMS modularization</b> - Derby has been re-packaged as a set of JPMS modules. This introduced a new jar file, <i>derbyshared.jar</i>, required by all configurations. Module diagrams for Derby configurations can be found in the
<a href="http://db.apache.org/derby/docs/10.15/publishedapi/index.html">javadoc</a>
for the 10.15 public API.
</li>

</ul>

<p>
New users should consult the
<a href="http://db.apache.org/derby/manuals/index.html#docs_10.15">10.15 documentation</a>,
especially the
<a href="http://db.apache.org/derby/docs/10.15/getstart/index.html">Getting Started With Derby</a> guide.
</p>

<p>
Existing users who want to continue running Derby with a classpath should read the extended release note for issue DERBY-6945 (see below).
</p>

<p>
Existing users who want to run Derby with a module path should consult the module diagrams in the
<a href="http://db.apache.org/derby/docs/10.15/publishedapi/index.html">javadoc</a>
for the 10.15 public API. Templates for wiring together a module path can be found in the
<i>setEmbeddedCP</i>, <i>setNetworkServerCP</i>, and <i>setNetworkClientCP</i> scripts located
in the bin directory of the release distributions, as described by the
"Manually setting the CLASSPATH/MODULEPATH environment variables" topic in the
<a href="http://db.apache.org/derby/docs/10.15/getstart/index.html">Getting Started With Derby</a> guide.
</p>

</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 SHA-512 signatures.  SHA-512 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 SHA-512 checksums on the files, you need to use a
platform-specific program. On Mac OSX, this program is called
<code>shasum</code>, on Linux it is called <code>sha512sum</code>,
and on Windows it is called <code>CertUtil</code>.</p>

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


</releaseVerification>

</summary>


