
<!DOCTYPE html>
<html lang="en" dir=ZgotmplZ>

<head>
  


<link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
<script src="/bootstrap/js/bootstrap.bundle.min.js"></script>
<link rel="stylesheet" type="text/css" href="/font-awesome/css/font-awesome.min.css">
<script src="/js/anchor.min.js"></script>
<script src="/js/flink.js"></script>
<link rel="canonical" href="https://flink.apache.org/2022/10/28/announcing-the-release-of-apache-flink-1.16/">

  <meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta name="description" content="Apache Flink continues to grow at a rapid pace and is one of the most active communities in Apache. Flink 1.16 had over 240 contributors enthusiastically participating, with 19 FLIPs and 1100&#43; issues completed, bringing a lot of exciting features to the community.
Flink has become the leading role and factual standard of stream processing, and the concept of the unification of stream and batch data processing is gradually gaining recognition and is being successfully implemented in more and more companies.">
<meta name="theme-color" content="#FFFFFF"><meta property="og:title" content="Announcing the Release of Apache Flink 1.16" />
<meta property="og:description" content="Apache Flink continues to grow at a rapid pace and is one of the most active communities in Apache. Flink 1.16 had over 240 contributors enthusiastically participating, with 19 FLIPs and 1100&#43; issues completed, bringing a lot of exciting features to the community.
Flink has become the leading role and factual standard of stream processing, and the concept of the unification of stream and batch data processing is gradually gaining recognition and is being successfully implemented in more and more companies." />
<meta property="og:type" content="article" />
<meta property="og:url" content="https://flink.apache.org/2022/10/28/announcing-the-release-of-apache-flink-1.16/" /><meta property="article:section" content="posts" />
<meta property="article:published_time" content="2022-10-28T08:00:00+00:00" />
<meta property="article:modified_time" content="2022-10-28T08:00:00+00:00" />
<title>Announcing the Release of Apache Flink 1.16 | Apache Flink</title>
<link rel="manifest" href="/manifest.json">
<link rel="icon" href="/favicon.png" type="image/x-icon">
<link rel="stylesheet" href="/book.min.22eceb4d17baa9cdc0f57345edd6f215a40474022dfee39b63befb5fb3c596b5.css" integrity="sha256-IuzrTRe6qc3A9XNF7dbyFaQEdAIt/uObY777X7PFlrU=">
<script defer src="/en.search.min.2698f0d1b683dae4d6cb071668b310a55ebcf1c48d11410a015a51d90105b53e.js" integrity="sha256-Jpjw0baD2uTWywcWaLMQpV688cSNEUEKAVpR2QEFtT4="></script>
<!--
Made with Book Theme
https://github.com/alex-shpak/hugo-book
-->

  <meta name="generator" content="Hugo 0.124.1">

    
    <script>
      var _paq = window._paq = window._paq || [];
       
       
      _paq.push(['disableCookies']);
       
      _paq.push(["setDomains", ["*.flink.apache.org","*.nightlies.apache.org/flink"]]);
      _paq.push(['trackPageView']);
      _paq.push(['enableLinkTracking']);
      (function() {
        var u="//analytics.apache.org/";
        _paq.push(['setTrackerUrl', u+'matomo.php']);
        _paq.push(['setSiteId', '1']);
        var d=document, g=d.createElement('script'), s=d.getElementsByTagName('script')[0];
        g.async=true; g.src=u+'matomo.js'; s.parentNode.insertBefore(g,s);
      })();
    </script>
    
</head>

<body dir=ZgotmplZ>
  


