<head>
<link rel="canonical" href="https://ignite.apache.org/releases/2.12.0/release_notes.html" />
<META NAME="ROBOTS" CONTENT="NOINDEX">

<!-- Yandex.Metrika counter -->
    <script type="text/javascript" >
      (function(m,e,t,r,i,k,a){m[i]=m[i]||function(){(m[i].a=m[i].a||[]).push(arguments)};
      m[i].l=1*new Date();k=e.createElement(t),a=e.getElementsByTagName(t)[0],k.async=1,k.src=r,a.parentNode.insertBefore(k,a)})
      (window, document, "script", "https://mc.yandex.ru/metrika/tag.js", "ym");
    
      ym(72949126, "init", {
           clickmap:true,
           trackLinks:true,
           accurateTrackBounce:true,
           webvisor:true
      });
    </script>
    <noscript><div><img src="https://mc.yandex.ru/watch/72949126" style="position:absolute; left:-9999px;" alt="" /></div></noscript>
    <!-- /Yandex.Metrika counter -->
<script type='text/javascript'>
    window.__lo_site_id = 284467;
    
      (function() {
        var wa = document.createElement('script'); wa.type = 'text/javascript'; wa.async = true;
        wa.src = 'https://d10lpsik1i8c69.cloudfront.net/w.js';
        var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(wa, s);
        })();
      </script>



	<style>h1 {    color: #113847;    font-size: 33px;    font-weight: bold;    margin: 30px 0 15px 0;    padding-bottom: 7px;    width: 700px;}h2 {  border-bottom: 2px solid #ccc;     color: #113847;     font-size: 29px;     font-weight: normal;     margin: 30px 0 15px 0;     padding-bottom: 7px;  width: 700px; }a {      color: #cc0000;      text-decoration: none;  }span {    color: #cc0000;}a:hover {    text-decoration: underline;}ul,ol {    list-style: disc;    margin-left: 30px;}ul li,ol li {    margin: 5px 0;}p.description {    width: 700px;}</style>

	<script>
  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
  })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');

  ga('create', 'UA-61232409-1', 'auto');
  ga('send', 'pageview');

	</script></head>