<header>
  <nav class="navbar navbar-expand-xl">
    <div class="container-fluid">
      <a class="navbar-brand" href="/">
        <img src="/img/logo/png/100/flink_squirrel_100_color.png" alt="Apache Flink" height="47" width="47" class="d-inline-block align-text-middle">
        <span>Apache Flink</span>
      </a>
      <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarSupportedContent" aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
          <i class="fa fa-bars navbar-toggler-icon"></i>
      </button>
      <div class="collapse navbar-collapse" id="navbarSupportedContent">
        <ul class="navbar-nav">
          





    
      
  
    <li class="nav-item dropdown">
      <a class="nav-link dropdown-toggle" href="#" role="button" data-bs-toggle="dropdown" aria-expanded="false">About</a>
      <ul class="dropdown-menu">
        
          <li>
            
  
    <a class="dropdown-item" href="/what-is-flink/flink-architecture/">Architecture</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/what-is-flink/flink-applications/">Applications</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/what-is-flink/flink-operations/">Operations</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/what-is-flink/use-cases/">Use Cases</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/what-is-flink/powered-by/">Powered By</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/what-is-flink/roadmap/">Roadmap</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/what-is-flink/community/">Community & Project Info</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/what-is-flink/security/">Security</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/what-is-flink/special-thanks/">Special Thanks</a>
  

          </li>
        
      </ul>
    </li>
  

    
      
  
    <li class="nav-item dropdown">
      <a class="nav-link dropdown-toggle" href="#" role="button" data-bs-toggle="dropdown" aria-expanded="false">Getting Started</a>
      <ul class="dropdown-menu">
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-docs-stable/docs/try-flink/local_installation/">With Flink<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-kubernetes-operator-docs-stable/docs/try-flink-kubernetes-operator/quick-start/">With Flink Kubernetes Operator<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-cdc-docs-stable/docs/get-started/introduction/">With Flink CDC<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-ml-docs-stable/docs/try-flink-ml/quick-start/">With Flink ML<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-statefun-docs-stable/getting-started/project-setup.html">With Flink Stateful Functions<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-docs-stable/docs/learn-flink/overview/">Training Course<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
      </ul>
    </li>
  

    
      
  
    <li class="nav-item dropdown">
      <a class="nav-link dropdown-toggle" href="#" role="button" data-bs-toggle="dropdown" aria-expanded="false">Documentation</a>
      <ul class="dropdown-menu">
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-docs-stable/">Flink 1.19 (stable)<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-docs-master/">Flink Master (snapshot)<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-kubernetes-operator-docs-stable/">Kubernetes Operator 1.8 (latest)<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-kubernetes-operator-docs-main">Kubernetes Operator Main (snapshot)<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-cdc-docs-stable">CDC 3.0 (stable)<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-cdc-docs-master">CDC Master (snapshot)<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-ml-docs-stable/">ML 2.3 (stable)<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-ml-docs-master">ML Master (snapshot)<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-statefun-docs-stable/">Stateful Functions 3.3 (stable)<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-statefun-docs-master">Stateful Functions Master (snapshot)<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
      </ul>
    </li>
  

    
      
  
    <li class="nav-item dropdown">
      <a class="nav-link dropdown-toggle" href="#" role="button" data-bs-toggle="dropdown" aria-expanded="false">How to Contribute</a>
      <ul class="dropdown-menu">
        
          <li>
            
  
    <a class="dropdown-item" href="/how-to-contribute/overview/">Overview</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/how-to-contribute/contribute-code/">Contribute Code</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/how-to-contribute/reviewing-prs/">Review Pull Requests</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/how-to-contribute/code-style-and-quality-preamble/">Code Style and Quality Guide</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/how-to-contribute/contribute-documentation/">Contribute Documentation</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/how-to-contribute/documentation-style-guide/">Documentation Style Guide</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/how-to-contribute/improve-website/">Contribute to the Website</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/how-to-contribute/getting-help/">Getting Help</a>
  

          </li>
        
      </ul>
    </li>
  

    


    
      
  
    <li class="nav-item">
      
  
    <a class="nav-link" href="/posts/">Flink Blog</a>
  

    </li>
  

    
      
  
    <li class="nav-item">
      
  
    <a class="nav-link" href="/downloads/">Downloads</a>
  

    </li>
  

    


    









        </ul>
        <div class="book-search">
          <div class="book-search-spinner hidden">
            <i class="fa fa-refresh fa-spin"></i>
          </div>
          <form class="search-bar d-flex" onsubmit="return false;"su>
            <input type="text" id="book-search-input" placeholder="Search" aria-label="Search" maxlength="64" data-hotkeys="s/">
            <i class="fa fa-search search"></i>
            <i class="fa fa-circle-o-notch fa-spin spinner"></i>
          </form>
          <div class="book-search-spinner hidden"></div>
          <ul id="book-search-results"></ul>
        </div>
      </div>
    </div>
  </nav>
  <div class="navbar-clearfix"></div>
</header>
 
  
      <main class="flex">
        <section class="container book-page">
          
<article class="markdown">
    <h1>
        <a href="/2022/10/28/announcing-the-release-of-apache-flink-1.16/">Announcing the Release of Apache Flink 1.16</a>
    </h1>
    


  October 28, 2022 -



  Godfrey He

  <a href="https://twitter.com/godfreyhe">(@godfreyhe)</a>
  



    <p><p>Apache Flink continues to grow at a rapid pace and is one of the most active
communities in Apache. Flink 1.16 had over 240 contributors enthusiastically participating,
with 19 FLIPs and 1100+ issues completed, bringing a lot of exciting features to the community.</p>
<p>Flink has become the leading role and factual standard of stream processing,
and the concept of the unification of stream and batch data processing is gradually gaining recognition
and is being successfully implemented in more and more companies. Previously,
the integrated stream and batch concept placed more emphasis on a unified API and
a unified computing framework. This year, based on this, Flink proposed
the next development direction of <a href="https://www.alibabacloud.com/blog/more-than-computing-a-new-era-led-by-the-warehouse-architecture-of-apache-flink_598821">Flink-Streaming Warehouse</a> (Streamhouse),
which further upgraded the scope of stream-batch integration: it truly completes not only
the unified computation but also unified storage, thus realizing unified real-time analysis.</p>
<p>In 1.16, the Flink community has completed many improvements for both batch and stream processing:</p>
<ul>
<li>For batch processing, all-round improvements in ease of use, stability and performance
have been completed. 1.16 is a milestone version of Flink batch processing and an important
step towards maturity.
<ul>
<li>Ease of use:  with the introduction of SQL Gateway and full compatibility with Hive Server2,
users can submit Flink SQL jobs and Hive SQL jobs very easily, and it is also easy to
connect to the original Hive ecosystem.</li>
<li>Functionality: Join hints let Flink SQL users manually specify join strategies
to avoid unreasonable execution plans. The compatibility of Hive SQL has reached 94%,
and users can migrate from Hive to Flink at a very low cost.</li>
<li>Stability: Propose a speculative execution mechanism to reduce the long tail sub-tasks of
a job and improve the stability. Improve HashJoin and introduce failure rollback mechanism
to avoid join failure.</li>
<li>Performance: Introduce dynamic partition pruning to reduce the Scan I/O and improve join
processing for the star-schema queries. There is 30% improvement in the TPC-DS benchmark.
We can use hybrid shuffle mode to improve resource usage and processing performance.</li>
</ul>
</li>
<li>For stream processing, there are a number of significant improvements:
<ul>
<li>Changelog State Backend provides users with second or even millisecond checkpoints to
dramatically improve the fault tolerance experience, while providing a smaller end-to-end
latency experience for transactional Sink jobs.</li>
<li>Lookup join is widely used in stream processing. Slow lookup speed, low throughput and
delay update are resolved through common cache mechanism, asynchronous io and retriable lookup.
These features are very useful, solving the pain points that users often complain about,
and supporting richer scenarios.</li>
<li>From the first day of the birth of Flink SQL, there were some non-deterministic operations
that could cause incorrect results or exceptions, which caused great distress to users.
In 1.16, we spent a lot of effort to solve most of the problems, and we will continue to
improve in the future.</li>
</ul>
</li>
</ul>
<p>With the further refinement of the integration of stream and batch, and the continuous iteration of
the Flink Table Store (<a href="https://flink.apache.org/news/2022/08/29/release-table-store-0.2.0.html">0.2 has been released</a>),
the Flink community is pushing the Streaming warehouse from concept to reality and maturity step by step.</p>
<h1 id="understanding-streaming-warehouses">
  Understanding Streaming Warehouses
  <a class="anchor" href="#understanding-streaming-warehouses">#</a>
</h1>
<p>To be precise, a streaming warehouse is to make data warehouse streaming, which allows the data
for each layer in the whole warehouse to flow in real-time. The goal is to realize
a Streaming Service with end-to-end real-time performance through a unified API and computing framework.
Please refer to <a href="https://www.alibabacloud.com/blog/more-than-computing-a-new-era-led-by-the-warehouse-architecture-of-apache-flink_598821">the article</a>
for more details.</p>
<h1 id="batch-processing">
  Batch processing
  <a class="anchor" href="#batch-processing">#</a>
</h1>
<p>Flink is a unified stream batch processing engine, stream processing has become the leading role
thanks to our long-term investment. We’re also putting more effort to improve batch processing
to make it an excellent computing engine. This makes the overall experience of stream batch
unification smoother.</p>
<h2 id="sql-gateway">
  SQL Gateway
  <a class="anchor" href="#sql-gateway">#</a>
</h2>
<p>The feedback from various channels indicates that <a href="https://nightlies.apache.org/flink/flink-docs-release-1.16/docs/dev/table/sql-gateway/overview/">SQL Gateway</a>
is a highly anticipated feature for users, especially for batch users. This function finally
completed (see <a href="https://cwiki.apache.org/confluence/display/FLINK/FLIP-91%3A&#43;Support&#43;SQL&#43;Gateway">FLIP-91</a> for design)
in 1.16. SQL Gateway is an extension and enhancement to SQL Client,
supporting multi-tenancy and pluggable API protocols (Endpoints), solving the problem that SQL Client
can only serve a single user and cannot be integrated with external services or components.
Currently SQL Gateway has support for REST API and HiveServer2 Protocol and users can link to
SQL Gateway via cURL, Postman, HTTP clients in various programming languages to submit stream jobs,
batch jobs and even OLAP jobs. For HiveServer2 Endpoint, please refer to the Hive Compatibility
for more details.</p>
<h2 id="hive-compatibility">
  Hive Compatibility
  <a class="anchor" href="#hive-compatibility">#</a>
</h2>
<p>To reduce the cost of migrating Hive to Flink, we introduce HiveServer2 Endpoint and
Hive Syntax Improvements in this version:</p>
<p><a href="https://nightlies.apache.org/flink/flink-docs-release-1.16/docs/dev/table/hive-compatibility/hiveserver2/">The HiveServer2 Endpoint</a>
allows users to interact with SQL Gateway with Hive JDBC/Beeline and migrate with Flink into
the Hive ecosystem (DBeaver, Apache Superset, Apache DolphinScheduler, and Apache Zeppelin).
When users connect to the HiveServer2 endpoint, the SQL Gateway registers the Hive Catalog,
switches to Hive Dialect, and uses batch execution mode to execute jobs. With these steps,
users can have the same experience as HiveServer2.</p>
<p><a href="https://nightlies.apache.org/flink/flink-docs-release-1.16/docs/dev/table/hive-compatibility/hive-dialect/overview/">Hive syntax</a>
is already the factual standard for big data processing. Flink has improved compatibility
with Hive syntax and added support for several Hive syntaxes commonly used in production.
Hive syntax compatibility can help users migrate existing Hive SQL tasks to Flink,
and it is convenient for users who are familiar with Hive syntax to use Hive syntax to
write SQL to query tables registered in Flink. The compatibility is measured using
the Hive qtest suite which contains more than 12K SQL cases. Until now, for Hive 2.3,
the compatibility has reached 94.1% for whole hive queries, and has reached 97.3%
if ACID queries are excluded.</p>
<h2 id="join-hints-for-flink-sql">
  Join Hints for Flink SQL
  <a class="anchor" href="#join-hints-for-flink-sql">#</a>
</h2>
<p>The join hint is a common solution in the industry to improve the shortcomings of the optimizer
by manually modifying the execution plans. Join is the most widely used operator in batch jobs,
and Flink supports a variety of join strategies. Missing statistics or a poor cost model of
the optimizer can lead to the wrong choice of a join strategy, which will cause slow execution
or even job failure. By specifying a <a href="https://nightlies.apache.org/flink/flink-docs-release-1.16/docs/dev/table/sql/queries/hints/#join-hints">Join Hint</a>,
the optimizer will choose the join strategy specified by the user whenever possible.
It could avoid various shortcomings of the optimizer and ensure the production availability of
the batch job.</p>
<h2 id="adaptive-hash-join">
  Adaptive Hash Join
  <a class="anchor" href="#adaptive-hash-join">#</a>
</h2>
<p>For batch jobs, the hash join operators may fail if the input data is severely skewed,
it&rsquo;s a very bad experience for users. To solve this, we introduce adaptive Hash-Join
which can automatically fall back to Sort-Merge-Join once the Hash-Join fails in runtime.
This mechanism ensures that the Hash-Join is always successful and improves the stability
by gracefully degrading from a Hash-Join to a more robust Sort-Merge-Join.</p>
<h2 id="speculative-execution-for-batch-job">
  Speculative Execution for Batch Job
  <a class="anchor" href="#speculative-execution-for-batch-job">#</a>