<body>
	<h1>Apache Ignite 2.12.0</h1>
			<div></div>

    <h2>WARNINGS</h2>
    <ul>
        <li>The community accepted deprecate for removal in future releases: CacheMode#LOCAL, CacheAtomicityMode#TRANSACTIONAL_SNAPSHOT, CacheConfiguration#rebalanceDelay.</li>
        <li>GCE, AWS, Azure modules, CacheSpringStoreSessionListener, and TcpDiscoveryZookeeperIpFinder migrated to the Ignite extensions.</li>
        <li>The deprecated legacy service grid implementation will be removed in the next release.</li>
    </ul>

    <h2>Ignite</h2>
    <ul>
        <li>Added Ignite Distributed Environment Tests.</li>
        <li>Added IndexQuery API for fast index scans.</li>
        <li>Added KubernetesConnectionConfiguration.discoveryPort.</li>
        <li>Added MergeSort distributed cache query reducer.</li>
        <li>Added Read Repair on specified partition to the Control.sh.</li>
        <li>Added an ability to track request handling completion in GridRestProcessor.</li>
        <li>Added an explicit method to register binary type based on class.</li>
        <li>Added batch cache operations histogram metrics.</li>
        <li>Added benchmarks for cache queries - scan, index, text.</li>
        <li>Added docker image for s390x.</li>
        <li>Added events for snapshot restore operation.</li>
        <li>Added expire policy info into log of started cache.</li>
        <li>Added firing event for any ReadRepair attempt (if consistency violation found). Atomic caches are also supported.</li>
        <li>Added offline utility to read and analyze index files.</li>
        <li>Added possibility to accept while indexing classes/enums that are extending interfaces/classes marked to be stored in cache.</li>
        <li>Added rename index tree operation with corresponding WAL record.</li>
        <li>Added resource de-allocation in SharedPageLockTracker.</li>
        <li>Added snapshot thread pool configuration.</li>
        <li>Added support for creating IndexQuery without index name.</li>
        <li>Added the ability to cancellation of consistency recovery command (Read Repair via control.ch).</li>
        <li>Added the ability to record Control.sh consistency check violations to other log file.</li>
        <li>Added the ability to restore snapshot taken on different topologies.</li>
        <li>Added the ability to snapshot encrypted caches.</li>
        <li>Added the cache destroy command for control.sh.</li>
        <li>Added the force deactivation flag to the IgniteMXBean.</li>
        <li>Added time metrics and statistics for the IgniteCache#getAllOutTx.</li>
        <li>Added unconditional logging of tx states to WAL to ensure correct tx recovery after node crash.</li>
        <li>Changed IGNITE_PDS_WAL_REBALANCE_THRESHOLD from System property to Distributed property.</li>
        <li>Deprecated CacheConfiguration#rebalanceDelay for removal.</li>
        <li>Deprecated CacheMode#LOCAL for removal.</li>
        <li>Deprecated CacheAtomicityMode#TRANSACTIONAL_SNAPSHOT deprecated for removal.</li>
        <li>Deprecated the IGNITE_THRESHOLD_WAL_ARCHIVE_SIZE_PERCENTAGE system property.</li>
        <li>Expanded kubernetes examples to include full beans.</li>
        <li>Fixed AssertionError: Unexpected rebalance on rebalanced cluster.</li>
        <li>Fixed CacheObjectAdapter#put incorrect offset handling.</li>
        <li>Fixed NPE on remote listener registration with null remote filter and security enabled.</li>
        <li>Fixed PagesWriteSpeedBasedThrottle time to throttle calculation.</li>
        <li>Fixed REST and Zookeeper module logging: use the slf4j facade to log third-party libraries.</li>
        <li>Fixed REST request failure when cache node filter is used.</li>
        <li>Fixed SSL read error.</li>
        <li>Fixed StackOverflowError in case if exception suppressed with itself.</li>
        <li>Fixed adaptation of the historical rebalance to the release of WAL segments.</li>
        <li>Fixed an error when starting a node due to exceeding the DataStorageConfiguration#getMaxWalArchiveSize.</li>
        <li>Fixed azure-blob-storage dependency versions.</li>
        <li>Fixed builds with maven 3.8.1+.</li>
        <li>Fixed cancelling WAL segments reservation when max WAL archive size is reached.</li>
        <li>Fixed change permissions required to create/destroy caches in GridRestProcessor.</li>
        <li>Fixed check of SERVICE_DEPLOY permission.</li>
        <li>Fixed check statistics obsolescence on server nodes only.</li>
        <li>Fixed client node reconnect with enabled security.</li>
        <li>Fixed concurrent heartbeat update while in blocking section for system workers.</li>
        <li>Fixed contention in lock on Compound future.</li>
        <li>Fixed diagnostic information for PDS corruption scenarios.</li>
        <li>Fixed error extension about B+tree lock retry for indexes.</li>
        <li>Fixed exception for checkpoint marker reading error.</li>
        <li>Fixed exception message of closed the GridCloseableIteratorAdapter.</li>
        <li>Fixed execution of daemon node operations that require authorization.</li>
        <li>Fixed fallback to full rebalance in case of historical rebalancing failure.</li>
        <li>Fixed handle windows in ODBC on Windows.</li>
        <li>Fixed idle verify and snapshot check ambiguity error output.</li>
        <li>Fixed multiple results bug when query parallelism is enabled for single partition query.</li>
        <li>Fixed node restart in maintenance mode with security enabled.</li>
        <li>Fixed performance suggestion URL to legacy documentation.</li>
        <li>Fixed preconfigured service deployment authorization.</li>
        <li>Fixed security context propagation for cache event.</li>
        <li>Fixed security context propagation for compute tasks.</li>
        <li>Fixed snapshot restore fails if metadata is missing on any baseline node.</li>
        <li>Fixed snapshot restore on not all affinity partitions are physically present.</li>
        <li>Fixed spontaneous SocketTimeoutException in server socket accept (JDK-8247750).</li>
        <li>Fixed storage of physical pageIds in a DurableBackgroundCleanupIndexTreeTask.</li>
        <li>Fixed the AssertionError when the JmxMetricExporterSpi unregister a filtered metric registry.</li>
        <li>Fixed the data structures system views registration on inactive cluster start.</li>
        <li>Fixed the inconsistency of the built new indexes after restarting the node.</li>
        <li>Fixed the remove metric value is different for sync and async methods.</li>
        <li>Fixed triple flushing of meta information at the checkpoint.</li>
        <li>Fixed unconditional Lucene index creation.</li>
        <li>Fixed unnecessary socket shutdown and close log output.</li>
        <li>Fixed walTotalSize incorrectly reported when wal archiving is turned off.</li>
        <li>Implemented CDC metrics.</li>
        <li>Implemented Change Data Capture.</li>
        <li>Implemented IndexQuery filter operation.</li>
        <li>Implemented Yardstick benchmark for multi cache transaction operations.</li>
        <li>Implemented forbid duplicated field in CREATE INDEX clause.</li>
        <li>Improved logging of the peer class loading error message.</li>
        <li>Improved the snapshot procedure logging.</li>
        <li>Migrated CacheSpringStoreSessionListener to the Ignite extensions.</li>
        <li>Migrated TcpDiscoveryZookeeperIpFinder to the Ignite extensions.</li>
        <li>Migrated gce, aws, azure modules to the Ignite extensions.</li>
        <li>Updated Bouncycastle version (fixes CVE-2020-15522, CVE-2020-0187, CVE-2020-26939).</li>
        <li>Updated log4j version to 2.17.1 (fixes CVE-2021-44228, CVE-2021-44832, CVE-2021-45046, CVE-2021-45105).</li>
        <li>Updated PostgreSQL JDBC Driver version (fixes CVE-2020-13692).</li>
        <li>Updated httpclient, httpcore versions (fixes CVE-2020-13956).</li>
        <li>Updated the Jackson dependency version (fixes CVE-2019-16942, CVE-2019-16943, CVE-2019-17531).</li>
        <li>Updated the MySql connector dependency version (fixes CVE-2019-2692).</li>
        <li>Updated the Netty dependency version (fixes CVE-2021-21295).</li>
    </ul>
    <h2>Java thin-client</h2>
    <ul>
        <li>Added SQLSTATE to thin client SQL error message.</li>
        <li>Added client cache for OptimizedMarshaller class names.</li>
        <li>Added partition awareness for ScanQuery with specified partition.</li>
        <li>Added requests thread pool monitoring.</li>
        <li>Fixed ClassNotFoundException on service call after failover.</li>
        <li>Fixed follow user-defined endpoint order, try default port first.</li>
        <li>Fixed issue with explicit binary type configuration.</li>
        <li>Fixed transaction failure after timeout.</li>
    </ul>
    <h2>.Net</h2>
    <ul>
        <li>Fixed NRE in ClientFailoverSocket due to late logger setter.</li>
        <li>Fixed NullPointerException in ContinuousQuery with security enabled.</li>
        <li>Fixed Schema project version and examples packaging.</li>
        <li>Fixed SslStreamFactory.CertificatePath null value.</li>
        <li>Fixed TypeNameParser to ignore escaped characters in compiler-generated type names.</li>
        <li>Fixed dynamic assemblies handling in TypeResolver.</li>
        <li>Fixed thin client streamer not creating SQL table entries.</li>
        <li>Fixed verify-nuget.ps1 failure when .NET 5 is installed.</li>
    </ul>
    <h2>Ignite C++</h2>
    <ul>
        <li>Added Compute task functionality.</li>
        <li>Added support for affinity fields.</li>
        <li>Extended platforms API to call Java versioned entry processor.</li>
        <li>Fixed compilation on Visual Studio.</li>
        <li>Implemented building windows installer of ODBC Driver on CMake.</li>
        <li>Removed separate JNI module and moved it to Core.</li>
    </ul>
    <h2>SQL</h2>
    <ul>
        <li>Added support of precision parameter for varbinary type.</li>
        <li>Fixed PK flag ordering in SQL AST traverse.</li>
        <li>Fixed incorrect JOIN when querying a single-node cluster.</li>
        <li>Fixed setting alias for affinity fields.</li>
        <li>Implemented table statistics.</li>
    </ul>
</body>