</h2>
<p>Speculative execution is introduced in Flink 1.16 to mitigate batch job slowness
which is caused by problematic nodes. A problematic node may have hardware problems,
accident I/O busy, or high CPU load. These problems may make the hosted tasks run
much slower than tasks on other nodes, and affect the overall execution time of a batch job.</p>
<p>When speculative execution is enabled, Flink will keep detecting slow tasks.
Once slow tasks are detected, the nodes that the slow tasks locate in will be identified
as problematic nodes and get blocked via the blocklist mechanism (<a href="https://cwiki.apache.org/confluence/display/FLINK/FLIP-224%3A&#43;Blocklist&#43;Mechanism">FLIP-224</a>).
The scheduler will create new attempts for the slow tasks and deploy them to nodes
that are not blocked, while the existing attempts will keep running.
The new attempts process the same input data and produce the same data as the original attempt.
Once any attempt finishes first, it will be admitted as the only finished attempt of the task,
and the remaining attempts of the task will be canceled.</p>
<p>Most existing sources can work with speculative execution (<a href="https://cwiki.apache.org/confluence/display/FLINK/FLIP-245%3A&#43;Source&#43;Supports&#43;Speculative&#43;Execution&#43;For&#43;Batch&#43;Job">FLIP-245</a>).
Only if a source uses <code>SourceEvent</code>, it must implement <code>SupportsHandleExecutionAttemptSourceEvent</code> interface to support
speculative execution. Sinks do not support speculative execution yet so that
speculative execution will not happen on sinks at the moment.</p>
<p>The Web UI &amp; REST API are also improved (<a href="https://cwiki.apache.org/confluence/display/FLINK/FLIP-249%3A&#43;Flink&#43;Web&#43;UI&#43;Enhancement&#43;for&#43;Speculative&#43;Execution">FLIP-249</a>)
to display multiple concurrent attempts of tasks and blocked task managers.</p>
<h2 id="hybrid-shuffle-mode">
  Hybrid Shuffle Mode
  <a class="anchor" href="#hybrid-shuffle-mode">#</a>
</h2>
<p>We have introduced a new <a href="https://nightlies.apache.org/flink/flink-docs-release-1.16/docs/ops/batch/batch_shuffle">Hybrid Shuffle</a>
Mode for batch executions. It combines the advantages of blocking shuffle and
pipelined shuffle (in streaming mode).</p>
<ul>
<li>Like blocking shuffle, it does not require upstream and downstream tasks to run simultaneously,
which allows executing a job with little resources.</li>
<li>Like pipelined shuffle, it does not require downstream tasks to be executed
after upstream tasks finish, which reduces the overall execution time of the job when
given sufficient resources.</li>
<li>It adapts to custom preferences between persisting less data and restarting less tasks on failures,
by providing different spilling strategies.</li>
</ul>
<p>Note: This feature is experimental and by default not activated.</p>
<h2 id="further-improvements-of-blocking-shuffle">
  Further improvements of blocking shuffle
  <a class="anchor" href="#further-improvements-of-blocking-shuffle">#</a>
</h2>
<p>We further improved the blocking shuffle usability and performance in this version,
including adaptive network buffer allocation, sequential IO optimization and result partition reuse
which allows multiple consumer vertices reusing the same physical result partition to reduce disk IO
and storage space. These optimizations can achieve an overall 7% performance gain for
the TPC-DS test with a scale of 10 TB. In addition, two more compression algorithms (LZO and ZSTD)
with higher compression ratio were introduced which can further reduce the storage space with
some CPU cost compared to the default LZ4 compression algorithm.</p>
<h2 id="dynamic-partition-pruning">
  Dynamic Partition Pruning
  <a class="anchor" href="#dynamic-partition-pruning">#</a>
</h2>
<p>For batch jobs, partitioned tables are more widely used than non-partitioned tables in
production environments. Currently Flink has support for static partition pruning,
where the optimizer pushes down the partition field related filter conditions in the WHERE clause
into the Source Connector during the optimization phase, thus reducing unnecessary partition scan IO.
The <a href="https://en.wikipedia.org/wiki/Star_schema">star-schema</a> is the simplest of
the most commonly used data mart patterns. We have found that many user jobs cannot use
static partition pruning because partition pruning information can only be determined in execution,
which requires <a href="https://cwiki.apache.org/confluence/display/FLINK/FLIP-248%3A&#43;Introduce&#43;dynamic&#43;partition&#43;pruning">dynamic partition pruning techniques</a>,
where partition pruning information is collected at runtime based on data from other related tables,
thus reducing unnecessary partition scan IO for partitioned tables. The use of dynamic partition pruning
has been validated with the 10 TB dataset TPC-DS to improve performance by up to 30%.</p>
<h1 id="stream-processing">
  Stream Processing
  <a class="anchor" href="#stream-processing">#</a>
</h1>
<p>In 1.16, we have made improvements in Checkpoints, SQL, Connector and other fields,
so that stream computing can continue to lead.</p>
<h2 id="generalized-incremental-checkpoint">
  Generalized incremental checkpoint
  <a class="anchor" href="#generalized-incremental-checkpoint">#</a>
</h2>
<p>Changelog state backend aims at making checkpoint intervals shorter and more predictable,
this release is prod-ready and is dedicated to adapting changelog state backend to
the existing state backends and improving the usability of changelog state backend:</p>
<ul>
<li>Support state migration</li>
<li>Support local recovery</li>
<li>Introduce file cache to optimize restoring</li>
<li>Support switch based on checkpoint</li>
<li>Improve the monitoring experience of changelog state backend
<ul>
<li>expose changelog&rsquo;s metrics</li>
<li>expose changelog&rsquo;s configuration to webUI</li>
</ul>
</li>
</ul>
<p>Table 1: The comparison between Changelog Enabled / Changelog Disabled on value state
(see <a href="https://flink.apache.org/2022/05/30/changelog-state-backend.html">this blog</a> for more details)</p>
<p>{:class=&ldquo;table table-bordered&rdquo;}</p>
<table>
<thead>
<tr>
<th>Percentile</th>
<th>End to End Duration</th>
<th>Checkpointed Data Size<sup>*<sup></th>
<th>Full Checkpoint Data Size<sup>*<sup></th>
</tr>
</thead>
<tbody>
<tr>
<td>50%</td>
<td>311ms / 5s</td>
<td>14.8MB / 3.05GB</td>
<td>24.2GB / 18.5GB</td>
</tr>
<tr>
<td>90%</td>
<td>664ms / 6s</td>
<td>23.5MB / 4.52GB</td>
<td>25.2GB / 19.3GB</td>
</tr>
<tr>
<td>99%</td>
<td>1s / 7s</td>
<td>36.6MB / 5.19GB</td>
<td>25.6GB / 19.6GB</td>
</tr>
<tr>
<td>99.9%</td>
<td>1s / 10s</td>
<td>52.8MB / 6.49GB</td>
<td>25.7GB / 19.8GB</td>
</tr>
</tbody>
</table>
<h2 id="rocksdb-rescaling-improvement--rescaling-benchmark">
  RocksDB rescaling improvement &amp; rescaling benchmark
  <a class="anchor" href="#rocksdb-rescaling-improvement--rescaling-benchmark">#</a>
</h2>
<p>Rescaling is a frequent operation for cloud services built on Apache Flink, this release leverages
<a href="https://rocksdb.org/blog/2018/11/21/delete-range.html">deleteRange</a> to optimize the rescaling of
Incremental RocksDB state backend. deleteRange is used to avoid massive scan-and-delete operations,
for upscaling with a large number of states that need to be deleted,
the speed of restoring can be almost <a href="https://github.com/apache/flink/pull/19033#issuecomment-1072267658">increased by 2~10 times</a>.</p>
<center>
<img src="/img/rocksdb_rescaling_benchmark.png" style="width:90%;margin:15px">
</center>
<h2 id="improve-monitoring-experience-and-usability-of-state-backend">
  Improve monitoring experience and usability of state backend
  <a class="anchor" href="#improve-monitoring-experience-and-usability-of-state-backend">#</a>
</h2>
<p>This release also improves the monitoring experience and usability of state backend.
Previously, RocksDB&rsquo;s log was located in its own DB folder, which made debugging RocksDB not so easy.
This release lets RocksDB&rsquo;s log stay in Flink&rsquo;s log directory by default. RocksDB statistics-based
metrics are introduced to help debug the performance at the database level, e.g. total block cache hit/miss
count within the DB.</p>
<h2 id="support-overdraft-buffer">
  Support overdraft buffer
  <a class="anchor" href="#support-overdraft-buffer">#</a>
</h2>
<p>A new concept of <a href="https://nightlies.apache.org/flink/flink-docs-release-1.16/docs/deployment/memory/network_mem_tuning/#overdraft-buffers">overdraft network buffer</a>
is introduced to mitigate the effects of uninterruptible blocking a subtask thread during back pressure,
which can be turned on through the <a href="https://nightlies.apache.org/flink/flink-docs-release-1.16/docs/deployment/config/#taskmanager-network-memory-max-overdraft-buffers-per-gate">taskmanager.network.memory.max-overdraft-buffers-per-gate</a>
configuration parameter.<br>
Starting from 1.16.0, Flink subtask can request by default up to 5 extra (overdraft) buffers over
the regular configured amount.  This change can slightly increase memory consumption of
the Flink Job but vastly reduce the checkpoint duration of the unaligned checkpoint.
If the subtask is back pressured by downstream subtasks and the subtask requires more than
a single network buffer to finish what it&rsquo;s currently doing, overdraft buffer comes into play.
Read more about this in <a href="https://nightlies.apache.org/flink/flink-docs-release-1.16/docs/deployment/memory/network_mem_tuning/#overdraft-buffers">the documentation</a>.</p>
<h2 id="timeout-aligned-to-unaligned-checkpoint-barrier-in-the-output-buffers-of-an-upstream-subtask">
  Timeout aligned to unaligned checkpoint barrier in the output buffers of an upstream subtask
  <a class="anchor" href="#timeout-aligned-to-unaligned-checkpoint-barrier-in-the-output-buffers-of-an-upstream-subtask">#</a>
</h2>
<p>This release updates the timing of switching from Aligned Checkpoint (AC) to Unaligned Checkpoint (UC).
With UC enabled, if <a href="https://nightlies.apache.org/flink/flink-docs-release-1.16/docs/ops/state/checkpointing_under_backpressure/#aligned-checkpoint-timeout">execution.checkpointing.aligned-checkpoint-timeout</a>
is configured, each checkpoint will still begin as an AC, but when the global checkpoint duration
exceeds the aligned-checkpoint-timeout, if the AC has not been completed,
then the checkpoint will be switched to unaligned.</p>
<p>Previously, the switch of one subtask needs to wait for all barriers from upstream.
If the back pressure is severe, the downstream subtask may not receive all barriers
within <a href="https://nightlies.apache.org/flink/flink-docs-release-1.16/docs/deployment/config/#execution-checkpointing-timeout">checkpointing-timeout</a>,
causing the checkpoint to fail.</p>
<p>In this release, if the barrier cannot be sent from the output buffer to the downstream task
within the <code>execution.checkpointing.aligned-checkpoint-timeout</code>, Flink lets upstream subtasks
switch to UC first to send barriers to downstream, thereby decreasing
the probability of checkpoint timeout during back pressure.
More details can be found in <a href="https://nightlies.apache.org/flink/flink-docs-release-1.16/docs/ops/state/checkpointing_under_backpressure/#aligned-checkpoint-timeout">this documentation</a>.</p>
<h2 id="non-determinism-in-stream-processing">
  Non-Determinism In Stream Processing
  <a class="anchor" href="#non-determinism-in-stream-processing">#</a>
</h2>
<p>Users often complain about the high cost of understanding stream processing.
One of the pain points is the non-determinisim in stream processing (usually not intuitive)
which may cause wrong results or errors. These pain points have been around since the
early days of Flink SQL.</p>
<p>For complex streaming jobs, now it&rsquo;s possible to detect and resolve potential correctness issues
before running. If the problems can’t be resolved completely, a detailed message could prompt users to
adjust the SQL so as to avoid introducing non-deterministic problems. More details can be found
in <a href="https://nightlies.apache.org/flink/flink-docs-release-1.16/docs/dev/table/concepts/determinism">the documentation</a>.</p>
<h2 id="enhanced-lookup-join">
  Enhanced Lookup Join
  <a class="anchor" href="#enhanced-lookup-join">#</a>
</h2>
<p>Lookup join is widely used in stream processing, and we have introduced several improvements:</p>
<ul>
<li>Adds a unified abstraction for lookup source cache and
<a href="https://cwiki.apache.org/confluence/display/FLINK/FLIP-221%3A&#43;Abstraction&#43;for&#43;lookup&#43;source&#43;cache&#43;and&#43;metric">related metrics</a>
to speed up lookup queries</li>
<li>Introduces the configurable asynchronous mode (ALLOW_UNORDERED) via
<a href="https://nightlies.apache.org/flink/flink-docs-release-1.16/docs/dev/table/config/#table-exec-async-lookup-output-mode">job configuration</a>
or <a href="https://nightlies.apache.org/flink/flink-docs-release-1.16/docs/dev/table/sql/queries/hints/#lookup">lookup hint</a>
to significantly improve query throughput without compromising correctness.</li>
<li><a href="https://nightlies.apache.org/flink/flink-docs-master/docs/dev/table/sql/queries/hints/#3-enable-delayed-retry-strategy-for-lookup">Retryable lookup mechanism</a>
gives users more tools to solve the delayed updates issue in external systems.</li>
</ul>
<h2 id="retry-support-for-async-io">
  Retry Support For Async I/O
  <a class="anchor" href="#retry-support-for-async-io">#</a>
</h2>
<p>Introduces a built-in retry mechanism for <a href="https://nightlies.apache.org/flink/flink-docs-release-1.16/docs/dev/datastream/operators/asyncio/#retry-support">asynchronous I/O</a>
that is transparent to the user&rsquo;s existing code, allowing flexibility to meet
the user&rsquo;s retry and exception handling needs.</p>
<h1 id="pyflink">
  PyFlink
  <a class="anchor" href="#pyflink">#</a>
</h1>
<p>In Flink 1.15, we have introduced a new execution mode &rsquo;thread&rsquo; mode in
which the user-defined Python functions will be executed in the JVM via JNI instead of
in a separate Python process. However, it&rsquo;s only supported for Python scalar functions in
the Table API &amp; SQL in Flink 1.15. In this release, we have provided more comprehensive support for it.
It has also been supported in the Python DataStream API and also Python table functions
in the Table API &amp; SQL.</p>
<p>We are also continuing to fill in the last few missing features in Python API. In this release,
we have provided more comprehensive support for Python DataStream API and supported features
such as side output, broadcast state, etc and have also finalized the windowing support.
We have also added support for more connectors and formats in the Python DataStream API,
e.g. added support for connectors elasticsearch, kinesis, pulsar, hybrid source, etc and
formats orc, parquet, etc. With all these features added, the Python API should have aligned
most notable features in the Java &amp; Scala API and users should be able to develop most
kinds of Flink jobs using Python language smoothly.</p>
<h1 id="others">
  Others
  <a class="anchor" href="#others">#</a>
</h1>
<h2 id="new-sql-syntax">
  New SQL Syntax
  <a class="anchor" href="#new-sql-syntax">#</a>
</h2>
<p>In 1.16, we extend more DDL syntaxes which could help users to better use SQL:</p>
<ul>
<li><a href="https://nightlies.apache.org/flink/flink-docs-release-1.16/docs/dev/table/sql/create/#create-function">USING JAR</a>
supports dynamic loading of UDF jar to help platform developers to easily manage UDF.</li>
<li><a href="https://nightlies.apache.org/flink/flink-docs-release-1.16/docs/dev/table/sql/create/#as-select_statement">CREATE TABLE AS SELECT</a> (CTAS)
supports users to create new tables based on existing tables and queries.</li>
<li><a href="https://nightlies.apache.org/flink/flink-docs-release-1.16/zh/docs/dev/table/sql/analyze">ANALYZE TABLE</a>
supports users to manually generate table statistics so that the optimizer could
generate better execution plans.</li>
</ul>
<h2 id="cache-in-datastream-for-interactive-programming">
  Cache in DataStream for Interactive Programming
  <a class="anchor" href="#cache-in-datastream-for-interactive-programming">#</a>
</h2>
<p>Supports caching the result of a transformation via <a href="https://nightlies.apache.org/flink/flink-docs-release-1.16/docs/dev/datastream/operators/overview/#cache">DataStream#cache</a>.
The cached intermediate result is generated lazily at the first time the intermediate result is
computed so that the result can be reused by later jobs. If the cache is lost,
it will be recomputed using the original transformations. Currently only batch mode is supported.
This feature is very useful for ML and interactive programming in Python.</p>
<h2 id="history-server--completed-jobs-information-enhancement">
  History Server &amp; Completed Jobs Information Enhancement
  <a class="anchor" href="#history-server--completed-jobs-information-enhancement">#</a>
</h2>
<p>We have enhanced the experiences of viewing completed jobs’ information in this release.</p>
<ul>
<li>JobManager / HistoryServer WebUI now provides detailed execution time metrics,
including duration tasks spent in each execution state and the accumulated
busy / idle / back-pressured time during running.</li>
<li>JobManager / HistoryServer WebUI now provides aggregation of major SubTask metrics,
grouped by Task or TaskManager.</li>
<li>JobManager / HistoryServer WebUI now provides more environmental information,
including environment variables, JVM options and classpath.</li>
<li>HistoryServer now supports <a href="https://nightlies.apache.org/flink/flink-docs-release-1.16/docs/deployment/advanced/historyserver/#log-integration">browsing logs</a>
from external log archiving services.</li>
</ul>
<h2 id="protobuf-format">
  Protobuf format
  <a class="anchor" href="#protobuf-format">#</a>
</h2>
<p>Flink now supports the Protocol Buffers (Protobuf) format. This allows you to use this format directly
in your Table API or SQL applications.</p>
<h2 id="introduce-configurable-ratelimitingstrategy-for-async-sink">
  Introduce configurable RateLimitingStrategy for Async Sink
  <a class="anchor" href="#introduce-configurable-ratelimitingstrategy-for-async-sink">#</a>
</h2>
<p>The Async Sink was implemented in 1.15 to allow users to easily implement
their own custom asynchronous sinks. We have now extended it to support
a configurable RateLimitingStrategy. This means sink implementers can now customize
how their Async Sink behaves when requests fail, depending on the specific sink.
If no RateLimitingStrategy is specified, it will default to the current default of AIMDScalingStrategy.</p>
<h1 id="upgrade-notes">
  Upgrade Notes
  <a class="anchor" href="#upgrade-notes">#</a>
</h1>
<p>We aim to make upgrades as smooth as possible, but some of the changes require users to
adjust some parts of the program when upgrading to Apache Flink 1.16. Please take a look at
the release notes for a list of adjustments to make and issues to check during upgrades.</p>
<h1 id="list-of-contributors">
  List of Contributors
  <a class="anchor" href="#list-of-contributors">#</a>
</h1>
<p>The Apache Flink community would like to thank each one of the contributors that have made this release possible:</p>
<p>1996fanrui, Ada Wang, Ada Wong, Ahmed Hamdy, Aitozi, Alexander Fedulov, Alexander Preuß, Alexander Trushev,
Andriy Redko, Anton Kalashnikov, Arvid Heise, Ben Augarten, Benchao Li, BiGsuw, Biao Geng, Bobby Richard,
Brayno, CPS794, Cheng Pan, Chengkai Yang, Chesnay Schepler, Danny Cranmer, David N Perkins, Dawid Wysakowicz,
Dian Fu, DingGeGe, EchoLee5, Etienne Chauchot, Fabian Paul, Ferenc Csaky, Francesco Guardiani, Gabor Somogyi,
Gen Luo, Gyula Fora, Haizhou Zhao, Hangxiang Yu, Hao Wang, Hong Liang Teoh, Hong Teoh, Hongbo Miao, HuangXingBo,
Ingo Bürk, Jacky Lau, Jane Chan, Jark Wu, Jay Li, Jia Liu, Jie Wang, Jin, Jing Ge, Jing Zhang, Jingsong Lee,
Jinhu Wu, Joe Moser, Joey Pereira, Jun He, JunRuiLee, Juntao Hu, JustDoDT, Kai Chen, Krzysztof Chmielewski,
Krzysztof Dziolak, Kyle Dong, LeoZhang, Levani Kokhreidze, Lihe Ma, Lijie Wang, Liu Jiangang, Luning Wang,
Marios Trivyzas, Martijn Visser, MartijnVisser, Mason Chen, Matthias Pohl, Metehan Yıldırım, Michael, Mingde Peng,
Mingliang Liu, Mulavar, Márton Balassi, Nie yingping, Niklas Semmler, Paul Lam, Paul Lin, Paul Zhang, PengYuan,
Piotr Nowojski, Qingsheng Ren, Qishang Zhong, Ran Tao, Robert Metzger, Roc Marshal, Roman Boyko, Roman Khachatryan,
Ron, Ron Cohen, Ruanshubin, Rudi Kershaw, Rufus Refactor, Ryan Skraba, Sebastian Mattheis, Sergey, Sergey Nuyanzin,
Shengkai, Shubham Bansal, SmirAlex, Smirnov Alexander, SteNicholas, Steven van Rossum, Suhan Mao, Tan Yuxin,
Tartarus0zm, TennyZhuang, Terry Wang, Thesharing, Thomas Weise, Timo Walther, Tom, Tony Wei, Weijie Guo, Wencong Liu,
WencongLiu, Xintong Song, Xuyang, Yangze Guo, Yi Tang, Yu Chen, Yuan Huang, Yubin Li, Yufan Sheng, Yufei Zhang,
Yun Gao, Yun Tang, Yuxin Tan, Zakelly, Zhanghao Chen, Zhu Zhu, Zichen Liu, Zili Sun, acquachen, bgeng777, billyrrr,
bzhao, caoyu, chenlei677, chenzihao, chenzihao5, coderap, cphe, davidliu, dependabot[bot], dkkb, dusukang, empcl,
eyys, fanrui, fengjiankun, fengli, fredia, gabor.g.somogyi, godfreyhe, gongzhongqiang, harker2015, hongli,
huangxingbo, huweihua, jayce, jaydonzhou, jiabao.sun, kevin.cyj, kurt, lidefu, lijiewang.wlj, liliwei, lincoln lee,
lincoln.lil, littleeleventhwolf, liufangqi, liujia10, liujiangang, liujingmao, liuyongvs, liuzhuang2017, longwang,
lovewin99, luoyuxia, mans2singh, maosuhan, mayue.fight, mayuehappy, nieyingping, pengmide, pengmingde, polaris6,
pvary, qinjunjerry, realdengziqi, root, shammon, shihong90, shuiqiangchen, slinkydeveloper, snailHumming, snuyanzin,
suxinglee, sxnan, tison, trushev, tsreaper, unknown, wangfeifan, wangyang0918, wangzhiwu, wenbingshen, xiangqiao123,
xuyang, yangjf2019, yangjunhan, yangsanity, yangxin, ylchou, yuchengxin, yunfengzhou-hub, yuxia Luo, yuzelin,
zhangchaoming, zhangjingcun, zhangmang, zhangzhengqi3, zhaoweinan, zhengyunhong.zyh, zhenyu xing, zhouli,
zhuanshenbsj1, zhuzhu.zz, zoucao, zp, 周磊, 饶紫轩,, 鲍健昕 愚鲤, 帝国阿三</p>
</p>
</article>

          



  
    
    <div class="edit-this-page">
      <p>
        <a href="https://cwiki.apache.org/confluence/display/FLINK/Flink+Translation+Specifications">Want to contribute translation?</a>
      </p>
      <p>
        <a href="//github.com/apache/flink-web/edit/asf-site/docs/content/posts/2022-10-28-1.16-announcement.md">
          Edit This Page<i class="fa fa-edit fa-fw"></i> 
        </a>
      </p>
    </div>

        </section>
        
          <aside class="book-toc">
            


<nav id="TableOfContents"><h3>On This Page <a href="javascript:void(0)" class="toc" onclick="collapseToc()"><i class="fa fa-times" aria-hidden="true"></i></a></h3>
  <ul>
    <li><a href="#understanding-streaming-warehouses">Understanding Streaming Warehouses</a></li>
    <li><a href="#batch-processing">Batch processing</a>
      <ul>
        <li><a href="#sql-gateway">SQL Gateway</a></li>
        <li><a href="#hive-compatibility">Hive Compatibility</a></li>
        <li><a href="#join-hints-for-flink-sql">Join Hints for Flink SQL</a></li>
        <li><a href="#adaptive-hash-join">Adaptive Hash Join</a></li>
        <li><a href="#speculative-execution-for-batch-job">Speculative Execution for Batch Job</a></li>
        <li><a href="#hybrid-shuffle-mode">Hybrid Shuffle Mode</a></li>
        <li><a href="#further-improvements-of-blocking-shuffle">Further improvements of blocking shuffle</a></li>
        <li><a href="#dynamic-partition-pruning">Dynamic Partition Pruning</a></li>
      </ul>
    </li>
    <li><a href="#stream-processing">Stream Processing</a>
      <ul>
        <li><a href="#generalized-incremental-checkpoint">Generalized incremental checkpoint</a></li>
        <li><a href="#rocksdb-rescaling-improvement--rescaling-benchmark">RocksDB rescaling improvement &amp; rescaling benchmark</a></li>
        <li><a href="#improve-monitoring-experience-and-usability-of-state-backend">Improve monitoring experience and usability of state backend</a></li>
        <li><a href="#support-overdraft-buffer">Support overdraft buffer</a></li>
        <li><a href="#timeout-aligned-to-unaligned-checkpoint-barrier-in-the-output-buffers-of-an-upstream-subtask">Timeout aligned to unaligned checkpoint barrier in the output buffers of an upstream subtask</a></li>
        <li><a href="#non-determinism-in-stream-processing">Non-Determinism In Stream Processing</a></li>
        <li><a href="#enhanced-lookup-join">Enhanced Lookup Join</a></li>
        <li><a href="#retry-support-for-async-io">Retry Support For Async I/O</a></li>
      </ul>
    </li>
    <li><a href="#pyflink">PyFlink</a></li>
    <li><a href="#others">Others</a>
      <ul>
        <li><a href="#new-sql-syntax">New SQL Syntax</a></li>
        <li><a href="#cache-in-datastream-for-interactive-programming">Cache in DataStream for Interactive Programming</a></li>
        <li><a href="#history-server--completed-jobs-information-enhancement">History Server &amp; Completed Jobs Information Enhancement</a></li>
        <li><a href="#protobuf-format">Protobuf format</a></li>
        <li><a href="#introduce-configurable-ratelimitingstrategy-for-async-sink">Introduce configurable RateLimitingStrategy for Async Sink</a></li>
      </ul>
    </li>
    <li><a href="#upgrade-notes">Upgrade Notes</a></li>
    <li><a href="#list-of-contributors">List of Contributors</a></li>
  </ul>
</nav>


          </aside>
          <aside class="expand-toc hidden">
            <a class="toc" onclick="expandToc()" href="javascript:void(0)">
              <i class="fa fa-bars" aria-hidden="true"></i>
            </a>
          </aside>
        
      </main>

      <footer>
        


<div class="separator"></div>
<div class="panels">
  <div class="wrapper">
      <div class="panel">
        <ul>
          <li>
            <a href="https://flink-packages.org/">flink-packages.org</a>
          </li>
          <li>
            <a href="https://www.apache.org/">Apache Software Foundation</a>
          </li>
          <li>
            <a href="https://www.apache.org/licenses/">License</a>
          </li>
          
          
          
            
          
            
          
          

          
            
              
            
          
            
              
                <li>
                  <a  href="/zh/">
                    <i class="fa fa-globe" aria-hidden="true"></i>&nbsp;中文版
                  </a>
                </li>
              
            
          
       </ul>
      </div>
      <div class="panel">
        <ul>
          <li>
            <a href="/what-is-flink/security">Security</a-->
          </li>
          <li>
            <a href="https://www.apache.org/foundation/sponsorship.html">Donate</a>
          </li>
          <li>
            <a href="https://www.apache.org/foundation/thanks.html">Thanks</a>
          </li>
       </ul>
      </div>
      <div class="panel icons">
        <div>
          <a href="/posts">
            <div class="icon flink-blog-icon"></div>
            <span>Flink blog</span>
          </a>
        </div>
        <div>
          <a href="https://github.com/apache/flink">
            <div class="icon flink-github-icon"></div>
            <span>Github</span>
          </a>
        </div>
        <div>
          <a href="https://twitter.com/apacheflink">
            <div class="icon flink-twitter-icon"></div>
            <span>Twitter</span>
          </a>
        </div>
      </div>
  </div>
</div>

<hr/>

<div class="container disclaimer">
  <p>The contents of this website are © 2024 Apache Software Foundation under the terms of the Apache License v2. Apache Flink, Flink, and the Flink logo are either registered trademarks or trademarks of The Apache Software Foundation in the United States and other countries.</p>
</div>



      </footer>
    
  </body>
</html>






