<!doctype html>
<html lang="en-US" dir="ltr" class="docs-wrapper docs-doc-page docs-version-2.0 plugin-docs plugin-id-default docs-doc-id-admin-manual/config/fe-config" data-has-hydrated="false">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width,initial-scale=1,minimum-scale=1,maximum-scale=1,user-scalable=no">
<meta name="generator" content="Docusaurus v2.4.3">
<link rel="alternate" type="application/rss+xml" href="/blog/rss.xml" title="Apache Doris RSS Feed">
<link rel="alternate" type="application/atom+xml" href="/blog/atom.xml" title="Apache Doris Atom Feed">

<link rel="preconnect" href="https://www.google-analytics.com">
<link rel="preconnect" href="https://www.googletagmanager.com">
<script async src="https://www.googletagmanager.com/gtag/js?id=G-DT7W9E9722"></script>
<script>function gtag(){dataLayer.push(arguments)}window.dataLayer=window.dataLayer||[],gtag("js",new Date),gtag("config","G-DT7W9E9722",{anonymize_ip:!0})</script>



<link rel="preconnect" href="https://analytics.apache.org/">
<script>var _paq=window._paq=window._paq||[];_paq.push(["setRequestMethod","POST"]),_paq.push(["trackPageView"]),_paq.push(["enableLinkTracking"]),_paq.push(["enableHeartBeatTimer"]),function(){var e="https://analytics.apache.org/";_paq.push(["setRequestMethod","POST"]),_paq.push(["setTrackerUrl",e+"matomo.php"]),_paq.push(["setSiteId","43"]);var a=document,t=a.createElement("script"),p=a.getElementsByTagName("script")[0];t.type="text/javascript",t.async=!0,t.src=e+"matomo.js",p.parentNode.insertBefore(t,p)}()</script>



<link rel="icon" href="/images/logo-only.png">
<link rel="manifest" href="/manifest.json">
<meta name="theme-color" content="#FFFFFF">
<meta name="apple-mobile-web-app-capable" content="yes">
<meta name="apple-mobile-web-app-status-bar-style" content="#000">
<link rel="apple-touch-icon" href="/img/docusaurus.png">
<link rel="mask-icon" href="/img/docusaurus.svg" color="rgb(37, 194, 160)">
<meta name="msapplication-TileImage" content="/img/docusaurus.png">
<meta name="msapplication-TileColor" content="#000">



<link rel="stylesheet" href="https://cdn-font.hyperos.mi.com/font/css?family=MiSans:100,200,300,400,450,500,600,650,700,900:Chinese_Simplify,Latin&display=swap">
<link rel="stylesheet" href="https://cdn-font.hyperos.mi.com/font/css?family=MiSans_Latin:100,200,300,400,450,500,600,650,700,900:Latin&display=swap">
<script src="/js/custom-script.js"></script><title data-rh="true">FE Configuration - Apache Doris</title><meta data-rh="true" name="viewport" content="width=device-width,initial-scale=1"><meta data-rh="true" name="twitter:card" content="summary_large_image"><meta data-rh="true" property="og:url" content="https://doris.apache.org/docs/2.0/admin-manual/config/fe-config"><meta data-rh="true" name="docusaurus_locale" content="en"><meta data-rh="true" name="docsearch:language" content="en"><meta data-rh="true" name="docusaurus_version" content="2.0"><meta data-rh="true" name="docusaurus_tag" content="docs-default-2.0"><meta data-rh="true" name="docsearch:version" content="2.0"><meta data-rh="true" name="docsearch:docusaurus_tag" content="docs-default-2.0"><meta data-rh="true" property="og:title" content="FE Configuration - Apache Doris"><meta data-rh="true" name="description" content="&lt;!--"><meta data-rh="true" property="og:description" content="&lt;!--"><link data-rh="true" rel="icon" href="/images/favicon.ico"><link data-rh="true" rel="canonical" href="https://doris.apache.org/docs/2.0/admin-manual/config/fe-config"><link data-rh="true" rel="alternate" href="https://doris.apache.org/docs/2.0/admin-manual/config/fe-config" hreflang="en-US"><link data-rh="true" rel="alternate" href="https://doris.apache.org/zh-CN/docs/2.0/admin-manual/config/fe-config" hreflang="zh-Hans-CN"><link data-rh="true" rel="alternate" href="https://doris.apache.org/docs/2.0/admin-manual/config/fe-config" hreflang="x-default"><link rel="stylesheet" href="https://cdnd.selectdb.com/assets/css/styles.2bd95c40.css">
<link rel="preload" href="https://cdnd.selectdb.com/assets/js/runtime~main.17e841a6.js" as="script">
<link rel="preload" href="https://cdnd.selectdb.com/assets/js/main.c9678103.js" as="script">
</head>
<body class="navigation-with-keyboard">
<script>!function(){function t(t){document.documentElement.setAttribute("data-theme",t)}var e=function(){var t=null;try{t=new URLSearchParams(window.location.search).get("docusaurus-theme")}catch(t){}return t}()||function(){var t=null;try{t=localStorage.getItem("theme")}catch(t){}return t}();t(null!==e?e:"light")}(),document.documentElement.setAttribute("data-announcement-bar-initially-dismissed",function(){try{return"true"===localStorage.getItem("docusaurus.announcement.dismiss")}catch(t){}return!1}())</script><div id="__docusaurus">
<div role="region" aria-label="Skip to main content"><a class="skipToContent_fXgn" href="#__docusaurus_skipToContent_fallback">Skip to main content</a></div><div class="announcementBar_s0pr" style="background-color:#3C2FD4;color:#FFFFFF" role="banner"><div class="announcementBarPlaceholder_qxfj"></div><div class="announcementBarContent_dpRF"><a href="https://github.com/apache/doris" target="_blank" style="display: flex; width: 100%; align-items: center; justify-content: center; margin-left: 4px; text-decoration: none; color: white">Do you ❤️ Doris? Give us a 🌟 on GitHub 
                        <img style="width: 1.2rem; height: 1.2rem; margin-left: 0.4rem;" src="/images/github-white-icon.svg">
                    </a></div><button type="button" class="clean-btn close announcementBarClose_iXyO" aria-label="Close"><svg viewBox="0 0 15 15" width="14" height="14" style="color:white"><g stroke="currentColor" stroke-width="3.1"><path d="M.75.75l13.5 13.5M14.25.75L.75 14.25"></path></g></svg></button></div><nav aria-label="Main" class="navbar navbar--fixed-top"><div class="navbar__inner" style="padding:"><div class="navbar__items"><div class="navbar-left"><div class="navbar-logo-wrapper flex items-center"><a class="navbar__brand" href="/"><div class="navbar__logo"><img src="https://cdnd.selectdb.com/images/logo.svg" alt="Apache Doris" class="themedImage_ToTc themedImage--light_HNdA"><img src="https://cdnd.selectdb.com/images/logo.svg" alt="Apache Doris" class="themedImage_ToTc themedImage--dark_i4oU"></div><b class="navbar__title text--truncate"></b></a></div><a class="navbar__item navbar__link" style="text-align:center" href="/docs/get-starting/quick-start">Docs</a><a class="navbar__item navbar__link" style="text-align:center" href="/blog">Blog</a><a class="navbar__item navbar__link" style="text-align:center" href="/users">Users</a><a href="https://github.com/apache/doris/discussions" target="_blank" rel="noopener noreferrer" class="navbar__item navbar__link" style="text-align:center">Discussions</a><a class="navbar__item navbar__link" style="text-align:center" href="/ecosystem/cluster-management">Ecosystem</a><a class="navbar__item navbar__link" style="text-align:center" href="/community/join-community">Community</a></div></div><div class="navbar__items navbar__items--right"><button aria-label="Toggle navigation bar" aria-expanded="false" class="navbar__toggle clean-btn" type="button"><svg width="30" height="30" viewBox="0 0 30 30" aria-hidden="true"><path stroke="currentColor" stroke-linecap="round" stroke-miterlimit="10" stroke-width="2" d="M4 7h22M4 15h22M4 23h22"></path></svg></button><div class="docs-search searchBox_H2mL"><div class="navbar__search searchBarContainer_PzyC"><input placeholder="Search" aria-label="Search" class="navbar__search-input navbarSearchInput_tb6T"><div class="loadingRing__K5d searchBarLoadingRing_e2f0"><div></div><div></div><div></div><div></div></div><div class="searchHintContainer_m7ml"><kbd class="searchHint_zuPL">ctrl</kbd><kbd class="searchHint_zuPL">K</kbd></div></div></div><div class="custom-navbar-item navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link"><svg class="icon-language" xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16" fill="none"><path d="M7.75756 14.3L10.5816 6.91667H11.8759L14.7 14.3H13.4057L12.7501 12.4167H9.74113L9.06873 14.3H7.75756ZM10.1109 11.35H12.3467L11.254 8.3H11.2036L10.1109 11.35ZM2.84908 12.45L1.97498 11.5833L5.11841 8.48333C4.72618 8.05 4.38439 7.60267 4.09302 7.14133C3.80165 6.68044 3.54389 6.19444 3.31976 5.68333H4.61412C4.80463 6.06111 5.00635 6.39711 5.21927 6.69133C5.43219 6.986 5.68434 7.29444 5.97571 7.61667C6.43519 7.12778 6.81621 6.62511 7.11879 6.10867C7.42137 5.59178 7.67352 5.03889 7.87523 4.45H1V3.23333H5.33694V2H6.58087V3.23333H10.9178V4.45H9.11916C8.89503 5.18333 8.59805 5.89155 8.22824 6.57467C7.85842 7.25822 7.39895 7.90555 6.84983 8.51667L8.3459 10.0167L7.87523 11.2833L5.95891 9.38333L2.84908 12.45Z" fill="#4C576C"></path></svg></a><ul class="dropdown__menu"><li><a href="/docs/2.0/admin-manual/config/fe-config" target="_self" rel="noopener noreferrer" class="dropdown__link dropdown__link--active" style="text-align:center">English</a></li><li><a href="/zh-CN/docs/2.0/admin-manual/config/fe-config" target="_self" rel="noopener noreferrer" class="dropdown__link" style="text-align:center">中文</a></li></ul></div><div class="custom-navbar-item navbar__item dropdown dropdown--hoverable dropdown--right"><a class="navbar__link" aria-haspopup="true" aria-expanded="false" role="button" href="/docs/2.0/get-starting/what-is-apache-doris"><span class="text-sm">Versions: <!-- -->2.0</span></a><ul class="dropdown__menu"><li><a class="dropdown__link" style="text-align:center" href="/docs/dev/admin-manual/config/fe-config">Dev</a></li><li><a class="dropdown__link" style="text-align:center" href="/docs/admin-manual/config/fe-config">2.1</a></li><li><a aria-current="page" class="dropdown__link dropdown__link--active" style="text-align:center" href="/docs/2.0/admin-manual/config/fe-config">2.0</a></li><li><a class="dropdown__link" style="text-align:center" href="/docs/1.2/admin-manual/config/fe-config">1.2</a></li></ul></div><a class="navbar__item navbar__link header-right-button-primary navbar-download-mobile" style="text-align:center" href="/download">Download</a><a href="https://github.com/apache/doris" target="_blank" rel="noopener noreferrer" class="github-btn desktop header-right-button-github"></a><a href="https://join.slack.com/t/apachedoriscommunity/shared_invite/zt-2kl08hzc0-SPJe4VWmL_qzrFd2u2XYQA" target="_blank" rel="noopener noreferrer" class="slack-btn desktop header-right-button-slack"></a><a class="header-right-button-primary navbar-download-desktop" href="/download">Download</a></div></div><div class="navbar__bottom"></div><div role="presentation" class="navbar-sidebar__backdrop"></div></nav><div id="__docusaurus_skipToContent_fallback" class="main-wrapper mainWrapper_z2l0"><div role="region" aria-label="Skip to main content"><a class="skipToContent_fXgn" href="#__docusaurus_skipToContent_fallback">Skip to main content</a></div><div class="main-wrapper docsWrapper_BCFX"><button aria-label="Scroll back to top" class="clean-btn theme-back-to-top-button backToTopButton_sjWU" type="button"></button><div class="docPage__5DB"><aside class="theme-doc-sidebar-container docSidebarContainer_b6E3"><div class="sidebarViewport_Xe31"><div class="sidebar"><nav aria-label="Docs sidebar" class="menu custom-scrollbar menu_Y1UP menuWithAnnouncementBar_fPny"><ul class="theme-doc-sidebar-menu menu__list"><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a id="menu__group" class="menu__link menu__link_level_1 menu__link--sublist menu__link--sublist-caret" aria-expanded="false" href="/docs/2.0/get-starting/what-is-apache-doris">Getting Started</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a id="menu__group" class="menu__link menu__link_level_1 menu__link--sublist menu__link--sublist-caret" aria-expanded="false" href="/docs/2.0/install/source-install/compilation-with-docker">Installation and Deployment</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a id="menu__group" class="menu__link menu__link_level_1 menu__link--sublist menu__link--sublist-caret" aria-expanded="false" href="/docs/2.0/db-connect/database-connect">Database Connection</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a id="menu__group" class="menu__link menu__link_level_1 menu__link--sublist menu__link--sublist-caret" aria-expanded="false" href="/docs/2.0/table-design/data-type">Data Table Design</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a id="menu__group" class="menu__link menu__link_level_1 menu__link--sublist menu__link--sublist-caret" aria-expanded="false" href="/docs/2.0/data-operate/import/load-manual">Data Manipulation</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a id="menu__group" class="menu__link menu__link_level_1 menu__link--sublist menu__link--sublist-caret" aria-expanded="false" href="/docs/2.0/query/query-data/mysql-compatibility">Data Queries</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a id="menu__group" class="menu__link menu__link_level_1 menu__link--sublist menu__link--sublist-caret" aria-expanded="false" href="/docs/2.0/lakehouse/lakehouse-overview">Lakehouse</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item"><div class="menu__list-item-collapsible"><a id="menu__group" class="menu__link menu__link_level_1 menu__link--sublist menu__link--sublist-caret menu__link--active" aria-expanded="true" href="/docs/2.0/admin-manual/cluster-management/upgrade">Managing Doris</a></div><ul style="display:block;overflow:visible;height:auto" class="menu__list menu__list_level_2"><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link_level_2 menu__link--sublist menu__link--sublist-caret" aria-expanded="false" tabindex="0" href="/docs/2.0/admin-manual/cluster-management/upgrade">Managing Cluster</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link_level_2 menu__link--sublist menu__link--sublist-caret" aria-expanded="false" tabindex="0" href="/docs/2.0/admin-manual/data-admin/backup">Managing Data</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link_level_2 menu__link--sublist menu__link--sublist-caret" aria-expanded="false" tabindex="0" href="/docs/2.0/admin-manual/resource-admin/workload-group">Managing Resource</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link_level_2 menu__link--sublist menu__link--sublist-caret" aria-expanded="false" tabindex="0" href="/docs/2.0/admin-manual/query-admin/sql-interception">Managing Query</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link_level_2 menu__link--sublist menu__link--sublist-caret" aria-expanded="false" tabindex="0" href="/docs/2.0/admin-manual/privilege-ldap/user-privilege">Managing User Privilege</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link_level_2 menu__link--sublist menu__link--sublist-caret" aria-expanded="false" tabindex="0" href="/docs/2.0/admin-manual/memory-management/memory-tracker">Managing Memory</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link_level_2 menu__link--sublist menu__link--sublist-caret" aria-expanded="false" tabindex="0" href="/docs/2.0/admin-manual/maint-monitor/monitor-metrics/metrics">Maintenance</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item"><div class="menu__list-item-collapsible"><a class="menu__link menu__link_level_2 menu__link--sublist menu__link--sublist-caret menu__link--active" aria-expanded="true" tabindex="0" href="/docs/2.0/admin-manual/config/config-dir">Managing Configuration</a></div><ul style="display:block;overflow:visible;height:auto" class="menu__list"><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-3 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/2.0/admin-manual/config/config-dir">Config Dir</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-3 menu__list-item"><a class="menu__link menu__link--active" aria-current="page" tabindex="0" href="/docs/2.0/admin-manual/config/fe-config">FE Configuration</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-3 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/2.0/admin-manual/config/be-config">BE Configuration</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-3 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/2.0/admin-manual/config/user-property">User Property</a></li></ul></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/2.0/admin-manual/audit-plugin">Using Audit Log Plugin</a></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link_level_2 menu__link--sublist menu__link--sublist-caret" aria-expanded="false" tabindex="0" href="/docs/2.0/admin-manual/fe/config-action">FE OPEN API</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link_level_2 menu__link--sublist menu__link--sublist-caret" aria-expanded="false" tabindex="0" href="/docs/2.0/admin-manual/be/check-rpc-channel">BE OPEN API</a></div></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/2.0/admin-manual/plugin-development-manual">Developing Plugins</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/2.0/admin-manual/small-file-mgr">Small File Manager</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/2.0/admin-manual/compaction">Compaction</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/2.0/admin-manual/rowsets">Using rowsets</a></li></ul></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a id="menu__group" class="menu__link menu__link_level_1 menu__link--sublist menu__link--sublist-caret" aria-expanded="false" href="/docs/2.0/ecosystem/spark-doris-connector">Ecosystem</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a id="menu__group" class="menu__link menu__link_level_1 menu__link--sublist menu__link--sublist-caret" aria-expanded="false" href="/docs/2.0/sql-manual/sql-functions/array-functions/array">SQL Reference</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a id="menu__group" class="menu__link menu__link_level_1 menu__link--sublist menu__link--sublist-caret" aria-expanded="false" href="/docs/2.0/benchmark/ssb">Benchmark</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a id="menu__group" class="menu__link menu__link_level_1 menu__link--sublist menu__link--sublist-caret" aria-expanded="false" href="/docs/2.0/faq/install-faq">FAQ</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a id="menu__group" class="menu__link menu__link_level_1 menu__link--sublist menu__link--sublist-caret" aria-expanded="false" href="/docs/2.0/releasenotes/release-2.0.12">Release notes</a></div></li></ul></nav></div></div></aside><main class="docMainContainer_gTbr"><div class="container padding-top--md padding-bottom--lg"><div class="row"><div class="col docItemCol_z5aJ"><div class="docItemContainer_c0TR"><article><nav class="theme-doc-breadcrumbs breadcrumbsContainer_Z_bl" aria-label="Breadcrumbs"><ul class="breadcrumbs" itemscope="" itemtype="https://schema.org/BreadcrumbList"><li class="breadcrumbs__item"><a aria-label="Home page" class="breadcrumbs__link" href="/"><svg viewBox="0 0 24 24" class="breadcrumbHomeIcon_YNFT"><path d="M10 19v-5h4v5c0 .55.45 1 1 1h3c.55 0 1-.45 1-1v-7h1.7c.46 0 .68-.57.33-.87L12.67 3.6c-.38-.34-.96-.34-1.34 0l-8.36 7.53c-.34.3-.13.87.33.87H5v7c0 .55.45 1 1 1h3c.55 0 1-.45 1-1z" fill="currentColor"></path></svg></a></li><li class="breadcrumbs__item"><span class="breadcrumbs__link">Managing Doris</span><meta itemprop="position" content="1"></li><li class="breadcrumbs__item"><span class="breadcrumbs__link">Managing Configuration</span><meta itemprop="position" content="2"></li><li itemscope="" itemprop="itemListElement" itemtype="https://schema.org/ListItem" class="breadcrumbs__item breadcrumbs__item--active"><span class="breadcrumbs__link" itemprop="name">FE Configuration</span><meta itemprop="position" content="3"></li></ul></nav><div class="tocCollapsible_ETCw theme-doc-toc-mobile tocMobile_ITEo"><button type="button" class="clean-btn tocCollapsibleButton_TO0P">On this page</button></div><div class="theme-doc-markdown markdown"><header><h1>FE Configuration</h1></header><h1>FE Configuration</h1><p>This document mainly introduces the relevant configuration items of FE.</p><p>The FE configuration file <code>fe.conf</code> is usually stored in the <code>conf/</code> directory of the FE deployment path. In version 0.14, another configuration file <code>fe_custom.conf</code> will be introduced. The configuration file is used to record the configuration items that are dynamically configured and persisted by the user during operation.</p><p>After the FE process is started, it will read the configuration items in <code>fe.conf</code> first, and then read the configuration items in <code>fe_custom.conf</code>. The configuration items in <code>fe_custom.conf</code> will overwrite the same configuration items in <code>fe.conf</code>.</p><p>The location of the <code>fe_custom.conf</code> file can be configured in <code>fe.conf</code> through the <code>custom_config_dir</code> configuration item.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="view-configuration-items">View configuration items<a href="#view-configuration-items" class="hash-link" aria-label="Direct link to View configuration items" title="Direct link to View configuration items">​</a></h2><p>There are two ways to view the configuration items of FE:</p><ol><li><p>FE web page</p><p>Open the FE web page <code>http://fe_host:fe_http_port/variable</code> in the browser. You can see the currently effective FE configuration items in <code>Configure Info</code>.</p></li><li><p>View by command</p><p>After the FE is started, you can view the configuration items of the FE in the MySQL client with the following command,Concrete language law reference <a href="/docs/2.0/sql-manual/sql-reference/Database-Administration-Statements/ADMIN-SHOW-CONFIG">ADMIN-SHOW-CONFIG</a>:</p><p><code>ADMIN SHOW FRONTEND CONFIG;</code></p><p>The meanings of the columns in the results are as follows:</p><ul><li>Key: the name of the configuration item.</li><li>Value: The value of the current configuration item.</li><li>Type: The configuration item value type, such as integer or string.</li><li>IsMutable: whether it can be dynamically configured. If true, the configuration item can be dynamically configured at runtime. If false, it means that the configuration item can only be configured in <code>fe.conf</code> and takes effect after restarting FE.</li><li>MasterOnly: Whether it is a unique configuration item of Master FE node. If it is true, it means that the configuration item is meaningful only at the Master FE node, and is meaningless to other types of FE nodes. If false, it means that the configuration item is meaningful in all types of FE nodes.</li><li>Comment: The description of the configuration item.</li></ul></li></ol><h2 class="anchor anchorWithStickyNavbar_LWe7" id="set-configuration-items">Set configuration items<a href="#set-configuration-items" class="hash-link" aria-label="Direct link to Set configuration items" title="Direct link to Set configuration items">​</a></h2><p>There are two ways to configure FE configuration items:</p><ol><li><p>Static configuration</p><p>Add and set configuration items in the <code>conf/fe.conf</code> file. The configuration items in <code>fe.conf</code> will be read when the FE process starts. Configuration items not in <code>fe.conf</code> will use default values.</p></li><li><p>Dynamic configuration via MySQL protocol</p><p>After the FE starts, you can set the configuration items dynamically through the following commands. This command requires administrator privilege.</p><p><code>ADMIN SET FRONTEND CONFIG (&quot; fe_config_name &quot;=&quot; fe_config_value &quot;);</code></p><p>Not all configuration items support dynamic configuration. You can check whether the dynamic configuration is supported by the <code>IsMutable</code> column in the<code>ADMIN SHOW FRONTEND CONFIG;</code>command result.</p><p>If the configuration item of <code>MasterOnly</code> is modified, the command will be directly forwarded to the Master FE and only the corresponding configuration item in the Master FE will be modified.</p><p><strong>Configuration items modified in this way will become invalid after the FE process restarts.</strong></p><p>For more help on this command, you can view it through the <code>HELP ADMIN SET CONFIG;</code> command.</p></li><li><p>Dynamic configuration via HTTP protocol</p><p>For details, please refer to <a href="/docs/2.0/admin-manual/fe/set-config-action">Set Config Action</a></p><p>This method can also persist the modified configuration items. The configuration items will be persisted in the <code>fe_custom.conf</code> file and will still take effect after FE is restarted.</p></li></ol><h2 class="anchor anchorWithStickyNavbar_LWe7" id="examples">Examples<a href="#examples" class="hash-link" aria-label="Direct link to Examples" title="Direct link to Examples">​</a></h2><ol><li><p>Modify <code>async_pending_load_task_pool_size</code></p><p>Through <code>ADMIN SHOW FRONTEND CONFIG;</code> you can see that this configuration item cannot be dynamically configured (<code>IsMutable</code> is false). You need to add in <code>fe.conf</code>:</p><p><code>async_pending_load_task_pool_size = 20</code></p><p>Then restart the FE process to take effect the configuration.</p></li><li><p>Modify <code>dynamic_partition_enable</code></p><p>Through <code>ADMIN SHOW FRONTEND CONFIG;</code> you can see that the configuration item can be dynamically configured (<code>IsMutable</code> is true). And it is the unique configuration of Master FE. Then first we can connect to any FE and execute the following command to modify the configuration:</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#F8F8F2;--prism-background-color:#282A36"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#F8F8F2"><span class="token plain">ADMIN SET FRONTEND CONFIG (&quot;dynamic_partition_enable&quot; = &quot;true&quot;); `</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg viewBox="0 0 24 24" class="copyButtonIcon_y97N"><path fill="currentColor" d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg viewBox="0 0 24 24" class="copyButtonSuccessIcon_LjdS"><path fill="currentColor" d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><p>Afterwards, you can view the modified value with the following command:</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#F8F8F2;--prism-background-color:#282A36"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#F8F8F2"><span class="token plain">set forward_to_master = true;</span><br></span><span class="token-line" style="color:#F8F8F2"><span class="token plain">ADMIN SHOW FRONTEND CONFIG;</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg viewBox="0 0 24 24" class="copyButtonIcon_y97N"><path fill="currentColor" d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg viewBox="0 0 24 24" class="copyButtonSuccessIcon_LjdS"><path fill="currentColor" d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><p>After modification in the above manner, if the Master FE restarts or a Master election is performed, the configuration will be invalid. You can add the configuration item directly in <code>fe.conf</code> and restart the FE to make the configuration item permanent.</p></li><li><p>Modify <code>max_distribution_pruner_recursion_depth</code></p><p>Through <code>ADMIN SHOW FRONTEND CONFIG;</code> you can see that the configuration item can be dynamically configured (<code>IsMutable</code> is true). It is not unique to Master FE.</p><p>Similarly, we can modify the configuration by dynamically modifying the configuration command. Because this configuration is not unique to the Master FE, user need to connect to different FEs separately to modify the configuration dynamically, so that all FEs use the modified configuration values.</p></li></ol><h2 class="anchor anchorWithStickyNavbar_LWe7" id="configurations">Configurations<a href="#configurations" class="hash-link" aria-label="Direct link to Configurations" title="Direct link to Configurations">​</a></h2><h3 class="anchor anchorWithStickyNavbar_LWe7" id="metadata-and-cluster">Metadata And Cluster<a href="#metadata-and-cluster" class="hash-link" aria-label="Direct link to Metadata And Cluster" title="Direct link to Metadata And Cluster">​</a></h3><h4 class="anchor anchorWithStickyNavbar_LWe7" id="meta_dir"><code>meta_dir</code><a href="#meta_dir" class="hash-link" aria-label="Direct link to meta_dir" title="Direct link to meta_dir">​</a></h4><p>Default：DORIS_HOME_DIR + &quot;/doris-meta&quot;</p><p>Type: string Description: Doris meta data will be saved here.The storage of this dir is highly recommended as to be:</p><ul><li>High write performance (SSD)</li><li>Safe (RAID）</li></ul><h4 class="anchor anchorWithStickyNavbar_LWe7" id="catalog_try_lock_timeout_ms"><code>catalog_try_lock_timeout_ms</code><a href="#catalog_try_lock_timeout_ms" class="hash-link" aria-label="Direct link to catalog_try_lock_timeout_ms" title="Direct link to catalog_try_lock_timeout_ms">​</a></h4><p>Default：5000  （ms）</p><p>IsMutable：true</p><p>The tryLock timeout configuration of catalog lock.  Normally it does not need to change, unless you need to test something.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_bdbje_debug_mode"><code>enable_bdbje_debug_mode</code><a href="#enable_bdbje_debug_mode" class="hash-link" aria-label="Direct link to enable_bdbje_debug_mode" title="Direct link to enable_bdbje_debug_mode">​</a></h4><p>Default：false</p><p>If set to true, FE will be started in BDBJE debug mode</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_bdbje_clock_delta_ms"><code>max_bdbje_clock_delta_ms</code><a href="#max_bdbje_clock_delta_ms" class="hash-link" aria-label="Direct link to max_bdbje_clock_delta_ms" title="Direct link to max_bdbje_clock_delta_ms">​</a></h4><p>Default：5000 （5s）</p><p>Set the maximum acceptable clock skew between non-master FE to Master FE host. This value is checked whenever a non-master FE establishes a connection to master FE via BDBJE. The connection is abandoned if the clock skew is larger than this value.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="metadata_failure_recovery"><code>metadata_failure_recovery</code><a href="#metadata_failure_recovery" class="hash-link" aria-label="Direct link to metadata_failure_recovery" title="Direct link to metadata_failure_recovery">​</a></h4><p>Default：false</p><p>If true, FE will reset bdbje replication group(that is, to remove all electable nodes info)  and is supposed to start as Master.  If all the electable nodes can not start, we can copy the meta data to another node and set this config to true to try to restart the FE..</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="txn_rollback_limit"><code>txn_rollback_limit</code><a href="#txn_rollback_limit" class="hash-link" aria-label="Direct link to txn_rollback_limit" title="Direct link to txn_rollback_limit">​</a></h4><p>Default：100</p><p>the max txn number which bdbje can rollback when trying to rejoin the group</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="grpc_threadmgr_threads_nums"><code>grpc_threadmgr_threads_nums</code><a href="#grpc_threadmgr_threads_nums" class="hash-link" aria-label="Direct link to grpc_threadmgr_threads_nums" title="Direct link to grpc_threadmgr_threads_nums">​</a></h4><p>Default: 4096</p><p>Num of thread to handle grpc events in grpc_threadmgr.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="bdbje_replica_ack_timeout_second"><code>bdbje_replica_ack_timeout_second</code><a href="#bdbje_replica_ack_timeout_second" class="hash-link" aria-label="Direct link to bdbje_replica_ack_timeout_second" title="Direct link to bdbje_replica_ack_timeout_second">​</a></h4><p>Default：10  (s)</p><p>The replica ack timeout when writing to bdbje , When writing some relatively large logs, the ack time may time out, resulting in log writing failure.  At this time, you can increase this value appropriately.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="bdbje_lock_timeout_second"><code>bdbje_lock_timeout_second</code><a href="#bdbje_lock_timeout_second" class="hash-link" aria-label="Direct link to bdbje_lock_timeout_second" title="Direct link to bdbje_lock_timeout_second">​</a></h4><p>Default：5</p><p>The lock timeout of bdbje operation, If there are many LockTimeoutException in FE WARN log, you can try to increase this value</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="bdbje_heartbeat_timeout_second"><code>bdbje_heartbeat_timeout_second</code><a href="#bdbje_heartbeat_timeout_second" class="hash-link" aria-label="Direct link to bdbje_heartbeat_timeout_second" title="Direct link to bdbje_heartbeat_timeout_second">​</a></h4><p>Default：30</p><p>The heartbeat timeout of bdbje between master and follower. the default is 30 seconds, which is same as default value in bdbje. If the network is experiencing transient problems, of some unexpected long java GC annoying you,  you can try to increase this value to decrease the chances of false timeouts</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="replica_ack_policy"><code>replica_ack_policy</code><a href="#replica_ack_policy" class="hash-link" aria-label="Direct link to replica_ack_policy" title="Direct link to replica_ack_policy">​</a></h4><p>Default：SIMPLE_MAJORITY</p><p>OPTION: ALL, NONE, SIMPLE_MAJORITY</p><p>Replica ack policy of bdbje. more info, see: <a href="http://docs.oracle.com/cd/E17277_02/html/java/com/sleepycat/je/Durability.ReplicaAckPolicy.html" target="_blank" rel="noopener noreferrer">http://docs.oracle.com/cd/E17277_02/html/java/com/sleepycat/je/Durability.ReplicaAckPolicy.html</a></p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="replica_sync_policy"><code>replica_sync_policy</code><a href="#replica_sync_policy" class="hash-link" aria-label="Direct link to replica_sync_policy" title="Direct link to replica_sync_policy">​</a></h4><p>Default：SYNC</p><p>选项：SYNC, NO_SYNC, WRITE_NO_SYNC</p><p>Follower FE sync policy of bdbje.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="master_sync_policy"><code>master_sync_policy</code><a href="#master_sync_policy" class="hash-link" aria-label="Direct link to master_sync_policy" title="Direct link to master_sync_policy">​</a></h4><p>Default：SYNC</p><p>选项：SYNC, NO_SYNC, WRITE_NO_SYNC</p><p>Master FE sync policy of bdbje. If you only deploy one Follower FE, set this to &#x27;SYNC&#x27;. If you deploy more than 3 Follower FE,  you can set this and the following &#x27;replica_sync_policy&#x27; to WRITE_NO_SYNC.  more info, see: <a href="http://docs.oracle.com/cd/E17277_02/html/java/com/sleepycat/je/Durability.SyncPolicy.html" target="_blank" rel="noopener noreferrer">http://docs.oracle.com/cd/E17277_02/html/java/com/sleepycat/je/Durability.SyncPolicy.html</a></p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="bdbje_reserved_disk_bytes"><code>bdbje_reserved_disk_bytes</code><a href="#bdbje_reserved_disk_bytes" class="hash-link" aria-label="Direct link to bdbje_reserved_disk_bytes" title="Direct link to bdbje_reserved_disk_bytes">​</a></h4><p>The desired upper limit on the number of bytes of reserved space to retain in a replicated JE Environment.</p><p>Default: 1073741824</p><p>Is it possible to dynamically configure: false</p><p>Is it a configuration item unique to the Master FE node: false</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="ignore_meta_check"><code>ignore_meta_check</code><a href="#ignore_meta_check" class="hash-link" aria-label="Direct link to ignore_meta_check" title="Direct link to ignore_meta_check">​</a></h4><p>Default：false</p><p>IsMutable：true</p><p>If true, non-master FE will ignore the meta data delay gap between Master FE and its self,  even if the metadata delay gap exceeds <em>meta_delay_toleration_second</em>.  Non-master FE will still offer read service.
This is helpful when you try to stop the Master FE for a relatively long time for some reason,  but still wish the non-master FE can offer read service.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="meta_delay_toleration_second"><code>meta_delay_toleration_second</code><a href="#meta_delay_toleration_second" class="hash-link" aria-label="Direct link to meta_delay_toleration_second" title="Direct link to meta_delay_toleration_second">​</a></h4><p>Default: 300 (5 min)</p><p>Non-master FE will stop offering service  if meta data delay gap exceeds <em>meta_delay_toleration_second</em></p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="edit_log_port"><code>edit_log_port</code><a href="#edit_log_port" class="hash-link" aria-label="Direct link to edit_log_port" title="Direct link to edit_log_port">​</a></h4><p>Default：9010</p><p>bdbje port</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="edit_log_type"><code>edit_log_type</code><a href="#edit_log_type" class="hash-link" aria-label="Direct link to edit_log_type" title="Direct link to edit_log_type">​</a></h4><p>Default：BDB</p><p>Edit log type.
BDB: write log to bdbje
LOCAL: deprecated..</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="edit_log_roll_num"><code>edit_log_roll_num</code><a href="#edit_log_roll_num" class="hash-link" aria-label="Direct link to edit_log_roll_num" title="Direct link to edit_log_roll_num">​</a></h4><p>Default：50000</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Master FE will save image every <em>edit_log_roll_num</em> meta journals.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="force_do_metadata_checkpoint"><code>force_do_metadata_checkpoint</code><a href="#force_do_metadata_checkpoint" class="hash-link" aria-label="Direct link to force_do_metadata_checkpoint" title="Direct link to force_do_metadata_checkpoint">​</a></h4><p>Default：false</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>If set to true, the checkpoint thread will make the checkpoint regardless of the jvm memory used percent</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="metadata_checkpoint_memory_threshold"><code>metadata_checkpoint_memory_threshold</code><a href="#metadata_checkpoint_memory_threshold" class="hash-link" aria-label="Direct link to metadata_checkpoint_memory_threshold" title="Direct link to metadata_checkpoint_memory_threshold">​</a></h4><p>Default：60  （60%）</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>If the jvm memory used percent(heap or old mem pool) exceed this threshold, checkpoint thread will  not work to avoid OOM.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_same_name_catalog_trash_num"><code>max_same_name_catalog_trash_num</code><a href="#max_same_name_catalog_trash_num" class="hash-link" aria-label="Direct link to max_same_name_catalog_trash_num" title="Direct link to max_same_name_catalog_trash_num">​</a></h4><p>It is used to set the maximum number of meta information with the same name in the catalog recycle bin. When the maximum value is exceeded, the earliest deleted meta trash will be completely deleted and cannot be recovered. 0 means not to keep objects of the same name. &lt; 0 means no limit.</p><p>Note: The judgment of metadata with the same name will be limited to a certain range. For example, the judgment of the database with the same name will be limited to the same cluster, the judgment of the table with the same name will be limited to the same database (with the same database id), the judgment of the partition with the same name will be limited to the same database (with the same database id) and the same table (with the same table) same table id).</p><p>Default: 3</p><p>Is it possible to dynamically configure: true</p><p>Is it a configuration item unique to the Master FE node: true</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="cluster_id"><code>cluster_id</code><a href="#cluster_id" class="hash-link" aria-label="Direct link to cluster_id" title="Direct link to cluster_id">​</a></h4><p>Default：-1</p><p>node(FE or BE) will be considered belonging to the same Palo cluster if they have same cluster id.  Cluster id is usually a random integer generated when master FE start at first time. You can also specify one.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="heartbeat_mgr_blocking_queue_size"><code>heartbeat_mgr_blocking_queue_size</code><a href="#heartbeat_mgr_blocking_queue_size" class="hash-link" aria-label="Direct link to heartbeat_mgr_blocking_queue_size" title="Direct link to heartbeat_mgr_blocking_queue_size">​</a></h4><p>Default：1024</p><p>MasterOnly：true</p><p>blocking queue size to store heartbeat task in heartbeat_mgr.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="heartbeat_mgr_threads_num"><code>heartbeat_mgr_threads_num</code><a href="#heartbeat_mgr_threads_num" class="hash-link" aria-label="Direct link to heartbeat_mgr_threads_num" title="Direct link to heartbeat_mgr_threads_num">​</a></h4><p>Default：8</p><p>MasterOnly：true</p><p>num of thread to handle heartbeat events in heartbeat_mgr.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="disable_cluster_feature"><code>disable_cluster_feature</code><a href="#disable_cluster_feature" class="hash-link" aria-label="Direct link to disable_cluster_feature" title="Direct link to disable_cluster_feature">​</a></h4><p>Default：true</p><p>IsMutable：true</p><p>The multi cluster feature will be deprecated in version 0.12 , set this config to true will disable all operations related to cluster feature, include:</p><ol><li>create/drop cluster</li><li>add free backend/add backend to cluster/decommission cluster balance</li><li>change the backends num of cluster</li><li>link/migration db</li></ol><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_deploy_manager"><code>enable_deploy_manager</code><a href="#enable_deploy_manager" class="hash-link" aria-label="Direct link to enable_deploy_manager" title="Direct link to enable_deploy_manager">​</a></h4><p>Default：disable</p><p>Set to true if you deploy Doris using thirdparty deploy manager</p><p>Valid options are:</p><ul><li>disable:    no deploy manager</li><li>k8s:        Kubernetes</li><li>ambari:     Ambari</li><li>local:      Local File (for test or Boxer2 BCC version)</li></ul><h4 class="anchor anchorWithStickyNavbar_LWe7" id="with_k8s_certs"><code>with_k8s_certs</code><a href="#with_k8s_certs" class="hash-link" aria-label="Direct link to with_k8s_certs" title="Direct link to with_k8s_certs">​</a></h4><p>Default：false</p><p>If use k8s deploy manager locally, set this to true and prepare the certs files</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_fqdn_mode"><code>enable_fqdn_mode</code><a href="#enable_fqdn_mode" class="hash-link" aria-label="Direct link to enable_fqdn_mode" title="Direct link to enable_fqdn_mode">​</a></h4><p>This configuration is mainly used in the k8s cluster environment. When enable_fqdn_mode is true, the name of the pod where the be is located will remain unchanged after reconstruction, while the ip can be changed.</p><p>Default: false</p><p>Is it possible to dynamically configure: false</p><p>Is it a configuration item unique to the Master FE node: true</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_token_check"><code>enable_token_check</code><a href="#enable_token_check" class="hash-link" aria-label="Direct link to enable_token_check" title="Direct link to enable_token_check">​</a></h4><p>Default：true</p><p>For forward compatibility, will be removed later. check token when download image file.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_multi_tags"><code>enable_multi_tags</code><a href="#enable_multi_tags" class="hash-link" aria-label="Direct link to enable_multi_tags" title="Direct link to enable_multi_tags">​</a></h4><p>Default: false</p><p>Is it possible to dynamically configure: false</p><p>Is it a configuration item unique to the Master FE node: true</p><p>Whether to enable the multi-tags function of a single BE</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="initial_root_password"><code>initial_root_password</code><a href="#initial_root_password" class="hash-link" aria-label="Direct link to initial_root_password" title="Direct link to initial_root_password">​</a></h4><p>Set root user initial 2-staged SHA-1 encrypted password, default as &#x27;&#x27;, means no root password. Subsequent <code>set password</code> operations for root user will overwrite the initial root password.</p><p>Example: If you want to configure a plaintext password <code>root@123</code>. You can execute Doris SQL <code>select password(&#x27;root@123&#x27;)</code> to generate encrypted password <code>*A00C34073A26B40AB4307650BFB9309D6BFA6999</code>.</p><p>Default: empty string</p><p>Is it possible to dynamically configure: false</p><p>Is it a configuration item unique to the Master FE node: true</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="service">Service<a href="#service" class="hash-link" aria-label="Direct link to Service" title="Direct link to Service">​</a></h3><h4 class="anchor anchorWithStickyNavbar_LWe7" id="query_port"><code>query_port</code><a href="#query_port" class="hash-link" aria-label="Direct link to query_port" title="Direct link to query_port">​</a></h4><p>Default：9030</p><p>FE MySQL server port</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="arrow_flight_sql_port"><code>arrow_flight_sql_port</code><a href="#arrow_flight_sql_port" class="hash-link" aria-label="Direct link to arrow_flight_sql_port" title="Direct link to arrow_flight_sql_port">​</a></h4><p>Default：-1</p><p>Arrow Flight SQL server port</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="frontend_address"><code>frontend_address</code><a href="#frontend_address" class="hash-link" aria-label="Direct link to frontend_address" title="Direct link to frontend_address">​</a></h4><p>Status: Deprecated, not recommended use. This parameter may be deleted later</p><p>Type: string</p><p>Description: Explicitly set the IP address of FE instead of using <em>InetAddress.getByName</em> to get the IP address. Usually in <em>InetAddress.getByName</em> When the expected results cannot be obtained. Only IP address is supported, not hostname.</p><p>Default value: 0.0.0.0</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="priority_networks"><code>priority_networks</code><a href="#priority_networks" class="hash-link" aria-label="Direct link to priority_networks" title="Direct link to priority_networks">​</a></h4><p>Default：none</p><p>Declare a selection strategy for those servers have many ips.  Note that there should at most one ip match this list.  this is a list in semicolon-delimited format, in CIDR notation, e.g. 10.10.10.0/24 , If no ip match this rule, will choose one randomly.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="http_port"><code>http_port</code><a href="#http_port" class="hash-link" aria-label="Direct link to http_port" title="Direct link to http_port">​</a></h4><p>Default：8030</p><p>HTTP bind port. All FE http ports must be same currently.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="https_port"><code>https_port</code><a href="#https_port" class="hash-link" aria-label="Direct link to https_port" title="Direct link to https_port">​</a></h4><p>Default：8050</p><p>HTTPS bind port. All FE https ports must be same currently.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_https"><code>enable_https</code><a href="#enable_https" class="hash-link" aria-label="Direct link to enable_https" title="Direct link to enable_https">​</a></h4><p>Default：false</p><p>Https enable flag. If the value is false, http is supported. Otherwise, both http and https are supported, and http requests are automatically redirected to https.
If enable_https is true, you need to configure ssl certificate information in fe.conf.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_ssl"><code>enable_ssl</code><a href="#enable_ssl" class="hash-link" aria-label="Direct link to enable_ssl" title="Direct link to enable_ssl">​</a></h4><p>Default：true</p><p>If set to ture, doris will establish an encrypted channel based on the SSL protocol with mysql.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="qe_max_connection"><code>qe_max_connection</code><a href="#qe_max_connection" class="hash-link" aria-label="Direct link to qe_max_connection" title="Direct link to qe_max_connection">​</a></h4><p>Default：1024</p><p>Maximal number of connections per FE.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="check_java_version"><code>check_java_version</code><a href="#check_java_version" class="hash-link" aria-label="Direct link to check_java_version" title="Direct link to check_java_version">​</a></h4><p>Default：true</p><p>Doris will check whether the compiled and run Java versions are compatible, if not, it will throw a Java version mismatch exception message and terminate the startup</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="rpc_port"><code>rpc_port</code><a href="#rpc_port" class="hash-link" aria-label="Direct link to rpc_port" title="Direct link to rpc_port">​</a></h4><p>Default：9020</p><p>FE Thrift Server port</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="thrift_server_type"><code>thrift_server_type</code><a href="#thrift_server_type" class="hash-link" aria-label="Direct link to thrift_server_type" title="Direct link to thrift_server_type">​</a></h4><p>This configuration represents the service model used by The Thrift Service of FE, is of type String and is case-insensitive.</p><p>If this parameter is &#x27;SIMPLE&#x27;, then the &#x27;TSimpleServer&#x27; model is used, which is generally not suitable for production and is limited to test use.</p><p>If the parameter is &#x27;THREADED&#x27;, then the &#x27;TThreadedSelectorServer&#x27; model is used, which is a non-blocking I/O model, namely the master-slave Reactor model, which can timely respond to a large number of concurrent connection requests and performs well in most scenarios.</p><p>If this parameter is <code>THREAD_POOL</code>, then the <code>TThreadPoolServer</code> model is used, the model for blocking I/O model, use the thread pool to handle user connections, the number of simultaneous connections are limited by the number of thread pool, if we can estimate the number of concurrent requests in advance, and tolerant enough thread resources cost, this model will have a better performance, the service model is used by default</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="thrift_server_max_worker_threads"><code>thrift_server_max_worker_threads</code><a href="#thrift_server_max_worker_threads" class="hash-link" aria-label="Direct link to thrift_server_max_worker_threads" title="Direct link to thrift_server_max_worker_threads">​</a></h4><p>Default：4096</p><p>The thrift server max worker threads</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="thrift_backlog_num"><code>thrift_backlog_num</code><a href="#thrift_backlog_num" class="hash-link" aria-label="Direct link to thrift_backlog_num" title="Direct link to thrift_backlog_num">​</a></h4><p>Default：1024</p><p>The backlog_num for thrift server , When you enlarge this backlog_num, you should ensure it&#x27;s value larger than the linux /proc/sys/net/core/somaxconn config</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="thrift_client_timeout_ms"><code>thrift_client_timeout_ms</code><a href="#thrift_client_timeout_ms" class="hash-link" aria-label="Direct link to thrift_client_timeout_ms" title="Direct link to thrift_client_timeout_ms">​</a></h4><p>Default：0</p><p>The connection timeout and socket timeout config for thrift server.</p><p>The value for thrift_client_timeout_ms is set to be zero to prevent read timeout.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="thrift_max_message_size"><code>thrift_max_message_size</code><a href="#thrift_max_message_size" class="hash-link" aria-label="Direct link to thrift_max_message_size" title="Direct link to thrift_max_message_size">​</a></h4><span class="version-mark paragraph"><span class="v-mark"><span class="version-tags"><span class="version-tag"><span class="version-tag-t">Since</span><span class="version-tag-n since">Version <!-- -->2.0.12</span></span></span></span></span><p>Default: 100MB</p><p>The maximum size of a (received) message of the thrift server, in bytes. If the size of the message sent by the client exceeds this limit, the Thrift server will reject the request and close the connection. As a result, the client will encounter the error: &quot;connection has been closed by peer.&quot; In this case, you can try increasing this parameter.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="use_compact_thrift_rpc"><code>use_compact_thrift_rpc</code><a href="#use_compact_thrift_rpc" class="hash-link" aria-label="Direct link to use_compact_thrift_rpc" title="Direct link to use_compact_thrift_rpc">​</a></h4><p>Default: true</p><p>Whether to use compressed format to send query plan structure. After it is turned on, the size of the query plan structure can be reduced by about 50%, thereby avoiding some &quot;send fragment timeout&quot; errors.
However, in some high-concurrency small query scenarios, the concurrency may be reduced by about 10%.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="grpc_max_message_size_bytes"><code>grpc_max_message_size_bytes</code><a href="#grpc_max_message_size_bytes" class="hash-link" aria-label="Direct link to grpc_max_message_size_bytes" title="Direct link to grpc_max_message_size_bytes">​</a></h4><p>Default：1G</p><p>Used to set the initial flow window size of the GRPC client channel, and also used to max message size.  When the result set is large, you may need to increase this value.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_mysql_service_task_threads_num"><code>max_mysql_service_task_threads_num</code><a href="#max_mysql_service_task_threads_num" class="hash-link" aria-label="Direct link to max_mysql_service_task_threads_num" title="Direct link to max_mysql_service_task_threads_num">​</a></h4><p>Default：4096</p><p>The number of threads responsible for Task events.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="mysql_service_io_threads_num"><code>mysql_service_io_threads_num</code><a href="#mysql_service_io_threads_num" class="hash-link" aria-label="Direct link to mysql_service_io_threads_num" title="Direct link to mysql_service_io_threads_num">​</a></h4><p>Default：4</p><p>When FE starts the MySQL server based on NIO model, the number of threads responsible for IO events.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="mysql_nio_backlog_num"><code>mysql_nio_backlog_num</code><a href="#mysql_nio_backlog_num" class="hash-link" aria-label="Direct link to mysql_nio_backlog_num" title="Direct link to mysql_nio_backlog_num">​</a></h4><p>Default：1024</p><p>The backlog_num for mysql nio server, When you enlarge this backlog_num, you should enlarge the value in the linux /proc/sys/net/core/somaxconn file at the same time</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="broker_timeout_ms"><code>broker_timeout_ms</code><a href="#broker_timeout_ms" class="hash-link" aria-label="Direct link to broker_timeout_ms" title="Direct link to broker_timeout_ms">​</a></h4><p>Default：10000   （10s）</p><p>Default broker RPC timeout</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="backend_rpc_timeout_ms"><code>backend_rpc_timeout_ms</code><a href="#backend_rpc_timeout_ms" class="hash-link" aria-label="Direct link to backend_rpc_timeout_ms" title="Direct link to backend_rpc_timeout_ms">​</a></h4><p>Timeout millisecond for Fe sending rpc request to BE</p><p>Default: 60000</p><p>Is it possible to dynamically configure: false</p><p>Is it a configuration item unique to the Master FE node: true</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="drop_backend_after_decommission"><code>drop_backend_after_decommission</code><a href="#drop_backend_after_decommission" class="hash-link" aria-label="Direct link to drop_backend_after_decommission" title="Direct link to drop_backend_after_decommission">​</a></h4><p>Default：false</p><p>IsMutable：true</p><p>MasterOnly：true</p><ol><li><p>This configuration is used to control whether the system drops the BE after successfully decommissioning the BE. If true, the BE node will be deleted after the BE is successfully offline. If false, after the BE successfully goes offline, the BE will remain in the DECOMMISSION state, but will not be dropped.</p><p>This configuration can play a role in certain scenarios. Assume that the initial state of a Doris cluster is one disk per BE node. After running for a period of time, the system has been vertically expanded, that is, each BE node adds 2 new disks. Because Doris currently does not support data balancing among the disks within the BE, the data volume of the initial disk may always be much higher than the data volume of the newly added disk. At this time, we can perform manual inter-disk balancing by the following operations:</p><ol><li>Set the configuration item to false.</li><li>Perform a decommission operation on a certain BE node. This operation will migrate all data on the BE to other nodes.</li><li>After the decommission operation is completed, the BE will not be dropped. At this time, cancel the decommission status of the BE. Then the data will start to balance from other BE nodes back to this node. At this time, the data will be evenly distributed to all disks of the BE.</li><li>Perform steps 2 and 3 for all BE nodes in sequence, and finally achieve the purpose of disk balancing for all nodes</li></ol></li></ol><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_backend_down_time_second"><code>max_backend_down_time_second</code><a href="#max_backend_down_time_second" class="hash-link" aria-label="Direct link to max_backend_down_time_second" title="Direct link to max_backend_down_time_second">​</a></h4><p>Default: 3600  (1 hour)</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>If a backend is down for <em>max_backend_down_time_second</em>, a BACKEND_DOWN event will be triggered.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="disable_backend_black_list"><code>disable_backend_black_list</code><a href="#disable_backend_black_list" class="hash-link" aria-label="Direct link to disable_backend_black_list" title="Direct link to disable_backend_black_list">​</a></h4><p>Used to disable the BE blacklist function. After this function is disabled, if the query request to the BE fails, the BE will not be added to the blacklist.
This parameter is suitable for regression testing environments to reduce occasional bugs that cause a large number of regression tests to fail.</p><p>Default: false</p><p>Is it possible to configure dynamically: true</p><p>Is it a configuration item unique to the Master FE node: false</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_backend_heartbeat_failure_tolerance_count"><code>max_backend_heartbeat_failure_tolerance_count</code><a href="#max_backend_heartbeat_failure_tolerance_count" class="hash-link" aria-label="Direct link to max_backend_heartbeat_failure_tolerance_count" title="Direct link to max_backend_heartbeat_failure_tolerance_count">​</a></h4><p>The maximum tolerable number of BE node heartbeat failures. If the number of consecutive heartbeat failures exceeds this value, the BE state will be set to dead.
This parameter is suitable for regression test environments to reduce occasional heartbeat failures that cause a large number of regression test failures.</p><p>Default: 1</p><p>Is it possible to configure dynamically: true</p><p>Whether it is a configuration item unique to the Master FE node: true</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_access_file_without_broker"><code>enable_access_file_without_broker</code><a href="#enable_access_file_without_broker" class="hash-link" aria-label="Direct link to enable_access_file_without_broker" title="Direct link to enable_access_file_without_broker">​</a></h4><p>Default：false</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>This config is used to try skip broker when access bos or other cloud storage via broker</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="agent_task_resend_wait_time_ms"><code>agent_task_resend_wait_time_ms</code><a href="#agent_task_resend_wait_time_ms" class="hash-link" aria-label="Direct link to agent_task_resend_wait_time_ms" title="Direct link to agent_task_resend_wait_time_ms">​</a></h4><p>Default：5000</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>This configuration will decide whether to resend agent task when create_time for agent_task is set, only when current_time - create_time &gt; agent_task_resend_wait_time_ms can ReportHandler do resend agent task.</p><p>This configuration is currently mainly used to solve the problem of repeated sending of <code>PUBLISH_VERSION</code> agent tasks. The current default value of this configuration is 5000, which is an experimental value.</p><p>Because there is a certain time delay between submitting agent tasks to AgentTaskQueue and submitting to be, Increasing the value of this configuration can effectively solve the problem of repeated sending of agent tasks,</p><p>But at the same time, it will cause the submission of failed or failed execution of the agent task to be executed again for an extended period of time</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_agent_task_threads_num"><code>max_agent_task_threads_num</code><a href="#max_agent_task_threads_num" class="hash-link" aria-label="Direct link to max_agent_task_threads_num" title="Direct link to max_agent_task_threads_num">​</a></h4><p>Default：4096</p><p>MasterOnly：true</p><p>max num of thread to handle agent task in agent task thread-pool.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="remote_fragment_exec_timeout_ms"><code>remote_fragment_exec_timeout_ms</code><a href="#remote_fragment_exec_timeout_ms" class="hash-link" aria-label="Direct link to remote_fragment_exec_timeout_ms" title="Direct link to remote_fragment_exec_timeout_ms">​</a></h4><p>Default：30000  （ms）</p><p>IsMutable：true</p><p>The timeout of executing async remote fragment.  In normal case, the async remote fragment will be executed in a short time. If system are under high load condition, try to set this timeout longer.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="auth_token"><code>auth_token</code><a href="#auth_token" class="hash-link" aria-label="Direct link to auth_token" title="Direct link to auth_token">​</a></h4><p>Default：empty</p><p>Cluster token used for internal authentication.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_http_server_v2"><code>enable_http_server_v2</code><a href="#enable_http_server_v2" class="hash-link" aria-label="Direct link to enable_http_server_v2" title="Direct link to enable_http_server_v2">​</a></h4><p>Default: The default is true after the official 0.14.0 version is released, and the default is false before</p><p>HTTP Server V2 is implemented by SpringBoot. It uses an architecture that separates the front and back ends. Only when httpv2 is enabled can users use the new front-end UI interface.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="http_api_extra_base_path"><code>http_api_extra_base_path</code><a href="#http_api_extra_base_path" class="hash-link" aria-label="Direct link to http_api_extra_base_path" title="Direct link to http_api_extra_base_path">​</a></h4><p>In some deployment environments, user need to specify an additional base path as the unified prefix of the HTTP API. This parameter is used by the user to specify additional prefixes.
After setting, user can get the parameter value through the <code>GET /api/basepath</code> interface. And the new UI will also try to get this base path first to assemble the URL. Only valid when <code>enable_http_server_v2</code> is true.</p><p>The default is empty, that is, not set</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="jetty_server_acceptors"><code>jetty_server_acceptors</code><a href="#jetty_server_acceptors" class="hash-link" aria-label="Direct link to jetty_server_acceptors" title="Direct link to jetty_server_acceptors">​</a></h4><p>Default：2</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="jetty_server_selectors"><code>jetty_server_selectors</code><a href="#jetty_server_selectors" class="hash-link" aria-label="Direct link to jetty_server_selectors" title="Direct link to jetty_server_selectors">​</a></h4><p>Default：4</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="jetty_server_workers"><code>jetty_server_workers</code><a href="#jetty_server_workers" class="hash-link" aria-label="Direct link to jetty_server_workers" title="Direct link to jetty_server_workers">​</a></h4><p>Default：0</p><p>With the above three parameters, Jetty&#x27;s thread architecture model is very simple, divided into acceptors, selectors and workers three thread pools. Acceptors are responsible for accepting new connections, and then hand them over to selectors to process the unpacking of the HTTP message protocol, and finally workers process the request. The first two thread pools adopt a non-blocking model, and one thread can handle the read and write of many sockets, so the number of thread pools is small.</p><p>For most projects, only 1-2 acceptors threads are required, and 2 to 4 selectors threads are sufficient. Workers are obstructive business logic, often have more database operations, and require a large number of threads. The specific number depends on the proportion of QPS and IO events of the application. The higher the QPS, the more threads are required, the higher the proportion of IO, the more threads waiting, and the more total threads required.</p><p>Worker thread pool is not set by default, set according to your needs</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="jetty_server_max_http_post_size"><code>jetty_server_max_http_post_size</code><a href="#jetty_server_max_http_post_size" class="hash-link" aria-label="Direct link to jetty_server_max_http_post_size" title="Direct link to jetty_server_max_http_post_size">​</a></h4><p>Default：<code>100 * 1024 * 1024</code>  （100MB）</p><p>This is the maximum number of bytes of the file uploaded by the put or post method, the default value: 100MB</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="jetty_server_max_http_header_size"><code>jetty_server_max_http_header_size</code><a href="#jetty_server_max_http_header_size" class="hash-link" aria-label="Direct link to jetty_server_max_http_header_size" title="Direct link to jetty_server_max_http_header_size">​</a></h4><p>Default：1048576  （1M）</p><p>http header size configuration parameter, the default value is 1M.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="http_sql_submitter_max_worker_threads"><code>http_sql_submitter_max_worker_threads</code><a href="#http_sql_submitter_max_worker_threads" class="hash-link" aria-label="Direct link to http_sql_submitter_max_worker_threads" title="Direct link to http_sql_submitter_max_worker_threads">​</a></h4><p>Default：2</p><p>The max number work threads of http sql submitter</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="http_load_submitter_max_worker_threads"><code>http_load_submitter_max_worker_threads</code><a href="#http_load_submitter_max_worker_threads" class="hash-link" aria-label="Direct link to http_load_submitter_max_worker_threads" title="Direct link to http_load_submitter_max_worker_threads">​</a></h4><p>Default：2</p><p>The max number work threads of http upload submitter</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="query-engine">Query Engine<a href="#query-engine" class="hash-link" aria-label="Direct link to Query Engine" title="Direct link to Query Engine">​</a></h3><h4 class="anchor anchorWithStickyNavbar_LWe7" id="default_max_query_instances"><code>default_max_query_instances</code><a href="#default_max_query_instances" class="hash-link" aria-label="Direct link to default_max_query_instances" title="Direct link to default_max_query_instances">​</a></h4><p>The default value when user property max_query_instances is equal or less than 0. This config is used to limit the max number of instances for a user. This parameter is less than or equal to 0 means unlimited.</p><p>The default value is -1</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_query_retry_time"><code>max_query_retry_time</code><a href="#max_query_retry_time" class="hash-link" aria-label="Direct link to max_query_retry_time" title="Direct link to max_query_retry_time">​</a></h4><p>Default：3</p><p>IsMutable：true</p><p>The number of query retries.  A query may retry if we encounter RPC exception and no result has been sent to user.  You may reduce this number to avoid Avalanche disaster</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_dynamic_partition_num"><code>max_dynamic_partition_num</code><a href="#max_dynamic_partition_num" class="hash-link" aria-label="Direct link to max_dynamic_partition_num" title="Direct link to max_dynamic_partition_num">​</a></h4><p>Default：500</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Used to limit the maximum number of partitions that can be created when creating a dynamic partition table,  to avoid creating too many partitions at one time. The number is determined by &quot;start&quot; and &quot;end&quot; in the dynamic partition parameters.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="dynamic_partition_enable"><code>dynamic_partition_enable</code><a href="#dynamic_partition_enable" class="hash-link" aria-label="Direct link to dynamic_partition_enable" title="Direct link to dynamic_partition_enable">​</a></h4><p>Default：true</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Whether to enable dynamic partition scheduler, enabled by default</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="dynamic_partition_check_interval_seconds"><code>dynamic_partition_check_interval_seconds</code><a href="#dynamic_partition_check_interval_seconds" class="hash-link" aria-label="Direct link to dynamic_partition_check_interval_seconds" title="Direct link to dynamic_partition_check_interval_seconds">​</a></h4><p>Default：600 （s）</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Decide how often to check dynamic partition</p><span class="version-mark paragraph"><span class="v-mark"><span class="version-tags"><span class="version-tag"><span class="version-tag-t">Since</span><span class="version-tag-n since">Version <!-- -->1.2.0</span></span></span></span><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_multi_partition_num"><code>max_multi_partition_num</code><a href="#max_multi_partition_num" class="hash-link" aria-label="Direct link to max_multi_partition_num" title="Direct link to max_multi_partition_num">​</a></h4><p>Default：4096</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Use this parameter to set the partition name prefix for multi partition,Only multi partition takes effect, not dynamic partitions. The default prefix is &quot;p_&quot;.</p></span><h4 class="anchor anchorWithStickyNavbar_LWe7" id="multi_partition_name_prefix"><code>multi_partition_name_prefix</code><a href="#multi_partition_name_prefix" class="hash-link" aria-label="Direct link to multi_partition_name_prefix" title="Direct link to multi_partition_name_prefix">​</a></h4><p>Default：p_</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Use this parameter to set the partition name prefix for multi partition, Only multi partition takes effect, not dynamic partitions.The default prefix is &quot;p_&quot;.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="partition_in_memory_update_interval_secs"><code>partition_in_memory_update_interval_secs</code><a href="#partition_in_memory_update_interval_secs" class="hash-link" aria-label="Direct link to partition_in_memory_update_interval_secs" title="Direct link to partition_in_memory_update_interval_secs">​</a></h4><p>Default：300 (s)</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Time to update global partition information in memory</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_concurrent_update"><code>enable_concurrent_update</code><a href="#enable_concurrent_update" class="hash-link" aria-label="Direct link to enable_concurrent_update" title="Direct link to enable_concurrent_update">​</a></h4><p>Default：false</p><p>IsMutable：false</p><p>MasterOnly：true</p><p>Whether to enable concurrent update</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="lower_case_table_names"><code>lower_case_table_names</code><a href="#lower_case_table_names" class="hash-link" aria-label="Direct link to lower_case_table_names" title="Direct link to lower_case_table_names">​</a></h4><p>Default：0</p><p>IsMutable：false</p><p>MasterOnly：true</p><p>This configuration can only be configured during cluster initialization and cannot be modified during cluster
restart and upgrade after initialization is complete.</p><p>0: table names are stored as specified and comparisons are case sensitive.
1: table names are stored in lowercase and comparisons are not case sensitive.
2: table names are stored as given but compared in lowercase.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="table_name_length_limit"><code>table_name_length_limit</code><a href="#table_name_length_limit" class="hash-link" aria-label="Direct link to table_name_length_limit" title="Direct link to table_name_length_limit">​</a></h4><p>Default：64</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Used to control the maximum table name length</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="cache_enable_sql_mode"><code>cache_enable_sql_mode</code><a href="#cache_enable_sql_mode" class="hash-link" aria-label="Direct link to cache_enable_sql_mode" title="Direct link to cache_enable_sql_mode">​</a></h4><p>Default：true</p><p>IsMutable：true</p><p>MasterOnly：false</p><p>If this switch is turned on, the SQL query result set will be cached. If the interval between the last visit version time in all partitions of all tables in the query is greater than cache_last_version_interval_second, and the result set is less than cache_result_max_row_count, and the data size is less than cache_result_max_data_size, the result set will be cached, and the next same SQL will hit the cache</p><p>If set to true, fe will enable sql result caching. This option is suitable for offline data update scenarios</p><table><thead><tr><th></th><th>case1</th><th>case2</th><th>case3</th><th>case4</th></tr></thead><tbody><tr><td>enable_sql_cache</td><td>false</td><td>true</td><td>true</td><td>false</td></tr><tr><td>enable_partition_cache</td><td>false</td><td>false</td><td>true</td><td>true</td></tr></tbody></table><h4 class="anchor anchorWithStickyNavbar_LWe7" id="cache_enable_partition_mode"><code>cache_enable_partition_mode</code><a href="#cache_enable_partition_mode" class="hash-link" aria-label="Direct link to cache_enable_partition_mode" title="Direct link to cache_enable_partition_mode">​</a></h4><p>Default：true</p><p>IsMutable：true</p><p>MasterOnly：false</p><p>If set to true, fe will get data from be cache, This option is suitable for real-time updating of partial partitions.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="cache_result_max_row_count"><code>cache_result_max_row_count</code><a href="#cache_result_max_row_count" class="hash-link" aria-label="Direct link to cache_result_max_row_count" title="Direct link to cache_result_max_row_count">​</a></h4><p>Default：3000</p><p>IsMutable：true</p><p>MasterOnly：false</p><p>In order to avoid occupying too much memory, the maximum number of rows that can be cached is 3000 by default. If this threshold is exceeded, the cache cannot be set</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="cache_result_max_data_size"><code>cache_result_max_data_size</code><a href="#cache_result_max_data_size" class="hash-link" aria-label="Direct link to cache_result_max_data_size" title="Direct link to cache_result_max_data_size">​</a></h4><p>Default: 31457280</p><p>IsMutable: true</p><p>MasterOnly: false</p><p>In order to avoid occupying too much memory, the maximum data size of rows that can be cached is 10MB by default. If this threshold is exceeded, the cache cannot be set</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="cache_last_version_interval_second"><code>cache_last_version_interval_second</code><a href="#cache_last_version_interval_second" class="hash-link" aria-label="Direct link to cache_last_version_interval_second" title="Direct link to cache_last_version_interval_second">​</a></h4><p>Default：900</p><p>IsMutable：true</p><p>MasterOnly：false</p><p>The time interval of the latest partitioned version of the table refers to the time interval between the data update and the current version. It is generally set to 900 seconds, which distinguishes offline and real-time import</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_batch_delete_by_default"><code>enable_batch_delete_by_default</code><a href="#enable_batch_delete_by_default" class="hash-link" aria-label="Direct link to enable_batch_delete_by_default" title="Direct link to enable_batch_delete_by_default">​</a></h4><p>Default：false</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Whether to add a delete sign column when create unique table</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_allowed_in_element_num_of_delete"><code>max_allowed_in_element_num_of_delete</code><a href="#max_allowed_in_element_num_of_delete" class="hash-link" aria-label="Direct link to max_allowed_in_element_num_of_delete" title="Direct link to max_allowed_in_element_num_of_delete">​</a></h4><p>Default：1024</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>This configuration is used to limit element num of InPredicate in delete statement.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_running_rollup_job_num_per_table"><code>max_running_rollup_job_num_per_table</code><a href="#max_running_rollup_job_num_per_table" class="hash-link" aria-label="Direct link to max_running_rollup_job_num_per_table" title="Direct link to max_running_rollup_job_num_per_table">​</a></h4><p>Default：1</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Control the concurrency limit of Rollup jobs</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_distribution_pruner_recursion_depth"><code>max_distribution_pruner_recursion_depth</code><a href="#max_distribution_pruner_recursion_depth" class="hash-link" aria-label="Direct link to max_distribution_pruner_recursion_depth" title="Direct link to max_distribution_pruner_recursion_depth">​</a></h4><p>Default：100</p><p>IsMutable：true</p><p>MasterOnly：false</p><p>This will limit the max recursion depth of hash distribution pruner.
eg: where a in (5 elements) and b in (4 elements) and c in (3 elements) and d in (2 elements).
a/b/c/d are distribution columns, so the recursion depth will be 5 <em> 4 </em> 3 * 2 = 120, larger than 100,
So that distribution pruner will no work and just return all buckets.
Increase the depth can support distribution pruning for more elements, but may cost more CPU.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_local_replica_selection"><code>enable_local_replica_selection</code><a href="#enable_local_replica_selection" class="hash-link" aria-label="Direct link to enable_local_replica_selection" title="Direct link to enable_local_replica_selection">​</a></h4><p>Default：false</p><p>IsMutable：true</p><p>If set to true, Planner will try to select replica of tablet on same host as this Frontend.
This may reduce network transmission in following case:</p><ul><li><p>N hosts with N Backends and N Frontends deployed.</p></li><li><p>The data has N replicas.</p></li><li><p>High concurrency queries are syyuyuient to all Frontends evenly</p></li></ul><p>In this case, all Frontends can only use local replicas to do the query. If you want to allow fallback to nonlocal replicas when no local replicas available, set enable_local_replica_selection_fallback to true.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_local_replica_selection_fallback"><code>enable_local_replica_selection_fallback</code><a href="#enable_local_replica_selection_fallback" class="hash-link" aria-label="Direct link to enable_local_replica_selection_fallback" title="Direct link to enable_local_replica_selection_fallback">​</a></h4><p>Default：false</p><p>IsMutable：true</p><p>Used with enable_local_replica_selection. If the local replicas is not available, fallback to the nonlocal replicas.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="expr_depth_limit"><code>expr_depth_limit</code><a href="#expr_depth_limit" class="hash-link" aria-label="Direct link to expr_depth_limit" title="Direct link to expr_depth_limit">​</a></h4><p>Default：3000</p><p>IsMutable：true</p><p>Limit on the depth of an expr tree.  Exceed this limit may cause long analysis time while holding db read lock.  Do not set this if you know what you are doing</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="expr_children_limit"><code>expr_children_limit</code><a href="#expr_children_limit" class="hash-link" aria-label="Direct link to expr_children_limit" title="Direct link to expr_children_limit">​</a></h4><p>Default：10000</p><p>IsMutable：true</p><p>Limit on the number of expr children of an expr tree.  Exceed this limit may cause long analysis time while holding database read lock.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="be_exec_version"><code>be_exec_version</code><a href="#be_exec_version" class="hash-link" aria-label="Direct link to be_exec_version" title="Direct link to be_exec_version">​</a></h4><p>Used to define the serialization format for passing blocks between fragments.</p><p>Sometimes some of our code changes will change the data format of the block. In order to make the BE compatible with each other during the rolling upgrade process, we need to issue a data version from the FE to decide what format to send the data in.</p><p>Specifically, for example, there are 2 BEs in the cluster, one of which can support the latest $v_1$ after being upgraded, while the other only supports $v_0$. At this time, since the FE has not been upgraded yet, $v_0 is issued uniformly. $, BE interact in the old data format. After all BEs are upgraded, we will upgrade FE. At this time, the new FE will issue $v_1$, and the cluster will be uniformly switched to the new data format.</p><p>The default value is <code>max_be_exec_version</code>. If there are special needs, we can manually set the format version to lower, but it should not be lower than <code>min_be_exec_version</code>.</p><p>Note that we should always keep the value of this variable between <code>BeExecVersionManager::min_be_exec_version</code> and <code>BeExecVersionManager::max_be_exec_version</code> for all BEs. (That is to say, if a cluster that has completed the update needs to be downgraded, it should ensure the order of downgrading FE and then downgrading BE, or manually lower the variable in the settings and downgrade BE)</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_be_exec_version"><code>max_be_exec_version</code><a href="#max_be_exec_version" class="hash-link" aria-label="Direct link to max_be_exec_version" title="Direct link to max_be_exec_version">​</a></h4><p>The latest data version currently supported, cannot be modified, and should be consistent with the <code>BeExecVersionManager::max_be_exec_version</code> in the BE of the matching version.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="min_be_exec_version"><code>min_be_exec_version</code><a href="#min_be_exec_version" class="hash-link" aria-label="Direct link to min_be_exec_version" title="Direct link to min_be_exec_version">​</a></h4><p>The oldest data version currently supported, which cannot be modified, should be consistent with the <code>BeExecVersionManager::min_be_exec_version</code> in the BE of the matching version.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_query_profile_num"><code>max_query_profile_num</code><a href="#max_query_profile_num" class="hash-link" aria-label="Direct link to max_query_profile_num" title="Direct link to max_query_profile_num">​</a></h4><p>The max number of query profile.</p><p>Default: 100</p><p>Is it possible to dynamically configure: true</p><p>Is it a configuration item unique to the Master FE node: false</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="publish_version_interval_ms"><code>publish_version_interval_ms</code><a href="#publish_version_interval_ms" class="hash-link" aria-label="Direct link to publish_version_interval_ms" title="Direct link to publish_version_interval_ms">​</a></h4><p>Default：10 （ms）</p><p>minimal intervals between two publish version action</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="publish_version_timeout_second"><code>publish_version_timeout_second</code><a href="#publish_version_timeout_second" class="hash-link" aria-label="Direct link to publish_version_timeout_second" title="Direct link to publish_version_timeout_second">​</a></h4><p>Default：30 （s）</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Maximal waiting time for all publish version tasks of one transaction to be finished</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="query_colocate_join_memory_limit_penalty_factor"><code>query_colocate_join_memory_limit_penalty_factor</code><a href="#query_colocate_join_memory_limit_penalty_factor" class="hash-link" aria-label="Direct link to query_colocate_join_memory_limit_penalty_factor" title="Direct link to query_colocate_join_memory_limit_penalty_factor">​</a></h4><p>Default：1</p><p>IsMutable：true</p><p>colocote join PlanFragment instance 的 memory_limit = exec_mem_limit / min (query_colocate_join_memory_limit_penalty_factor, instance_num)</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="rewrite_count_distinct_to_bitmap_hll"><code>rewrite_count_distinct_to_bitmap_hll</code><a href="#rewrite_count_distinct_to_bitmap_hll" class="hash-link" aria-label="Direct link to rewrite_count_distinct_to_bitmap_hll" title="Direct link to rewrite_count_distinct_to_bitmap_hll">​</a></h4><p>Default: true</p><p>This variable is a session variable, and the session level takes effect.</p><ul><li>Type: boolean</li><li>Description: <strong>Only for the table of the AGG model</strong>, when the variable is true, when the user query contains aggregate functions such as count(distinct c1), if the type of the c1 column itself is bitmap, count distnct will be rewritten It is bitmap_union_count(c1). When the type of the c1 column itself is hll, count distinct will be rewritten as hll_union_agg(c1) If the variable is false, no overwriting occurs..</li></ul><h3 class="anchor anchorWithStickyNavbar_LWe7" id="load-and-export">Load And Export<a href="#load-and-export" class="hash-link" aria-label="Direct link to Load And Export" title="Direct link to Load And Export">​</a></h3><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_pipeline_load"><code>enable_pipeline_load</code><a href="#enable_pipeline_load" class="hash-link" aria-label="Direct link to enable_pipeline_load" title="Direct link to enable_pipeline_load">​</a></h4><p>Default value: false</p><p>IsMutable: true</p><p>Whether or not to enable the Pipeline engine to perform import tasks such as Streamload.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_vectorized_load"><code>enable_vectorized_load</code><a href="#enable_vectorized_load" class="hash-link" aria-label="Direct link to enable_vectorized_load" title="Direct link to enable_vectorized_load">​</a></h4><p>Default: true</p><p>Whether to enable vectorized load</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_new_load_scan_node"><code>enable_new_load_scan_node</code><a href="#enable_new_load_scan_node" class="hash-link" aria-label="Direct link to enable_new_load_scan_node" title="Direct link to enable_new_load_scan_node">​</a></h4><p>Default: true</p><p>Whether to enable file scan node</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="default_max_filter_ratio"><code>default_max_filter_ratio</code><a href="#default_max_filter_ratio" class="hash-link" aria-label="Direct link to default_max_filter_ratio" title="Direct link to default_max_filter_ratio">​</a></h4><p>Default：0</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Maximum percentage of data that can be filtered (due to reasons such as data is irregularly) , The default value is 0.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_running_txn_num_per_db"><code>max_running_txn_num_per_db</code><a href="#max_running_txn_num_per_db" class="hash-link" aria-label="Direct link to max_running_txn_num_per_db" title="Direct link to max_running_txn_num_per_db">​</a></h4><p>Default：1000</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>This configuration is mainly used to control the number of concurrent load jobs of the same database.</p><p>When there are too many load jobs running in the cluster, the newly submitted load jobs may report errors:</p><div class="language-text codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#F8F8F2;--prism-background-color:#282A36"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#F8F8F2"><span class="token plain">current running txns on db xxx is xx, larger than limit xx</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg viewBox="0 0 24 24" class="copyButtonIcon_y97N"><path fill="currentColor" d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg viewBox="0 0 24 24" class="copyButtonSuccessIcon_LjdS"><path fill="currentColor" d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><p>When this error is encountered, it means that the load jobs currently running in the cluster exceeds the configuration value. At this time, it is recommended to wait on the business side and retry the load jobs.</p><p>If you use the Connector, the value of this parameter can be adjusted appropriately, and there is no problem with thousands</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="using_old_load_usage_pattern"><code>using_old_load_usage_pattern</code><a href="#using_old_load_usage_pattern" class="hash-link" aria-label="Direct link to using_old_load_usage_pattern" title="Direct link to using_old_load_usage_pattern">​</a></h4><p>Default：false</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>If set to true, the insert stmt with processing error will still return a label to user.  And user can use this label to check the load job&#x27;s status. The default value is false, which means if insert operation encounter errors,  exception will be thrown to user client directly without load label.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="disable_load_job"><code>disable_load_job</code><a href="#disable_load_job" class="hash-link" aria-label="Direct link to disable_load_job" title="Direct link to disable_load_job">​</a></h4><p>Default：false</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>if this is set to true</p><ul><li>all pending load job will failed when call begin txn api</li><li>all prepare load job will failed when call commit txn api</li><li>all committed load job will waiting to be published</li></ul><h4 class="anchor anchorWithStickyNavbar_LWe7" id="commit_timeout_second"><code>commit_timeout_second</code><a href="#commit_timeout_second" class="hash-link" aria-label="Direct link to commit_timeout_second" title="Direct link to commit_timeout_second">​</a></h4><p>Default：30</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Maximal waiting time for all data inserted before one transaction to be committed
This is the timeout second for the command &quot;commit&quot;</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_unfinished_load_job"><code>max_unfinished_load_job</code><a href="#max_unfinished_load_job" class="hash-link" aria-label="Direct link to max_unfinished_load_job" title="Direct link to max_unfinished_load_job">​</a></h4><p>Default：1000</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Max number of load jobs, include PENDING, ETL, LOADING, QUORUM_FINISHED. If exceed this number, load job is not allowed to be submitted</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="db_used_data_quota_update_interval_secs"><code>db_used_data_quota_update_interval_secs</code><a href="#db_used_data_quota_update_interval_secs" class="hash-link" aria-label="Direct link to db_used_data_quota_update_interval_secs" title="Direct link to db_used_data_quota_update_interval_secs">​</a></h4><p>Default：300 (s)</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>One master daemon thread will update database used data quota for db txn manager every <code>db_used_data_quota_update_interval_secs</code></p><p>For better data load performance, in the check of whether the amount of data used by the database before data load exceeds the quota, we do not calculate the amount of data already used by the database in real time, but obtain the periodically updated value of the daemon thread.</p><p>This configuration is used to set the time interval for updating the value of the amount of data used by the database</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="disable_show_stream_load"><code>disable_show_stream_load</code><a href="#disable_show_stream_load" class="hash-link" aria-label="Direct link to disable_show_stream_load" title="Direct link to disable_show_stream_load">​</a></h4><p>Default：false</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Whether to disable show stream load and clear stream load records in memory.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_stream_load_record_size"><code>max_stream_load_record_size</code><a href="#max_stream_load_record_size" class="hash-link" aria-label="Direct link to max_stream_load_record_size" title="Direct link to max_stream_load_record_size">​</a></h4><p>Default：5000</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Default max number of recent stream load record that can be stored in memory.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="fetch_stream_load_record_interval_second"><code>fetch_stream_load_record_interval_second</code><a href="#fetch_stream_load_record_interval_second" class="hash-link" aria-label="Direct link to fetch_stream_load_record_interval_second" title="Direct link to fetch_stream_load_record_interval_second">​</a></h4><p>Default：120</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>fetch stream load record interval.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_bytes_per_broker_scanner"><code>max_bytes_per_broker_scanner</code><a href="#max_bytes_per_broker_scanner" class="hash-link" aria-label="Direct link to max_bytes_per_broker_scanner" title="Direct link to max_bytes_per_broker_scanner">​</a></h4><p>Default：<code>500 * 1024 * 1024 * 1024L</code>  （500G）</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Max bytes a broker scanner can process in one broker load job. Commonly, each Backends has one broker scanner.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="default_load_parallelism"><code>default_load_parallelism</code><a href="#default_load_parallelism" class="hash-link" aria-label="Direct link to default_load_parallelism" title="Direct link to default_load_parallelism">​</a></h4><p>Default: 1</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Default parallelism of the broker load execution plan on a single node.
If the user to set the parallelism when the broker load is submitted, this parameter will be ignored.
This parameter will determine the concurrency of import tasks together with multiple configurations such as <code>max broker concurrency</code>, <code>min bytes per broker scanner</code>.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_broker_concurrency"><code>max_broker_concurrency</code><a href="#max_broker_concurrency" class="hash-link" aria-label="Direct link to max_broker_concurrency" title="Direct link to max_broker_concurrency">​</a></h4><p>Default：10</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Maximal concurrency of broker scanners.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="min_bytes_per_broker_scanner"><code>min_bytes_per_broker_scanner</code><a href="#min_bytes_per_broker_scanner" class="hash-link" aria-label="Direct link to min_bytes_per_broker_scanner" title="Direct link to min_bytes_per_broker_scanner">​</a></h4><p>Default：67108864L (64M)</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Minimum bytes that a single broker scanner will read.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="period_of_auto_resume_min"><code>period_of_auto_resume_min</code><a href="#period_of_auto_resume_min" class="hash-link" aria-label="Direct link to period_of_auto_resume_min" title="Direct link to period_of_auto_resume_min">​</a></h4><p>Default：5 （s）</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Automatically restore the cycle of Routine load</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_tolerable_backend_down_num"><code>max_tolerable_backend_down_num</code><a href="#max_tolerable_backend_down_num" class="hash-link" aria-label="Direct link to max_tolerable_backend_down_num" title="Direct link to max_tolerable_backend_down_num">​</a></h4><p>Default：0</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>As long as one BE is down, Routine Load cannot be automatically restored</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_routine_load_task_num_per_be"><code>max_routine_load_task_num_per_be</code><a href="#max_routine_load_task_num_per_be" class="hash-link" aria-label="Direct link to max_routine_load_task_num_per_be" title="Direct link to max_routine_load_task_num_per_be">​</a></h4><p>Default：5</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>the max concurrent routine load task num per BE.  This is to limit the num of routine load tasks sending to a BE, and it should also less than BE config &#x27;routine_load_thread_pool_size&#x27;(default 10), which is the routine load task thread pool size on BE.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_routine_load_task_concurrent_num"><code>max_routine_load_task_concurrent_num</code><a href="#max_routine_load_task_concurrent_num" class="hash-link" aria-label="Direct link to max_routine_load_task_concurrent_num" title="Direct link to max_routine_load_task_concurrent_num">​</a></h4><p>Default：5</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>the max concurrent routine load task num of a single routine load job</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_routine_load_job_num"><code>max_routine_load_job_num</code><a href="#max_routine_load_job_num" class="hash-link" aria-label="Direct link to max_routine_load_job_num" title="Direct link to max_routine_load_job_num">​</a></h4><p>Default：100</p><p>the max routine load job num, including NEED_SCHEDULED, RUNNING, PAUSE</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="desired_max_waiting_jobs"><code>desired_max_waiting_jobs</code><a href="#desired_max_waiting_jobs" class="hash-link" aria-label="Direct link to desired_max_waiting_jobs" title="Direct link to desired_max_waiting_jobs">​</a></h4><p>Default：100</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Default number of waiting jobs for routine load and version 2 of load , This is a desired number.  In some situation, such as switch the master, the current number is maybe more than desired_max_waiting_jobs.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="disable_hadoop_load"><code>disable_hadoop_load</code><a href="#disable_hadoop_load" class="hash-link" aria-label="Direct link to disable_hadoop_load" title="Direct link to disable_hadoop_load">​</a></h4><p>Default：false</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Load using hadoop cluster will be deprecated in future. Set to true to disable this kind of load.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_spark_load"><code>enable_spark_load</code><a href="#enable_spark_load" class="hash-link" aria-label="Direct link to enable_spark_load" title="Direct link to enable_spark_load">​</a></h4><p>Default：false</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Whether to enable spark load temporarily, it is not enabled by default</p><p><strong>Note:</strong> This parameter has been deleted in version 1.2, spark_load is enabled by default</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="spark_load_checker_interval_second"><code>spark_load_checker_interval_second</code><a href="#spark_load_checker_interval_second" class="hash-link" aria-label="Direct link to spark_load_checker_interval_second" title="Direct link to spark_load_checker_interval_second">​</a></h4><p>Default：60</p><p>Spark load scheduler run interval, default 60 seconds</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="async_loading_load_task_pool_size"><code>async_loading_load_task_pool_size</code><a href="#async_loading_load_task_pool_size" class="hash-link" aria-label="Direct link to async_loading_load_task_pool_size" title="Direct link to async_loading_load_task_pool_size">​</a></h4><p>Default：10</p><p>IsMutable：false</p><p>MasterOnly：true</p><p>The loading_load task executor pool size. This pool size limits the max running loading_load tasks.</p><p>Currently, it only limits the loading_load task of broker load</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="async_pending_load_task_pool_size"><code>async_pending_load_task_pool_size</code><a href="#async_pending_load_task_pool_size" class="hash-link" aria-label="Direct link to async_pending_load_task_pool_size" title="Direct link to async_pending_load_task_pool_size">​</a></h4><p>Default：10</p><p>IsMutable：false</p><p>MasterOnly：true</p><p>The pending_load task executor pool size. This pool size limits the max running pending_load tasks.</p><p>Currently, it only limits the pending_load task of broker load and spark load.</p><p>It should be less than &#x27;max_running_txn_num_per_db&#x27;</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="async_load_task_pool_size"><code>async_load_task_pool_size</code><a href="#async_load_task_pool_size" class="hash-link" aria-label="Direct link to async_load_task_pool_size" title="Direct link to async_load_task_pool_size">​</a></h4><p>Default：10</p><p>IsMutable：false</p><p>MasterOnly：true</p><p>This configuration is just for compatible with old version, this config has been replaced by async_loading_load_task_pool_size, it will be removed in the future.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_single_replica_load"><code>enable_single_replica_load</code><a href="#enable_single_replica_load" class="hash-link" aria-label="Direct link to enable_single_replica_load" title="Direct link to enable_single_replica_load">​</a></h4><p>Default：false</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Whether to enable to write single replica for stream load and broker load.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="min_load_timeout_second"><code>min_load_timeout_second</code><a href="#min_load_timeout_second" class="hash-link" aria-label="Direct link to min_load_timeout_second" title="Direct link to min_load_timeout_second">​</a></h4><p>Default：1 （1s）</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Min stream load timeout applicable to all type of load</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_stream_load_timeout_second"><code>max_stream_load_timeout_second</code><a href="#max_stream_load_timeout_second" class="hash-link" aria-label="Direct link to max_stream_load_timeout_second" title="Direct link to max_stream_load_timeout_second">​</a></h4><p>Default: 259200 (3 day)</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>This configuration is specifically used to limit timeout setting for stream load. It is to prevent that failed stream load transactions cannot be canceled within a short time because of the user&#x27;s large timeout setting</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_load_timeout_second"><code>max_load_timeout_second</code><a href="#max_load_timeout_second" class="hash-link" aria-label="Direct link to max_load_timeout_second" title="Direct link to max_load_timeout_second">​</a></h4><p>Default: 259200 (3 day)</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Max load timeout applicable to all type of load except for stream load</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="stream_load_default_timeout_second"><code>stream_load_default_timeout_second</code><a href="#stream_load_default_timeout_second" class="hash-link" aria-label="Direct link to stream_load_default_timeout_second" title="Direct link to stream_load_default_timeout_second">​</a></h4><p>Default: 86400 * 3 (3 day)</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Default stream load and streaming mini load timeout</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="stream_load_default_precommit_timeout_second"><code>stream_load_default_precommit_timeout_second</code><a href="#stream_load_default_precommit_timeout_second" class="hash-link" aria-label="Direct link to stream_load_default_precommit_timeout_second" title="Direct link to stream_load_default_precommit_timeout_second">​</a></h4><p>Default：3600（s）</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Default stream load pre-submission timeout</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="insert_load_default_timeout_second"><code>insert_load_default_timeout_second</code><a href="#insert_load_default_timeout_second" class="hash-link" aria-label="Direct link to insert_load_default_timeout_second" title="Direct link to insert_load_default_timeout_second">​</a></h4><p>Default: 3600 (1 hour)</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Default insert load timeout</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="mini_load_default_timeout_second"><code>mini_load_default_timeout_second</code><a href="#mini_load_default_timeout_second" class="hash-link" aria-label="Direct link to mini_load_default_timeout_second" title="Direct link to mini_load_default_timeout_second">​</a></h4><p>Default: 3600 (1 hour)</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Default non-streaming mini load timeout</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="broker_load_default_timeout_second"><code>broker_load_default_timeout_second</code><a href="#broker_load_default_timeout_second" class="hash-link" aria-label="Direct link to broker_load_default_timeout_second" title="Direct link to broker_load_default_timeout_second">​</a></h4><p>Default: 14400 (4 hour)</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Default broker load timeout</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="spark_load_default_timeout_second"><code>spark_load_default_timeout_second</code><a href="#spark_load_default_timeout_second" class="hash-link" aria-label="Direct link to spark_load_default_timeout_second" title="Direct link to spark_load_default_timeout_second">​</a></h4><p>Default: 86400  (1 day)</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Default spark load timeout</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="hadoop_load_default_timeout_second"><code>hadoop_load_default_timeout_second</code><a href="#hadoop_load_default_timeout_second" class="hash-link" aria-label="Direct link to hadoop_load_default_timeout_second" title="Direct link to hadoop_load_default_timeout_second">​</a></h4><p>Default: 86400 * 3   (3 day)</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Default hadoop load timeout</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="load_running_job_num_limit"><code>load_running_job_num_limit</code><a href="#load_running_job_num_limit" class="hash-link" aria-label="Direct link to load_running_job_num_limit" title="Direct link to load_running_job_num_limit">​</a></h4><p>Default：0</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>The number of loading tasks is limited, the default is 0, no limit</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="load_input_size_limit_gb"><code>load_input_size_limit_gb</code><a href="#load_input_size_limit_gb" class="hash-link" aria-label="Direct link to load_input_size_limit_gb" title="Direct link to load_input_size_limit_gb">​</a></h4><p>Default：0</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>The size of the data entered by the Load job, the default is 0, unlimited</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="load_etl_thread_num_normal_priority"><code>load_etl_thread_num_normal_priority</code><a href="#load_etl_thread_num_normal_priority" class="hash-link" aria-label="Direct link to load_etl_thread_num_normal_priority" title="Direct link to load_etl_thread_num_normal_priority">​</a></h4><p>Default：10</p><p>Concurrency of NORMAL priority etl load jobs. Do not change this if you know what you are doing.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="load_etl_thread_num_high_priority"><code>load_etl_thread_num_high_priority</code><a href="#load_etl_thread_num_high_priority" class="hash-link" aria-label="Direct link to load_etl_thread_num_high_priority" title="Direct link to load_etl_thread_num_high_priority">​</a></h4><p>Default：3</p><p>Concurrency of HIGH priority etl load jobs. Do not change this if you know what you are doing</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="load_pending_thread_num_normal_priority"><code>load_pending_thread_num_normal_priority</code><a href="#load_pending_thread_num_normal_priority" class="hash-link" aria-label="Direct link to load_pending_thread_num_normal_priority" title="Direct link to load_pending_thread_num_normal_priority">​</a></h4><p>Default：10</p><p>Concurrency of NORMAL priority pending load jobs.  Do not change this if you know what you are doing.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="load_pending_thread_num_high_priority"><code>load_pending_thread_num_high_priority</code><a href="#load_pending_thread_num_high_priority" class="hash-link" aria-label="Direct link to load_pending_thread_num_high_priority" title="Direct link to load_pending_thread_num_high_priority">​</a></h4><p>Default：3</p><p>Concurrency of HIGH priority pending load jobs. Load job priority is defined as HIGH or NORMAL.  All mini batch load jobs are HIGH priority, other types of load jobs are NORMAL priority.  Priority is set to avoid that a slow load job occupies a thread for a long time.  This is just a internal optimized scheduling policy.  Currently, you can not specified the job priority manually, and do not change this if you know what you are doing.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="load_checker_interval_second"><code>load_checker_interval_second</code><a href="#load_checker_interval_second" class="hash-link" aria-label="Direct link to load_checker_interval_second" title="Direct link to load_checker_interval_second">​</a></h4><p>Default：5 （s）</p><p>The load scheduler running interval. A load job will transfer its state from PENDING to LOADING to FINISHED.  The load scheduler will transfer load job from PENDING to LOADING while the txn callback will transfer load job from LOADING to FINISHED.  So a load job will cost at most one interval to finish when the concurrency has not reached the upper limit.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="load_straggler_wait_second"><code>load_straggler_wait_second</code><a href="#load_straggler_wait_second" class="hash-link" aria-label="Direct link to load_straggler_wait_second" title="Direct link to load_straggler_wait_second">​</a></h4><p>Default：300</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Maximal wait seconds for straggler node in load
eg.
there are 3 replicas A, B, C
load is already quorum finished(A,B) at t1 and C is not finished
if (current_time - t1) &gt; 300s, then palo will treat C as a failure node
will call transaction manager to commit the transaction and tell transaction manager that C is failed</p><p>This is also used when waiting for publish tasks</p><p><strong>Note:</strong> this parameter is the default value for all job and the DBA could specify it for separate job</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="label_keep_max_second"><code>label_keep_max_second</code><a href="#label_keep_max_second" class="hash-link" aria-label="Direct link to label_keep_max_second" title="Direct link to label_keep_max_second">​</a></h4><p>Default：<code>3 * 24 * 3600</code>  (3 day)</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>labels of finished or cancelled load jobs will be removed after <code>label_keep_max_second</code> ，</p><ol><li>The removed labels can be reused.</li><li>Set a short time will lower the FE memory usage.  (Because all load jobs&#x27; info is kept in memory before being removed)</li></ol><p>In the case of high concurrent writes, if there is a large backlog of jobs and call frontend service failed, check the log. If the metadata write takes too long to lock, you can adjust this value to 12 hours, or 6 hours less</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="streaming_label_keep_max_second"><code>streaming_label_keep_max_second</code><a href="#streaming_label_keep_max_second" class="hash-link" aria-label="Direct link to streaming_label_keep_max_second" title="Direct link to streaming_label_keep_max_second">​</a></h4><p>Default: 43200 (12 hour)</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>For some high-frequency load work, such as: INSERT, STREAMING LOAD, ROUTINE_LOAD_TASK. If it expires, delete the completed job or task.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="label_clean_interval_second"><code>label_clean_interval_second</code><a href="#label_clean_interval_second" class="hash-link" aria-label="Direct link to label_clean_interval_second" title="Direct link to label_clean_interval_second">​</a></h4><p>Default：1 * 3600  (1 hour)</p><p>Load label cleaner will run every <em>label_clean_interval_second</em> to clean the outdated jobs.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="transaction_clean_interval_second"><code>transaction_clean_interval_second</code><a href="#transaction_clean_interval_second" class="hash-link" aria-label="Direct link to transaction_clean_interval_second" title="Direct link to transaction_clean_interval_second">​</a></h4><p>Default：30</p><p>the transaction will be cleaned after transaction_clean_interval_second seconds if the transaction is visible or aborted  we should make this interval as short as possible and each clean cycle as soon as possible</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="sync_commit_interval_second"><code>sync_commit_interval_second</code><a href="#sync_commit_interval_second" class="hash-link" aria-label="Direct link to sync_commit_interval_second" title="Direct link to sync_commit_interval_second">​</a></h4><p>The maximum time interval for committing transactions. If there is still data in the channel that has not been submitted after this time, the consumer will notify the channel to submit the transaction.</p><p>Default: 10 (seconds)</p><p>Is it possible to configure dynamically: true</p><p>Whether it is a configuration item unique to the Master FE node: true</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="sync_checker_interval_second"><code>sync_checker_interval_second</code><a href="#sync_checker_interval_second" class="hash-link" aria-label="Direct link to sync_checker_interval_second" title="Direct link to sync_checker_interval_second">​</a></h4><p>Data synchronization job running status check.</p><p>Default: 10 (s)</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_sync_task_threads_num"><code>max_sync_task_threads_num</code><a href="#max_sync_task_threads_num" class="hash-link" aria-label="Direct link to max_sync_task_threads_num" title="Direct link to max_sync_task_threads_num">​</a></h4><p>The maximum number of threads in the data synchronization job thread pool.</p><p>默认值：10</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="min_sync_commit_size"><code>min_sync_commit_size</code><a href="#min_sync_commit_size" class="hash-link" aria-label="Direct link to min_sync_commit_size" title="Direct link to min_sync_commit_size">​</a></h4><p>The minimum number of events that must be satisfied to commit a transaction. If the number of events received by Fe is less than it, it will continue to wait for the next batch of data until the time exceeds <code>sync_commit_interval_second</code>. The default value is 10000 events. If you want to modify this configuration, please make sure that this value is smaller than the <code>canal.instance.memory.buffer.size</code> configuration on the canal side (default 16384), otherwise Fe will try to get the queue length longer than the store before ack More events cause the store queue to block until it times out.</p><p>Default: 10000</p><p>Is it possible to configure dynamically: true</p><p>Whether it is a configuration item unique to the Master FE node: true</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="min_bytes_sync_commit"><code>min_bytes_sync_commit</code><a href="#min_bytes_sync_commit" class="hash-link" aria-label="Direct link to min_bytes_sync_commit" title="Direct link to min_bytes_sync_commit">​</a></h4><p>The minimum data size required to commit a transaction. If the data size received by Fe is smaller than it, it will continue to wait for the next batch of data until the time exceeds <code>sync_commit_interval_second</code>. The default value is 15MB, if you want to modify this configuration, please make sure this value is less than the product of <code>canal.instance.memory.buffer.size</code> and <code>canal.instance.memory.buffer.memunit</code> on the canal side (default 16MB), otherwise Before the ack, Fe will try to obtain data that is larger than the store space, causing the store queue to block until it times out.</p><p>Default: <code>15*1024*1024</code> (15M)</p><p>Is it possible to configure dynamically: true</p><p>Whether it is a configuration item unique to the Master FE node: true</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_bytes_sync_commit"><code>max_bytes_sync_commit</code><a href="#max_bytes_sync_commit" class="hash-link" aria-label="Direct link to max_bytes_sync_commit" title="Direct link to max_bytes_sync_commit">​</a></h4><p>The maximum number of threads in the data synchronization job thread pool. There is only one thread pool in the entire FE, which is used to process all data synchronization tasks in the FE that send data to the BE. The implementation of the thread pool is in the <code>SyncTaskPool</code> class.</p><p>Default: 10</p><p>Is it possible to dynamically configure: false</p><p>Is it a configuration item unique to the Master FE node: false</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_outfile_to_local"><code>enable_outfile_to_local</code><a href="#enable_outfile_to_local" class="hash-link" aria-label="Direct link to enable_outfile_to_local" title="Direct link to enable_outfile_to_local">​</a></h4><p>Default：false</p><p>Whether to allow the outfile function to export the results to the local disk.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="export_tablet_num_per_task"><code>export_tablet_num_per_task</code><a href="#export_tablet_num_per_task" class="hash-link" aria-label="Direct link to export_tablet_num_per_task" title="Direct link to export_tablet_num_per_task">​</a></h4><p>Default：5</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Number of tablets per export query plan</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="export_task_default_timeout_second"><code>export_task_default_timeout_second</code><a href="#export_task_default_timeout_second" class="hash-link" aria-label="Direct link to export_task_default_timeout_second" title="Direct link to export_task_default_timeout_second">​</a></h4><p>Default: 2 * 3600   (2 hour)</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Default timeout of export jobs.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="export_running_job_num_limit"><code>export_running_job_num_limit</code><a href="#export_running_job_num_limit" class="hash-link" aria-label="Direct link to export_running_job_num_limit" title="Direct link to export_running_job_num_limit">​</a></h4><p>Default：5</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Limitation of the concurrency of running export jobs.  Default is 5.  0 is unlimited</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="export_checker_interval_second"><code>export_checker_interval_second</code><a href="#export_checker_interval_second" class="hash-link" aria-label="Direct link to export_checker_interval_second" title="Direct link to export_checker_interval_second">​</a></h4><p>Default：5</p><p>Export checker&#x27;s running interval.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="log">Log<a href="#log" class="hash-link" aria-label="Direct link to Log" title="Direct link to Log">​</a></h3><h4 class="anchor anchorWithStickyNavbar_LWe7" id="log_roll_size_mb"><code>log_roll_size_mb</code><a href="#log_roll_size_mb" class="hash-link" aria-label="Direct link to log_roll_size_mb" title="Direct link to log_roll_size_mb">​</a></h4><p>Default：1024  （1G）</p><p>The max size of one sys log and audit log</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="sys_log_dir"><code>sys_log_dir</code><a href="#sys_log_dir" class="hash-link" aria-label="Direct link to sys_log_dir" title="Direct link to sys_log_dir">​</a></h4><p>Default: DorisFE.DORIS_HOME_DIR + &quot;/log&quot;</p><p>This specifies FE log dir. FE will produces 2 log files:</p><p>fe.log:      all logs of FE process.
fe.warn.log  all WARNING and ERROR log of FE process.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="sys_log_level"><code>sys_log_level</code><a href="#sys_log_level" class="hash-link" aria-label="Direct link to sys_log_level" title="Direct link to sys_log_level">​</a></h4><p>Default：INFO</p><p>log level: INFO, WARNING, ERROR, FATAL</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="sys_log_roll_num"><code>sys_log_roll_num</code><a href="#sys_log_roll_num" class="hash-link" aria-label="Direct link to sys_log_roll_num" title="Direct link to sys_log_roll_num">​</a></h4><p>Default：10</p><p>Maximal FE log files to be kept within an sys_log_roll_interval. default is 10, which means there will be at most 10 log files in a day</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="sys_log_verbose_modules"><code>sys_log_verbose_modules</code><a href="#sys_log_verbose_modules" class="hash-link" aria-label="Direct link to sys_log_verbose_modules" title="Direct link to sys_log_verbose_modules">​</a></h4><p>Default：{}</p><p>Verbose modules. VERBOSE level is implemented by log4j DEBUG level.</p><p>eg：
sys_log_verbose_modules = org.apache.doris.catalog
This will only print debug log of files in package org.apache.doris.catalog and all its sub packages.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="sys_log_roll_interval"><code>sys_log_roll_interval</code><a href="#sys_log_roll_interval" class="hash-link" aria-label="Direct link to sys_log_roll_interval" title="Direct link to sys_log_roll_interval">​</a></h4><p>Default：DAY</p><p>sys_log_roll_interval:</p><ul><li>DAY:  log suffix is  yyyyMMdd</li><li>HOUR: log suffix is  yyyyMMddHH</li></ul><h4 class="anchor anchorWithStickyNavbar_LWe7" id="sys_log_delete_age"><code>sys_log_delete_age</code><a href="#sys_log_delete_age" class="hash-link" aria-label="Direct link to sys_log_delete_age" title="Direct link to sys_log_delete_age">​</a></h4><p>Default：7d</p><p>default is 7 days, if log&#x27;s last modify time is 7 days ago, it will be deleted.</p><p>support format:</p><ul><li>7d      7 day</li><li>10h     10 hours</li><li>60m     60 min</li><li>120s    120 seconds</li></ul><h4 class="anchor anchorWithStickyNavbar_LWe7" id="sys_log_roll_mode"><code>sys_log_roll_mode</code><a href="#sys_log_roll_mode" class="hash-link" aria-label="Direct link to sys_log_roll_mode" title="Direct link to sys_log_roll_mode">​</a></h4><p>Default：SIZE-MB-1024</p><p>The size of the log split, split a log file every 1 G</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="sys_log_enable_compress"><code>sys_log_enable_compress</code><a href="#sys_log_enable_compress" class="hash-link" aria-label="Direct link to sys_log_enable_compress" title="Direct link to sys_log_enable_compress">​</a></h4><p>Default: false</p><p>If true, will compress fe.log &amp; fe.warn.log by gzip</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="audit_log_dir"><code>audit_log_dir</code><a href="#audit_log_dir" class="hash-link" aria-label="Direct link to audit_log_dir" title="Direct link to audit_log_dir">​</a></h4><p>Default：DORIS_HOME_DIR + &quot;/log&quot;</p><p>audit_log_dir：
This specifies FE audit log dir..
Audit log fe.audit.log contains all requests with related infos such as user, host, cost, status, etc</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="audit_log_roll_num"><code>audit_log_roll_num</code><a href="#audit_log_roll_num" class="hash-link" aria-label="Direct link to audit_log_roll_num" title="Direct link to audit_log_roll_num">​</a></h4><p>Default：90</p><p>Maximal FE audit log files to be kept within an audit_log_roll_interval.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="audit_log_modules"><code>audit_log_modules</code><a href="#audit_log_modules" class="hash-link" aria-label="Direct link to audit_log_modules" title="Direct link to audit_log_modules">​</a></h4><p>Default：{&quot;slow_query&quot;, &quot;query&quot;, &quot;load&quot;, &quot;stream_load&quot;}</p><p>Slow query contains all queries which cost exceed <em>qe_slow_log_ms</em></p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="qe_slow_log_ms"><code>qe_slow_log_ms</code><a href="#qe_slow_log_ms" class="hash-link" aria-label="Direct link to qe_slow_log_ms" title="Direct link to qe_slow_log_ms">​</a></h4><p>Default: 5000 (5 seconds)</p><p>If the response time of a query exceed this threshold, it will be recorded in audit log as slow_query.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="audit_log_roll_interval"><code>audit_log_roll_interval</code><a href="#audit_log_roll_interval" class="hash-link" aria-label="Direct link to audit_log_roll_interval" title="Direct link to audit_log_roll_interval">​</a></h4><p>Default：DAY</p><p>DAY:  logsuffix is : yyyyMMdd
HOUR: logsuffix is : yyyyMMddHH</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="audit_log_delete_age"><code>audit_log_delete_age</code><a href="#audit_log_delete_age" class="hash-link" aria-label="Direct link to audit_log_delete_age" title="Direct link to audit_log_delete_age">​</a></h4><p>Default：30d</p><p>default is 30 days, if log&#x27;s last modify time is 30 days ago, it will be deleted.</p><p>support format:</p><ul><li>7d      7 day</li><li>10h     10 hours</li><li>60m     60 min</li><li>120s    120 seconds</li></ul><h4 class="anchor anchorWithStickyNavbar_LWe7" id="audit_log_enable_compress"><code>audit_log_enable_compress</code><a href="#audit_log_enable_compress" class="hash-link" aria-label="Direct link to audit_log_enable_compress" title="Direct link to audit_log_enable_compress">​</a></h4><p>Default: false</p><p>If true, will compress fe.audit.log by gzip</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="storage">Storage<a href="#storage" class="hash-link" aria-label="Direct link to Storage" title="Direct link to Storage">​</a></h3><h4 class="anchor anchorWithStickyNavbar_LWe7" id="min_replication_num_per_tablet"><code>min_replication_num_per_tablet</code><a href="#min_replication_num_per_tablet" class="hash-link" aria-label="Direct link to min_replication_num_per_tablet" title="Direct link to min_replication_num_per_tablet">​</a></h4><p>Default: 1</p><p>Used to set minimal number of replication per tablet.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_replication_num_per_tablet"><code>max_replication_num_per_tablet</code><a href="#max_replication_num_per_tablet" class="hash-link" aria-label="Direct link to max_replication_num_per_tablet" title="Direct link to max_replication_num_per_tablet">​</a></h4><p>Default: 32767</p><p>Used to set maximal number of replication per tablet.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="default_db_data_quota_bytes"><code>default_db_data_quota_bytes</code><a href="#default_db_data_quota_bytes" class="hash-link" aria-label="Direct link to default_db_data_quota_bytes" title="Direct link to default_db_data_quota_bytes">​</a></h4><p>Default：1PB</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Used to set the default database data quota size. To set the quota size of a single database, you can use:</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#F8F8F2;--prism-background-color:#282A36"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#F8F8F2"><span class="token plain">Set the database data quota, the unit is:B/K/KB/M/MB/G/GB/T/TB/P/PB</span><br></span><span class="token-line" style="color:#F8F8F2"><span class="token plain">ALTER DATABASE db_name SET DATA QUOTA quota;</span><br></span><span class="token-line" style="color:#F8F8F2"><span class="token plain">View configuration</span><br></span><span class="token-line" style="color:#F8F8F2"><span class="token plain">show data （Detail：HELP SHOW DATA）</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg viewBox="0 0 24 24" class="copyButtonIcon_y97N"><path fill="currentColor" d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg viewBox="0 0 24 24" class="copyButtonSuccessIcon_LjdS"><path fill="currentColor" d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><h4 class="anchor anchorWithStickyNavbar_LWe7" id="default_db_replica_quota_size"><code>default_db_replica_quota_size</code><a href="#default_db_replica_quota_size" class="hash-link" aria-label="Direct link to default_db_replica_quota_size" title="Direct link to default_db_replica_quota_size">​</a></h4><p>Default: 1073741824</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Used to set the default database replica quota. To set the quota size of a single database, you can use:</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#F8F8F2;--prism-background-color:#282A36"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#F8F8F2"><span class="token plain">Set the database replica quota</span><br></span><span class="token-line" style="color:#F8F8F2"><span class="token plain">ALTER DATABASE db_name SET REPLICA QUOTA quota;</span><br></span><span class="token-line" style="color:#F8F8F2"><span class="token plain">View configuration</span><br></span><span class="token-line" style="color:#F8F8F2"><span class="token plain">show data （Detail：HELP SHOW DATA）</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg viewBox="0 0 24 24" class="copyButtonIcon_y97N"><path fill="currentColor" d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg viewBox="0 0 24 24" class="copyButtonSuccessIcon_LjdS"><path fill="currentColor" d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><h4 class="anchor anchorWithStickyNavbar_LWe7" id="recover_with_empty_tablet"><code>recover_with_empty_tablet</code><a href="#recover_with_empty_tablet" class="hash-link" aria-label="Direct link to recover_with_empty_tablet" title="Direct link to recover_with_empty_tablet">​</a></h4><p>Default：false</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>In some very special circumstances, such as code bugs, or human misoperation, etc., all replicas of some tablets may be lost. In this case, the data has been substantially lost. However, in some scenarios, the business still hopes to ensure that the query will not report errors even if there is data loss, and reduce the perception of the user layer. At this point, we can use the blank Tablet to fill the missing replica to ensure that the query can be executed normally.</p><p>Set to true so that Doris will automatically use blank replicas to fill tablets which all replicas have been damaged or missing</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="min_clone_task_timeout_sec-and-max_clone_task_timeout_sec"><code>min_clone_task_timeout_sec</code> <code>And max_clone_task_timeout_sec</code><a href="#min_clone_task_timeout_sec-and-max_clone_task_timeout_sec" class="hash-link" aria-label="Direct link to min_clone_task_timeout_sec-and-max_clone_task_timeout_sec" title="Direct link to min_clone_task_timeout_sec-and-max_clone_task_timeout_sec">​</a></h4><p>Default: Minimum 3 minutes, maximum two hours</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Can cooperate with <code>mix_clone_task_timeout_sec</code> to control the maximum and minimum timeout of a clone task. Under normal circumstances, the timeout of a clone task is estimated by the amount of data and the minimum transfer rate (5MB/s). In some special cases, these two configurations can be used to set the upper and lower bounds of the clone task timeout to ensure that the clone task can be completed successfully.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="disable_storage_medium_check"><code>disable_storage_medium_check</code><a href="#disable_storage_medium_check" class="hash-link" aria-label="Direct link to disable_storage_medium_check" title="Direct link to disable_storage_medium_check">​</a></h4><p>Default：false</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>If disable_storage_medium_check is true, ReportHandler would not check tablet&#x27;s storage medium and disable storage cool down function, the default value is false. You can set the value true when you don&#x27;t care what the storage medium of the tablet is.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="decommission_tablet_check_threshold"><code>decommission_tablet_check_threshold</code><a href="#decommission_tablet_check_threshold" class="hash-link" aria-label="Direct link to decommission_tablet_check_threshold" title="Direct link to decommission_tablet_check_threshold">​</a></h4><p>Default：5000</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>This configuration is used to control whether the Master FE need to check the status of tablets on decommissioned BE. If the size of tablets on decommissioned BE is lower than this threshold, FE will start a periodic check, if all tablets on decommissioned BE have been recycled, FE will drop this BE immediately.</p><p>For performance consideration, please don&#x27;t set a very high value for this configuration.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="partition_rebalance_max_moves_num_per_selection"><code>partition_rebalance_max_moves_num_per_selection</code><a href="#partition_rebalance_max_moves_num_per_selection" class="hash-link" aria-label="Direct link to partition_rebalance_max_moves_num_per_selection" title="Direct link to partition_rebalance_max_moves_num_per_selection">​</a></h4><p>Default：10</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Valid only if use PartitionRebalancer,</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="partition_rebalance_move_expire_after_access"><code>partition_rebalance_move_expire_after_access</code><a href="#partition_rebalance_move_expire_after_access" class="hash-link" aria-label="Direct link to partition_rebalance_move_expire_after_access" title="Direct link to partition_rebalance_move_expire_after_access">​</a></h4><p>Default：600   (s)</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Valid only if use PartitionRebalancer. If this changed, cached moves will be cleared</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="tablet_rebalancer_type"><code>tablet_rebalancer_type</code><a href="#tablet_rebalancer_type" class="hash-link" aria-label="Direct link to tablet_rebalancer_type" title="Direct link to tablet_rebalancer_type">​</a></h4><p>Default：BeLoad</p><p>MasterOnly：true</p><p>Rebalancer type(ignore case): BeLoad, Partition. If type parse failed, use BeLoad as default</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_balancing_tablets"><code>max_balancing_tablets</code><a href="#max_balancing_tablets" class="hash-link" aria-label="Direct link to max_balancing_tablets" title="Direct link to max_balancing_tablets">​</a></h4><p>Default：100</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>if the number of balancing tablets in TabletScheduler exceed max_balancing_tablets, no more balance check</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_scheduling_tablets"><code>max_scheduling_tablets</code><a href="#max_scheduling_tablets" class="hash-link" aria-label="Direct link to max_scheduling_tablets" title="Direct link to max_scheduling_tablets">​</a></h4><p>Default：2000</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>if the number of scheduled tablets in TabletScheduler exceed max_scheduling_tablets skip checking.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="disable_balance"><code>disable_balance</code><a href="#disable_balance" class="hash-link" aria-label="Direct link to disable_balance" title="Direct link to disable_balance">​</a></h4><p>Default：false</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>if set to true, TabletScheduler will not do balance.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="disable_disk_balance"><code>disable_disk_balance</code><a href="#disable_disk_balance" class="hash-link" aria-label="Direct link to disable_disk_balance" title="Direct link to disable_disk_balance">​</a></h4><p>Default：true</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>if set to true, TabletScheduler will not do disk balance.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="balance_load_score_threshold"><code>balance_load_score_threshold</code><a href="#balance_load_score_threshold" class="hash-link" aria-label="Direct link to balance_load_score_threshold" title="Direct link to balance_load_score_threshold">​</a></h4><p>Default: 0.1 (10%)</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>the threshold of cluster balance score, if a backend&#x27;s load score is 10% lower than average score,  this backend will be marked as LOW load, if load score is 10% higher than average score, HIGH load  will be marked</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="capacity_used_percent_high_water"><code>capacity_used_percent_high_water</code><a href="#capacity_used_percent_high_water" class="hash-link" aria-label="Direct link to capacity_used_percent_high_water" title="Direct link to capacity_used_percent_high_water">​</a></h4><p>Default: 0.75  (75%)</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>The high water of disk capacity used percent. This is used for calculating load score of a backend</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="clone_distribution_balance_threshold"><code>clone_distribution_balance_threshold</code><a href="#clone_distribution_balance_threshold" class="hash-link" aria-label="Direct link to clone_distribution_balance_threshold" title="Direct link to clone_distribution_balance_threshold">​</a></h4><p>Default: 0.2</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Balance threshold of num of replicas in Backends.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="clone_capacity_balance_threshold"><code>clone_capacity_balance_threshold</code><a href="#clone_capacity_balance_threshold" class="hash-link" aria-label="Direct link to clone_capacity_balance_threshold" title="Direct link to clone_capacity_balance_threshold">​</a></h4><p>Default: 0.2</p><p>IsMutable：true</p><p>MasterOnly：true</p><ul><li><p>Balance threshold of data size in BE.</p><p> The balance algorithm is:</p><ol><li><p>Calculate the average used capacity(AUC) of the entire cluster. (total data size / total backends num)</p></li><li><p>The high water level is (AUC * (1 + clone_capacity_balance_threshold))</p></li><li><p>The low water level is (AUC * (1 - clone_capacity_balance_threshold))</p></li><li><p>The Clone checker will try to move replica from high water level BE to low water level BE.</p></li></ol></li></ul><h4 class="anchor anchorWithStickyNavbar_LWe7" id="disable_colocate_balance"><code>disable_colocate_balance</code><a href="#disable_colocate_balance" class="hash-link" aria-label="Direct link to disable_colocate_balance" title="Direct link to disable_colocate_balance">​</a></h4><p>Default：false</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>This configs can set to true to disable the automatic colocate tables&#x27;s relocate and balance.  If &#x27;disable_colocate_balance&#x27; is set to true,   ColocateTableBalancer will not relocate and balance colocate tables.</p><p><strong>Attention</strong>:</p><ol><li>Under normal circumstances, there is no need to turn off balance at all.</li><li>Because once the balance is turned off, the unstable colocate table may not be restored</li><li>Eventually the colocate plan cannot be used when querying.</li></ol><h4 class="anchor anchorWithStickyNavbar_LWe7" id="balance_slot_num_per_path"><code>balance_slot_num_per_path</code><a href="#balance_slot_num_per_path" class="hash-link" aria-label="Direct link to balance_slot_num_per_path" title="Direct link to balance_slot_num_per_path">​</a></h4><p>Default: 1</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Default number of slots per path during balance.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="disable_tablet_scheduler"><code>disable_tablet_scheduler</code><a href="#disable_tablet_scheduler" class="hash-link" aria-label="Direct link to disable_tablet_scheduler" title="Direct link to disable_tablet_scheduler">​</a></h4><p>Default:false</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>If set to true, the tablet scheduler will not work, so that all tablet repair/balance task will not work.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_force_drop_redundant_replica"><code>enable_force_drop_redundant_replica</code><a href="#enable_force_drop_redundant_replica" class="hash-link" aria-label="Direct link to enable_force_drop_redundant_replica" title="Direct link to enable_force_drop_redundant_replica">​</a></h4><p>Default: false</p><p>Dynamically configured: true</p><p>Only for Master FE: true</p><p>If set to true, the system will immediately drop redundant replicas in the tablet scheduling logic. This may cause some load jobs that are writing to the corresponding replica to fail, but it will speed up the balance and repair speed of the tablet.
When there are a large number of replicas waiting to be balanced or repaired in the cluster, you can try to set this config to speed up the balance and repair of replicas at the expense of partial load success rate.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="colocate_group_relocate_delay_second"><code>colocate_group_relocate_delay_second</code><a href="#colocate_group_relocate_delay_second" class="hash-link" aria-label="Direct link to colocate_group_relocate_delay_second" title="Direct link to colocate_group_relocate_delay_second">​</a></h4><p>Default: 1800</p><p>Dynamically configured: true</p><p>Only for Master FE: true</p><p>The relocation of a colocation group may involve a large number of tablets moving within the cluster. Therefore, we should use a more conservative strategy to avoid relocation of colocation groups as much as possible.
Reloaction usually occurs after a BE node goes offline or goes down. This parameter is used to delay the determination of BE node unavailability. The default is 30 minutes, i.e., if a BE node recovers within 30 minutes, relocation of the colocation group will not be triggered.</p><p>####<code> allow_replica_on_same_host</code></p><p>Default: false</p><p>Dynamically configured: false</p><p>Only for Master FE: false</p><p>Whether to allow multiple replicas of the same tablet to be distributed on the same host. This parameter is mainly used for local testing, to facilitate building multiple BEs to test certain multi-replica situations. Do not use it for non-test environments.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="repair_slow_replica"><code>repair_slow_replica</code><a href="#repair_slow_replica" class="hash-link" aria-label="Direct link to repair_slow_replica" title="Direct link to repair_slow_replica">​</a></h4><p>Default: false</p><p>IsMutable：true</p><p>MasterOnly: true</p><p>If set to true, the replica with slower compaction will be automatically detected and migrated to other machines. The detection condition is that the version count of the fastest replica exceeds the value of <code>min_version_count_indicate_replica_compaction_too_slow</code>, and the ratio of the version count difference from the fastest replica exceeds the value of <code>valid_version_count_delta_ratio_between_replicas</code></p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="min_version_count_indicate_replica_compaction_too_slow"><code>min_version_count_indicate_replica_compaction_too_slow</code><a href="#min_version_count_indicate_replica_compaction_too_slow" class="hash-link" aria-label="Direct link to min_version_count_indicate_replica_compaction_too_slow" title="Direct link to min_version_count_indicate_replica_compaction_too_slow">​</a></h4><p>Default: 200</p><p>Dynamically configured: true</p><p>Only for Master FE: false</p><p>The version count threshold used to judge whether replica compaction is too slow</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="skip_compaction_slower_replica"><code>skip_compaction_slower_replica</code><a href="#skip_compaction_slower_replica" class="hash-link" aria-label="Direct link to skip_compaction_slower_replica" title="Direct link to skip_compaction_slower_replica">​</a></h4><p>Default: true</p><p>Dynamically configured: true</p><p>Only for Master FE: false</p><p>If set to true, the compaction slower replica will be skipped when select get queryable replicas</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="valid_version_count_delta_ratio_between_replicas"><code>valid_version_count_delta_ratio_between_replicas</code><a href="#valid_version_count_delta_ratio_between_replicas" class="hash-link" aria-label="Direct link to valid_version_count_delta_ratio_between_replicas" title="Direct link to valid_version_count_delta_ratio_between_replicas">​</a></h4><p>Default: 0.5</p><p>Dynamically configured: true</p><p>Only for Master FE: true</p><p>The valid ratio threshold of the difference between the version count of the slowest replica and the fastest replica. If <code>repair_slow_replica</code> is set to true, it is used to determine whether to repair the slowest replica</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="min_bytes_indicate_replica_too_large"><code>min_bytes_indicate_replica_too_large</code><a href="#min_bytes_indicate_replica_too_large" class="hash-link" aria-label="Direct link to min_bytes_indicate_replica_too_large" title="Direct link to min_bytes_indicate_replica_too_large">​</a></h4><p>Default: <code>2 * 1024 * 1024 * 1024</code> (2G)</p><p>Dynamically configured: true</p><p>Only for Master FE: true</p><p>The data size threshold used to judge whether replica is too large</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="schedule_slot_num_per_path"><code>schedule_slot_num_per_path</code><a href="#schedule_slot_num_per_path" class="hash-link" aria-label="Direct link to schedule_slot_num_per_path" title="Direct link to schedule_slot_num_per_path">​</a></h4><p>Default：2</p><p>the default slot number per path in tablet scheduler , remove this config and dynamically adjust it by clone task statistic</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="tablet_repair_delay_factor_second"><code>tablet_repair_delay_factor_second</code><a href="#tablet_repair_delay_factor_second" class="hash-link" aria-label="Direct link to tablet_repair_delay_factor_second" title="Direct link to tablet_repair_delay_factor_second">​</a></h4><p>Default：60 （s）</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>the factor of delay time before deciding to repair tablet.</p><ul><li>if priority is VERY_HIGH, repair it immediately.</li><li>HIGH, delay tablet_repair_delay_factor_second * 1;</li><li>NORMAL: delay tablet_repair_delay_factor_second * 2;</li><li>LOW: delay tablet_repair_delay_factor_second * 3;</li></ul><h4 class="anchor anchorWithStickyNavbar_LWe7" id="tablet_stat_update_interval_second"><code>tablet_stat_update_interval_second</code><a href="#tablet_stat_update_interval_second" class="hash-link" aria-label="Direct link to tablet_stat_update_interval_second" title="Direct link to tablet_stat_update_interval_second">​</a></h4><p>Default：300（5min）</p><p>update interval of tablet stat,
All frontends will get tablet stat from all backends at each interval</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="storage_flood_stage_usage_percent"><code>storage_flood_stage_usage_percent</code><a href="#storage_flood_stage_usage_percent" class="hash-link" aria-label="Direct link to storage_flood_stage_usage_percent" title="Direct link to storage_flood_stage_usage_percent">​</a></h4><p>Default：95 （95%）</p><p>IsMutable：true</p><p>MasterOnly：true</p><h5 class="anchor anchorWithStickyNavbar_LWe7" id="storage_flood_stage_left_capacity_bytes"><code>storage_flood_stage_left_capacity_bytes</code><a href="#storage_flood_stage_left_capacity_bytes" class="hash-link" aria-label="Direct link to storage_flood_stage_left_capacity_bytes" title="Direct link to storage_flood_stage_left_capacity_bytes">​</a></h5><p>Default：1 <em> 1024 </em> 1024 * 1024 (1GB)</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>If capacity of disk reach the &#x27;storage_flood_stage_usage_percent&#x27; and  &#x27;storage_flood_stage_left_capacity_bytes&#x27;, the following operation will be rejected:</p><ol><li>load job</li><li>restore job</li></ol><h4 class="anchor anchorWithStickyNavbar_LWe7" id="storage_high_watermark_usage_percent"><code>storage_high_watermark_usage_percent</code><a href="#storage_high_watermark_usage_percent" class="hash-link" aria-label="Direct link to storage_high_watermark_usage_percent" title="Direct link to storage_high_watermark_usage_percent">​</a></h4><p>Default：85  (85%)</p><p>IsMutable：true</p><p>MasterOnly：true</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="storage_min_left_capacity_bytes"><code>storage_min_left_capacity_bytes</code><a href="#storage_min_left_capacity_bytes" class="hash-link" aria-label="Direct link to storage_min_left_capacity_bytes" title="Direct link to storage_min_left_capacity_bytes">​</a></h4><p>Default： <code>2 * 1024 * 1024 * 1024</code>  (2GB)</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>&#x27;storage_high_watermark_usage_percent&#x27; limit the max capacity usage percent of a Backend storage path.  &#x27;storage_min_left_capacity_bytes&#x27; limit the minimum left capacity of a Backend storage path.  If both limitations are reached, this storage path can not be chose as tablet balance destination. But for tablet recovery, we may exceed these limit for keeping data integrity as much as possible.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="catalog_trash_expire_second"><code>catalog_trash_expire_second</code><a href="#catalog_trash_expire_second" class="hash-link" aria-label="Direct link to catalog_trash_expire_second" title="Direct link to catalog_trash_expire_second">​</a></h4><p>Default: 86400L (1 day)</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>After dropping database(table/partition), you can recover it by using RECOVER stmt. And this specifies the maximal data retention time. After time, the data will be deleted permanently.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="storage_cooldown_second"><code>storage_cooldown_second</code><a href="#storage_cooldown_second" class="hash-link" aria-label="Direct link to storage_cooldown_second" title="Direct link to storage_cooldown_second">​</a></h4><span class="version-mark paragraph"><span class="v-mark"><span class="version-tags"><span class="version-tag"><span class="version-tag-t">Deprecated</span><span class="version-tag-n deprecated">Version <!-- -->2.0</span></span></span></span></span><p>Default：<code>30 * 24 * 3600L</code>  （30 day）</p><p>When create a table(or partition), you can specify its storage medium(HDD or SSD). If set to SSD, this specifies the default duration that tablets will stay on SSD.  After that, tablets will be moved to HDD automatically.  You can set storage cooldown time in CREATE TABLE stmt.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="default_storage_medium"><code>default_storage_medium</code><a href="#default_storage_medium" class="hash-link" aria-label="Direct link to default_storage_medium" title="Direct link to default_storage_medium">​</a></h4><p>Default：HDD</p><p>When create a table(or partition), you can specify its storage medium(HDD or SSD). If not set, this specifies the default medium when creat.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_storage_policy"><code>enable_storage_policy</code><a href="#enable_storage_policy" class="hash-link" aria-label="Direct link to enable_storage_policy" title="Direct link to enable_storage_policy">​</a></h4><ul><li>Whether to enable the Storage Policy feature. This config allows users to separate hot and cold data.
Default: false</li></ul><p>Is it possible to dynamically configure: true</p><p>Is it a configuration item unique to the Master FE node: true</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="check_consistency_default_timeout_second"><code>check_consistency_default_timeout_second</code><a href="#check_consistency_default_timeout_second" class="hash-link" aria-label="Direct link to check_consistency_default_timeout_second" title="Direct link to check_consistency_default_timeout_second">​</a></h4><p>Default: 600 (10 minutes)</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Default timeout of a single consistency check task. Set long enough to fit your tablet size</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="consistency_check_start_time"><code>consistency_check_start_time</code><a href="#consistency_check_start_time" class="hash-link" aria-label="Direct link to consistency_check_start_time" title="Direct link to consistency_check_start_time">​</a></h4><p>Default：23</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Consistency check start time</p><p>Consistency checker will run from <em>consistency_check_start_time</em> to <em>consistency_check_end_time</em>.</p><p>If the two times are the same, no consistency check will be triggered.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="consistency_check_end_time"><code>consistency_check_end_time</code><a href="#consistency_check_end_time" class="hash-link" aria-label="Direct link to consistency_check_end_time" title="Direct link to consistency_check_end_time">​</a></h4><p>Default：23</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Consistency check end time</p><p>Consistency checker will run from <em>consistency_check_start_time</em> to <em>consistency_check_end_time</em>.</p><p>If the two times are the same, no consistency check will be triggered.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="replica_delay_recovery_second"><code>replica_delay_recovery_second</code><a href="#replica_delay_recovery_second" class="hash-link" aria-label="Direct link to replica_delay_recovery_second" title="Direct link to replica_delay_recovery_second">​</a></h4><p>Default：0</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>the minimal delay seconds between a replica is failed and fe try to recovery it using clone.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="tablet_create_timeout_second"><code>tablet_create_timeout_second</code><a href="#tablet_create_timeout_second" class="hash-link" aria-label="Direct link to tablet_create_timeout_second" title="Direct link to tablet_create_timeout_second">​</a></h4><p>Default：1（s）</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Maximal waiting time for creating a single replica.</p><p>eg.
if you create a table with #m tablets and #n replicas for each tablet,
the create table request will run at most (m <em> n </em> tablet_create_timeout_second) before timeout.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="tablet_delete_timeout_second"><code>tablet_delete_timeout_second</code><a href="#tablet_delete_timeout_second" class="hash-link" aria-label="Direct link to tablet_delete_timeout_second" title="Direct link to tablet_delete_timeout_second">​</a></h4><p>Default：2</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Same meaning as <em>tablet_create_timeout_second</em>, but used when delete a tablet.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="alter_table_timeout_second"><code>alter_table_timeout_second</code><a href="#alter_table_timeout_second" class="hash-link" aria-label="Direct link to alter_table_timeout_second" title="Direct link to alter_table_timeout_second">​</a></h4><p>Default: 86400 * 30 (1 month)</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Maximal timeout of ALTER TABLE request. Set long enough to fit your table data size.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_replica_count_when_schema_change"><code>max_replica_count_when_schema_change</code><a href="#max_replica_count_when_schema_change" class="hash-link" aria-label="Direct link to max_replica_count_when_schema_change" title="Direct link to max_replica_count_when_schema_change">​</a></h4><p>The maximum number of replicas allowed when OlapTable is doing schema changes. Too many replicas will lead to FE OOM.</p><p>Default: 100000</p><p>Is it possible to configure dynamically: true</p><p>Whether it is a configuration item unique to the Master FE node: true</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="history_job_keep_max_second"><code>history_job_keep_max_second</code><a href="#history_job_keep_max_second" class="hash-link" aria-label="Direct link to history_job_keep_max_second" title="Direct link to history_job_keep_max_second">​</a></h4><p>Default：<code>7 * 24 * 3600</code> （7 day）</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>The max keep time of some kind of jobs. like schema change job and rollup job.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_create_table_timeout_second"><code>max_create_table_timeout_second</code><a href="#max_create_table_timeout_second" class="hash-link" aria-label="Direct link to max_create_table_timeout_second" title="Direct link to max_create_table_timeout_second">​</a></h4><p>Default：60 （s）</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>In order not to wait too long for create table(index), set a max timeout.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="external-table">External Table<a href="#external-table" class="hash-link" aria-label="Direct link to External Table" title="Direct link to External Table">​</a></h3><h4 class="anchor anchorWithStickyNavbar_LWe7" id="file_scan_node_split_num"><code>file_scan_node_split_num</code><a href="#file_scan_node_split_num" class="hash-link" aria-label="Direct link to file_scan_node_split_num" title="Direct link to file_scan_node_split_num">​</a></h4><p>Default：128</p><p>IsMutable：true</p><p>MasterOnly：false</p><p>multi catalog concurrent file scanning threads</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="file_scan_node_split_size"><code>file_scan_node_split_size</code><a href="#file_scan_node_split_size" class="hash-link" aria-label="Direct link to file_scan_node_split_size" title="Direct link to file_scan_node_split_size">​</a></h4><p>Default：256 <em> 1024 </em> 1024</p><p>IsMutable：true</p><p>MasterOnly：false</p><p>multi catalog concurrent file scan size</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_odbc_table"><code>enable_odbc_table</code><a href="#enable_odbc_table" class="hash-link" aria-label="Direct link to enable_odbc_table" title="Direct link to enable_odbc_table">​</a></h4><p>Default：false</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Whether to enable the ODBC table, it is not enabled by default. You need to manually configure it when you use it.</p><p>This parameter can be set by: ADMIN SET FRONTEND CONFIG(&quot;key&quot;=&quot;value&quot;)</p><p><strong>Note:</strong> This parameter has been deleted in version 1.2. The ODBC External Table is enabled by default, and the ODBC External Table will be deleted in a later version. It is recommended to use the JDBC External Table</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="disable_iceberg_hudi_table"><code>disable_iceberg_hudi_table</code><a href="#disable_iceberg_hudi_table" class="hash-link" aria-label="Direct link to disable_iceberg_hudi_table" title="Direct link to disable_iceberg_hudi_table">​</a></h4><p>Default：true</p><p>IsMutable：true</p><p>MasterOnly：false</p><p>Starting from version 1.2, we no longer support create hudi and iceberg External Table. Please use the multi catalog.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="iceberg_table_creation_interval_second"><code>iceberg_table_creation_interval_second</code><a href="#iceberg_table_creation_interval_second" class="hash-link" aria-label="Direct link to iceberg_table_creation_interval_second" title="Direct link to iceberg_table_creation_interval_second">​</a></h4><p>Default：10 (s)</p><p>IsMutable：true</p><p>MasterOnly：false</p><p>fe will create iceberg table every iceberg_table_creation_interval_second</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="iceberg_table_creation_strict_mode"><code>iceberg_table_creation_strict_mode</code><a href="#iceberg_table_creation_strict_mode" class="hash-link" aria-label="Direct link to iceberg_table_creation_strict_mode" title="Direct link to iceberg_table_creation_strict_mode">​</a></h4><p>Default：true</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>If set to TRUE, the column definitions of iceberg table and the doris table must be consistent
If set to FALSE, Doris only creates columns of supported data types.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_iceberg_table_creation_record_size"><code>max_iceberg_table_creation_record_size</code><a href="#max_iceberg_table_creation_record_size" class="hash-link" aria-label="Direct link to max_iceberg_table_creation_record_size" title="Direct link to max_iceberg_table_creation_record_size">​</a></h4><p>Default max number of recent iceberg database table creation record that can be stored in memory.</p><p>Default：2000</p><p>IsMutable：true</p><p>MasterOnly：true</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_hive_partition_cache_num"><code>max_hive_partition_cache_num</code><a href="#max_hive_partition_cache_num" class="hash-link" aria-label="Direct link to max_hive_partition_cache_num" title="Direct link to max_hive_partition_cache_num">​</a></h4><p>The maximum number of caches for the hive partition.</p><p>Default: 100000</p><p>Is it possible to dynamically configure: false</p><p>Is it a configuration item unique to the Master FE node: false</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="hive_metastore_client_timeout_second"><code>hive_metastore_client_timeout_second</code><a href="#hive_metastore_client_timeout_second" class="hash-link" aria-label="Direct link to hive_metastore_client_timeout_second" title="Direct link to hive_metastore_client_timeout_second">​</a></h4><p>The default connection timeout for hive metastore.</p><p>Default: 10</p><p>Is it possible to dynamically configure: true</p><p>Is it a configuration item unique to the Master FE node: true</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_external_cache_loader_thread_pool_size"><code>max_external_cache_loader_thread_pool_size</code><a href="#max_external_cache_loader_thread_pool_size" class="hash-link" aria-label="Direct link to max_external_cache_loader_thread_pool_size" title="Direct link to max_external_cache_loader_thread_pool_size">​</a></h4><p>Maximum thread pool size for loading external meta cache.</p><p>Default: 10</p><p>Is it possible to dynamically configure: false</p><p>Is it a configuration item unique to the Master FE node: false</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_external_file_cache_num"><code>max_external_file_cache_num</code><a href="#max_external_file_cache_num" class="hash-link" aria-label="Direct link to max_external_file_cache_num" title="Direct link to max_external_file_cache_num">​</a></h4><p>Maximum number of file cache to use for external tables.</p><p>Default: 100000</p><p>Is it possible to dynamically configure: false</p><p>Is it a configuration item unique to the Master FE node: false</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_external_schema_cache_num"><code>max_external_schema_cache_num</code><a href="#max_external_schema_cache_num" class="hash-link" aria-label="Direct link to max_external_schema_cache_num" title="Direct link to max_external_schema_cache_num">​</a></h4><p>Maximum number of schema cache to use for external external tables.</p><p>Default: 10000</p><p>Is it possible to dynamically configure: false</p><p>Is it a configuration item unique to the Master FE node: false</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="external_cache_expire_time_minutes_after_access"><code>external_cache_expire_time_minutes_after_access</code><a href="#external_cache_expire_time_minutes_after_access" class="hash-link" aria-label="Direct link to external_cache_expire_time_minutes_after_access" title="Direct link to external_cache_expire_time_minutes_after_access">​</a></h4><p>Set how long the data in the cache expires after the last access. The unit is minutes.
Applies to External Schema Cache as well as Hive Partition Cache.</p><p>Default: 1440</p><p>Is it possible to dynamically configure: false</p><p>Is it a configuration item unique to the Master FE node: false</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="es_state_sync_interval_second"><code>es_state_sync_interval_second</code><a href="#es_state_sync_interval_second" class="hash-link" aria-label="Direct link to es_state_sync_interval_second" title="Direct link to es_state_sync_interval_second">​</a></h4><p>Default：10</p><p>fe will call es api to get es index shard info every es_state_sync_interval_secs</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="external-resources">External Resources<a href="#external-resources" class="hash-link" aria-label="Direct link to External Resources" title="Direct link to External Resources">​</a></h3><h4 class="anchor anchorWithStickyNavbar_LWe7" id="dpp_hadoop_client_path"><code>dpp_hadoop_client_path</code><a href="#dpp_hadoop_client_path" class="hash-link" aria-label="Direct link to dpp_hadoop_client_path" title="Direct link to dpp_hadoop_client_path">​</a></h4><p>Default：/lib/hadoop-client/hadoop/bin/hadoop</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="dpp_bytes_per_reduce"><code>dpp_bytes_per_reduce</code><a href="#dpp_bytes_per_reduce" class="hash-link" aria-label="Direct link to dpp_bytes_per_reduce" title="Direct link to dpp_bytes_per_reduce">​</a></h4><p>Default：<code>100 * 1024 * 1024L</code> (100M)</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="dpp_default_cluster"><code>dpp_default_cluster</code><a href="#dpp_default_cluster" class="hash-link" aria-label="Direct link to dpp_default_cluster" title="Direct link to dpp_default_cluster">​</a></h4><p>Default：palo-dpp</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="dpp_default_config_str"><code>dpp_default_config_str</code><a href="#dpp_default_config_str" class="hash-link" aria-label="Direct link to dpp_default_config_str" title="Direct link to dpp_default_config_str">​</a></h4><p>Default：{
hadoop_configs : &#x27;mapred.job.priority=NORMAL;mapred.job.map.capacity=50;mapred.job.reduce.capacity=50;mapred.hce.replace.streaming=false;abaci.long.stored.job=true;dce.shuffle.enable=false;dfs.client.authserver.force_stop=true;dfs.client.auth.method=0&#x27;
}</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="dpp_config_str"><code>dpp_config_str</code><a href="#dpp_config_str" class="hash-link" aria-label="Direct link to dpp_config_str" title="Direct link to dpp_config_str">​</a></h4><p>Default：{
palo-dpp : {
hadoop_palo_path : &#x27;/dir&#x27;,
hadoop_configs : &#x27;fs.default.name=hdfs://host:port;mapred.job.tracker=host:port;hadoop.job.ugi=user,password&#x27;
}
}</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="yarn_config_dir"><code>yarn_config_dir</code><a href="#yarn_config_dir" class="hash-link" aria-label="Direct link to yarn_config_dir" title="Direct link to yarn_config_dir">​</a></h4><p>Default: DorisFE.DORIS_HOME_DIR + &quot;/lib/yarn-config&quot;</p><p>Default yarn config file directory , Each time before running the yarn command, we need to check that the  config file exists under this path, and if not, create them.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="yarn_client_path"><code>yarn_client_path</code><a href="#yarn_client_path" class="hash-link" aria-label="Direct link to yarn_client_path" title="Direct link to yarn_client_path">​</a></h4><p>Default：DORIS_HOME_DIR + &quot;/lib/yarn-client/hadoop/bin/yarn&quot;</p><p>Default yarn client path</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="spark_launcher_log_dir"><code>spark_launcher_log_dir</code><a href="#spark_launcher_log_dir" class="hash-link" aria-label="Direct link to spark_launcher_log_dir" title="Direct link to spark_launcher_log_dir">​</a></h4><p>Default： sys_log_dir + &quot;/spark_launcher_log&quot;</p><p>The specified spark launcher log dir</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="spark_resource_path"><code>spark_resource_path</code><a href="#spark_resource_path" class="hash-link" aria-label="Direct link to spark_resource_path" title="Direct link to spark_resource_path">​</a></h4><p>Default：none</p><p>Default spark dependencies path</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="spark_home_default_dir"><code>spark_home_default_dir</code><a href="#spark_home_default_dir" class="hash-link" aria-label="Direct link to spark_home_default_dir" title="Direct link to spark_home_default_dir">​</a></h4><p>Default：DORIS_HOME_DIR + &quot;/lib/spark2x&quot;</p><p>Default spark home dir</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="spark_dpp_version"><code>spark_dpp_version</code><a href="#spark_dpp_version" class="hash-link" aria-label="Direct link to spark_dpp_version" title="Direct link to spark_dpp_version">​</a></h4><p>Default: 1.0.0</p><p>Default spark dpp version</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="else">Else<a href="#else" class="hash-link" aria-label="Direct link to Else" title="Direct link to Else">​</a></h3><h4 class="anchor anchorWithStickyNavbar_LWe7" id="tmp_dir"><code>tmp_dir</code><a href="#tmp_dir" class="hash-link" aria-label="Direct link to tmp_dir" title="Direct link to tmp_dir">​</a></h4><p>Default: DorisFE.DORIS_HOME_DIR + &quot;/temp_dir&quot;</p><p>temp dir is used to save intermediate results of some process, such as backup and restore process.  file in this dir will be cleaned after these process is finished.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="custom_config_dir"><code>custom_config_dir</code><a href="#custom_config_dir" class="hash-link" aria-label="Direct link to custom_config_dir" title="Direct link to custom_config_dir">​</a></h4><p>Default: DorisFE.DORIS_HOME_DIR + &quot;/conf&quot;</p><p>Custom configuration file directory</p><p>Configure the location of the <code>fe_custom.conf</code> file. The default is in the <code>conf/</code> directory.</p><p>In some deployment environments, the <code>conf/</code> directory may be overwritten due to system upgrades. This will cause the user modified configuration items to be overwritten. At this time, we can store <code>fe_custom.conf</code> in another specified directory to prevent the configuration file from being overwritten.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="plugin_dir"><code>plugin_dir</code><a href="#plugin_dir" class="hash-link" aria-label="Direct link to plugin_dir" title="Direct link to plugin_dir">​</a></h4><p>Default：DORIS_HOME + &quot;/plugins</p><p>plugin install directory</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="plugin_enable"><code>plugin_enable</code><a href="#plugin_enable" class="hash-link" aria-label="Direct link to plugin_enable" title="Direct link to plugin_enable">​</a></h4><p>Default:true</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Whether the plug-in is enabled, enabled by default</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="small_file_dir"><code>small_file_dir</code><a href="#small_file_dir" class="hash-link" aria-label="Direct link to small_file_dir" title="Direct link to small_file_dir">​</a></h4><p>Default：DORIS_HOME_DIR/small_files</p><p>Save small files</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_small_file_size_bytes"><code>max_small_file_size_bytes</code><a href="#max_small_file_size_bytes" class="hash-link" aria-label="Direct link to max_small_file_size_bytes" title="Direct link to max_small_file_size_bytes">​</a></h4><p>Default：1M</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>The max size of a single file store in SmallFileMgr</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_small_file_number"><code>max_small_file_number</code><a href="#max_small_file_number" class="hash-link" aria-label="Direct link to max_small_file_number" title="Direct link to max_small_file_number">​</a></h4><p>Default：100</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>The max number of files store in SmallFileMgr</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_metric_calculator"><code>enable_metric_calculator</code><a href="#enable_metric_calculator" class="hash-link" aria-label="Direct link to enable_metric_calculator" title="Direct link to enable_metric_calculator">​</a></h4><p>Default：true</p><p>If set to true, metric collector will be run as a daemon timer to collect metrics at fix interval</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="report_queue_size"><code>report_queue_size</code><a href="#report_queue_size" class="hash-link" aria-label="Direct link to report_queue_size" title="Direct link to report_queue_size">​</a></h4><p>Default： 100</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>This threshold is to avoid piling up too many report task in FE, which may cause OOM exception.  In some large Doris cluster, eg: 100 Backends with ten million replicas, a tablet report may cost  several seconds after some modification of metadata(drop partition, etc..). And one Backend will report tablets info every 1 min, so unlimited receiving reports is unacceptable. we will optimize the processing speed of tablet report in future, but now, just discard the report if queue size exceeding limit.
Some online time cost:</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#F8F8F2;--prism-background-color:#282A36"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#F8F8F2"><span class="token plain">  1. disk report: 0-1 msta</span><br></span><span class="token-line" style="color:#F8F8F2"><span class="token plain">  2. sk report: 0-1 ms</span><br></span><span class="token-line" style="color:#F8F8F2"><span class="token plain">  3. tablet report</span><br></span><span class="token-line" style="color:#F8F8F2"><span class="token plain">  4. 10000 replicas: 200ms</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg viewBox="0 0 24 24" class="copyButtonIcon_y97N"><path fill="currentColor" d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg viewBox="0 0 24 24" class="copyButtonSuccessIcon_LjdS"><path fill="currentColor" d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><h4 class="anchor anchorWithStickyNavbar_LWe7" id="backup_job_default_timeout_ms"><code>backup_job_default_timeout_ms</code><a href="#backup_job_default_timeout_ms" class="hash-link" aria-label="Direct link to backup_job_default_timeout_ms" title="Direct link to backup_job_default_timeout_ms">​</a></h4><p>Default: 86400 * 1000  (1 day)</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>default timeout of backup job</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_backup_restore_job_num_per_db"><code>max_backup_restore_job_num_per_db</code><a href="#max_backup_restore_job_num_per_db" class="hash-link" aria-label="Direct link to max_backup_restore_job_num_per_db" title="Direct link to max_backup_restore_job_num_per_db">​</a></h4><p>Default: 10</p><p>This configuration is mainly used to control the number of backup/restore tasks recorded in each database.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_quantile_state_type"><code>enable_quantile_state_type</code><a href="#enable_quantile_state_type" class="hash-link" aria-label="Direct link to enable_quantile_state_type" title="Direct link to enable_quantile_state_type">​</a></h4><p>Default：false</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Whether to enable the quantile_state data type</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_date_conversion"><code>enable_date_conversion</code><a href="#enable_date_conversion" class="hash-link" aria-label="Direct link to enable_date_conversion" title="Direct link to enable_date_conversion">​</a></h4><p>Default：true</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>FE will convert date/datetime to datev2/datetimev2(0) automatically.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_decimal_conversion"><code>enable_decimal_conversion</code><a href="#enable_decimal_conversion" class="hash-link" aria-label="Direct link to enable_decimal_conversion" title="Direct link to enable_decimal_conversion">​</a></h4><p>Default：true</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>FE will convert DecimalV2 to DecimalV3 automatically.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="proxy_auth_magic_prefix"><code>proxy_auth_magic_prefix</code><a href="#proxy_auth_magic_prefix" class="hash-link" aria-label="Direct link to proxy_auth_magic_prefix" title="Direct link to proxy_auth_magic_prefix">​</a></h4><p>Default：x@8</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="proxy_auth_enable"><code>proxy_auth_enable</code><a href="#proxy_auth_enable" class="hash-link" aria-label="Direct link to proxy_auth_enable" title="Direct link to proxy_auth_enable">​</a></h4><p>Default：false</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_func_pushdown"><code>enable_func_pushdown</code><a href="#enable_func_pushdown" class="hash-link" aria-label="Direct link to enable_func_pushdown" title="Direct link to enable_func_pushdown">​</a></h4><p>Default：true</p><p>IsMutable：true</p><p>MasterOnly：false</p><p>Whether to push the filter conditions with functions down to MYSQL, when exectue query of ODBC, JDBC external tables</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="jdbc_drivers_dir"><code>jdbc_drivers_dir</code><a href="#jdbc_drivers_dir" class="hash-link" aria-label="Direct link to jdbc_drivers_dir" title="Direct link to jdbc_drivers_dir">​</a></h4><p>Default: <code>${DORIS_HOME}/jdbc_drivers</code>;</p><p>IsMutable：false</p><p>MasterOnly：false</p><p>The default dir to put jdbc drivers.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_error_tablet_of_broker_load"><code>max_error_tablet_of_broker_load</code><a href="#max_error_tablet_of_broker_load" class="hash-link" aria-label="Direct link to max_error_tablet_of_broker_load" title="Direct link to max_error_tablet_of_broker_load">​</a></h4><p>Default: 3;</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Maximum number of error tablet showed in broker load.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="default_db_max_running_txn_num"><code>default_db_max_running_txn_num</code><a href="#default_db_max_running_txn_num" class="hash-link" aria-label="Direct link to default_db_max_running_txn_num" title="Direct link to default_db_max_running_txn_num">​</a></h4><p>Default：-1</p><p>IsMutable：true</p><p>MasterOnly：true</p><p>Used to set the default database transaction quota size.</p><p>The default value setting to -1 means using <code>max_running_txn_num_per_db</code> instead of <code>default_db_max_running_txn_num</code>.</p><p>To set the quota size of a single database, you can use:</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#F8F8F2;--prism-background-color:#282A36"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#F8F8F2"><span class="token plain">Set the database transaction quota</span><br></span><span class="token-line" style="color:#F8F8F2"><span class="token plain">ALTER DATABASE db_name SET TRANSACTION QUOTA quota;</span><br></span><span class="token-line" style="color:#F8F8F2"><span class="token plain">View configuration</span><br></span><span class="token-line" style="color:#F8F8F2"><span class="token plain">show data （Detail：HELP SHOW DATA）</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg viewBox="0 0 24 24" class="copyButtonIcon_y97N"><path fill="currentColor" d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg viewBox="0 0 24 24" class="copyButtonSuccessIcon_LjdS"><path fill="currentColor" d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><h4 class="anchor anchorWithStickyNavbar_LWe7" id="prefer_compute_node_for_external_table"><code>prefer_compute_node_for_external_table</code><a href="#prefer_compute_node_for_external_table" class="hash-link" aria-label="Direct link to prefer_compute_node_for_external_table" title="Direct link to prefer_compute_node_for_external_table">​</a></h4><p>Default：false</p><p>IsMutable：true</p><p>MasterOnly：false</p><p>If set to true, query on external table will prefer to assign to compute node. And the max number of compute node is controlled by <code>min_backend_num_for_external_table</code>.
If set to false, query on external table will assign to any node.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="min_backend_num_for_external_table"><code>min_backend_num_for_external_table</code><a href="#min_backend_num_for_external_table" class="hash-link" aria-label="Direct link to min_backend_num_for_external_table" title="Direct link to min_backend_num_for_external_table">​</a></h4><p>Default：3</p><p>IsMutable：true</p><p>MasterOnly：false</p><p>Only take effect when <code>prefer_compute_node_for_external_table</code> is true. If the compute node number is less than this value, query on external table will try to get some mix node to assign, to let the total number of node reach this value.
If the compute node number is larger than this value, query on external table will assign to compute node only.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="infodb_support_ext_catalog"><code>infodb_support_ext_catalog</code><a href="#infodb_support_ext_catalog" class="hash-link" aria-label="Direct link to infodb_support_ext_catalog" title="Direct link to infodb_support_ext_catalog">​</a></h4><span class="version-mark paragraph"><span class="v-mark"><span class="version-tags"><span class="version-tag"><span class="version-tag-t">Since</span><span class="version-tag-n since">Version <!-- -->1.2.4</span></span></span></span></span><p>Default: false</p><p>IsMutable: true</p><p>MasterOnly: false</p><p>If false, when select from tables in information_schema database,
the result will not contain the information of the table in external catalog.
This is to avoid query time when external catalog is not reachable.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_query_hit_stats"><code>enable_query_hit_stats</code><a href="#enable_query_hit_stats" class="hash-link" aria-label="Direct link to enable_query_hit_stats" title="Direct link to enable_query_hit_stats">​</a></h4><span class="version-mark paragraph"><span class="v-mark"><span class="version-tags"><span class="version-tag"><span class="version-tag-t">Since</span><span class="version-tag-n since">Version <!-- -->dev</span></span></span></span></span><p>Default: false</p><p>IsMutable: true</p><p>MasterOnly: false</p><p>Controls whether to enable query hit statistics. The default is false.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="div_precision_increment"><code>div_precision_increment</code><a href="#div_precision_increment" class="hash-link" aria-label="Direct link to div_precision_increment" title="Direct link to div_precision_increment">​</a></h4><span class="version-mark paragraph"><span class="v-mark"><span class="version-tags"><span class="version-tag"><span class="version-tag-t">Since</span><span class="version-tag-n since">Version <!-- -->dev</span></span></span></span></span><p>Default: 4</p><p>This variable indicates the number of digits by which to increase the scale of the result of
division operations performed with the <code>/</code> operator.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="enable_convert_light_weight_schema_change"><code>enable_convert_light_weight_schema_change</code><a href="#enable_convert_light_weight_schema_change" class="hash-link" aria-label="Direct link to enable_convert_light_weight_schema_change" title="Direct link to enable_convert_light_weight_schema_change">​</a></h4><p>Default：true</p><p>Temporary configuration option. After it is enabled, a background thread will be started to automatically modify all olap tables to light schema change. The modification results can be viewed through the command <code>show convert_light_schema_change [from db]</code>, and the conversion results of all non-light schema change tables will be displayed.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="disable_local_deploy_manager_drop_node"><code>disable_local_deploy_manager_drop_node</code><a href="#disable_local_deploy_manager_drop_node" class="hash-link" aria-label="Direct link to disable_local_deploy_manager_drop_node" title="Direct link to disable_local_deploy_manager_drop_node">​</a></h4><p>Default：true</p><p>Forbid LocalDeployManager drop nodes to prevent errors in the cluster.info file from causing nodes to be dropped.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="mysqldb_replace_name"><code>mysqldb_replace_name</code><a href="#mysqldb_replace_name" class="hash-link" aria-label="Direct link to mysqldb_replace_name" title="Direct link to mysqldb_replace_name">​</a></h4><p>Default: mysql</p><p>To ensure compatibility with the MySQL ecosystem, Doris includes a built-in database called mysql. If this database conflicts with a user&#x27;s own database, please modify this field to replace the name of the Doris built-in MySQL database with a different name.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="max_auto_partition_num"><code>max_auto_partition_num</code><a href="#max_auto_partition_num" class="hash-link" aria-label="Direct link to max_auto_partition_num" title="Direct link to max_auto_partition_num">​</a></h4><p>Default value: 2000</p><p>For auto-partitioned tables to prevent users from accidentally creating a large number of partitions, the number of partitions allowed per OLAP table is <code>max_auto_partition_num</code>. Default 2000.</p></div></article><nav class="pagination-nav docusaurus-mt-lg" aria-label="Docs pages"><a class="pagination-nav__link pagination-nav__link--prev" href="/docs/2.0/admin-manual/config/config-dir"><div class="pagination-nav__sublabel">Previous</div><div class="pagination-nav__label">Config Dir</div></a><a class="pagination-nav__link pagination-nav__link--next" href="/docs/2.0/admin-manual/config/be-config"><div class="pagination-nav__sublabel">Next</div><div class="pagination-nav__label">BE Configuration</div></a></nav></div></div><div class="col col--3"><div class="tableOfContents_jeP5 thin-scrollbar theme-doc-toc-desktop"><a href="https://github.com/apache/doris/discussions" target="_blank" rel="noopener noreferrer" class="ml-4 mb-8 flex items-center hover:no-underline"><span class="pr-2">Join Discussion</span><svg viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="8500" id="mx_n_1711090272569" width="16" height="16"><path d="M522.24 896.512c-25.6 4.608-51.712 7.168-78.336 7.168-79.36 0-157.696-21.504-225.792-62.464l-18.432-10.752-103.936 28.16c-28.672 7.68-54.784-18.432-47.104-47.104l28.16-103.936c-10.752-17.92-17.408-30.208-20.992-36.864C20.992 607.232 3.072 536.064 3.584 463.36c0-243.2 197.12-440.32 440.32-440.32 221.696 0 405.504 164.352 435.712 377.856 90.112 55.808 144.896 154.112 144.896 260.096 0 51.2-12.8 100.352-36.352 144.384-2.048 4.096-6.144 10.752-11.776 20.48l17.408 64c7.68 28.672-18.432 54.784-47.104 47.104l-64-17.408-7.68 4.608c-47.616 28.672-101.888 43.52-157.184 43.52-71.68-0.512-140.8-25.088-195.584-71.168z m95.232-28.672c31.232 15.36 65.536 23.04 100.352 23.04 41.472 0 82.432-11.264 117.76-32.768 2.56-1.536 9.728-5.632 22.016-12.8 8.704-5.12 19.456-6.656 29.184-3.584l14.848 4.096-4.096-14.848c-2.56-10.24-1.536-20.48 4.096-29.696 6.144-10.24 12.288-20.992 18.432-31.232 17.92-33.28 27.136-70.656 27.136-108.544 0-59.904-23.552-117.76-65.536-160.256-13.312 164.352-118.272 303.616-264.192 366.592z m-462.848-155.648l-14.848 54.784 54.784-14.848c9.728-2.56 20.48-1.536 29.184 4.096 18.432 10.752 29.184 16.896 32.768 19.456 56.32 33.792 120.832 51.712 186.88 51.712 200.704 0 363.52-162.816 363.52-363.52s-162.816-363.52-363.52-363.52-363.52 162.816-363.52 363.52c0 60.928 14.848 119.296 43.008 171.52 3.584 7.168 13.312 23.04 27.648 47.616 5.632 8.704 6.656 19.456 4.096 29.184z m448.512-382.976c20.992 0 38.4 16.896 38.4 38.4 0 20.992-16.896 38.4-38.4 38.4H284.16c-20.992 0-38.4-16.896-38.4-38.4 0-20.992 16.896-38.4 38.4-38.4h318.976z m-153.088 191.488c20.992 0 38.4 16.896 38.4 38.4 0 20.992-16.896 38.4-38.4 38.4H284.16c-20.992 0-38.4-16.896-38.4-38.4 0-20.992 16.896-38.4 38.4-38.4h165.888z m0 0" p-id="8501" fill="currentColor"></path></svg></a><span class="ml-4">On This Page</span><ul class="table-of-contents table-of-contents__left-border"><li><a href="#view-configuration-items" class="table-of-contents__link toc-highlight">View configuration items</a></li><li><a href="#set-configuration-items" class="table-of-contents__link toc-highlight">Set configuration items</a></li><li><a href="#examples" class="table-of-contents__link toc-highlight">Examples</a></li><li><a href="#configurations" class="table-of-contents__link toc-highlight">Configurations</a><ul><li><a href="#metadata-and-cluster" class="table-of-contents__link toc-highlight">Metadata And Cluster</a><ul><li><a href="#meta_dir" class="table-of-contents__link toc-highlight"><code>meta_dir</code></a></li><li><a href="#catalog_try_lock_timeout_ms" class="table-of-contents__link toc-highlight"><code>catalog_try_lock_timeout_ms</code></a></li><li><a href="#enable_bdbje_debug_mode" class="table-of-contents__link toc-highlight"><code>enable_bdbje_debug_mode</code></a></li><li><a href="#max_bdbje_clock_delta_ms" class="table-of-contents__link toc-highlight"><code>max_bdbje_clock_delta_ms</code></a></li><li><a href="#metadata_failure_recovery" class="table-of-contents__link toc-highlight"><code>metadata_failure_recovery</code></a></li><li><a href="#txn_rollback_limit" class="table-of-contents__link toc-highlight"><code>txn_rollback_limit</code></a></li><li><a href="#grpc_threadmgr_threads_nums" class="table-of-contents__link toc-highlight"><code>grpc_threadmgr_threads_nums</code></a></li><li><a href="#bdbje_replica_ack_timeout_second" class="table-of-contents__link toc-highlight"><code>bdbje_replica_ack_timeout_second</code></a></li><li><a href="#bdbje_lock_timeout_second" class="table-of-contents__link toc-highlight"><code>bdbje_lock_timeout_second</code></a></li><li><a href="#bdbje_heartbeat_timeout_second" class="table-of-contents__link toc-highlight"><code>bdbje_heartbeat_timeout_second</code></a></li><li><a href="#replica_ack_policy" class="table-of-contents__link toc-highlight"><code>replica_ack_policy</code></a></li><li><a href="#replica_sync_policy" class="table-of-contents__link toc-highlight"><code>replica_sync_policy</code></a></li><li><a href="#master_sync_policy" class="table-of-contents__link toc-highlight"><code>master_sync_policy</code></a></li><li><a href="#bdbje_reserved_disk_bytes" class="table-of-contents__link toc-highlight"><code>bdbje_reserved_disk_bytes</code></a></li><li><a href="#ignore_meta_check" class="table-of-contents__link toc-highlight"><code>ignore_meta_check</code></a></li><li><a href="#meta_delay_toleration_second" class="table-of-contents__link toc-highlight"><code>meta_delay_toleration_second</code></a></li><li><a href="#edit_log_port" class="table-of-contents__link toc-highlight"><code>edit_log_port</code></a></li><li><a href="#edit_log_type" class="table-of-contents__link toc-highlight"><code>edit_log_type</code></a></li><li><a href="#edit_log_roll_num" class="table-of-contents__link toc-highlight"><code>edit_log_roll_num</code></a></li><li><a href="#force_do_metadata_checkpoint" class="table-of-contents__link toc-highlight"><code>force_do_metadata_checkpoint</code></a></li><li><a href="#metadata_checkpoint_memory_threshold" class="table-of-contents__link toc-highlight"><code>metadata_checkpoint_memory_threshold</code></a></li><li><a href="#max_same_name_catalog_trash_num" class="table-of-contents__link toc-highlight"><code>max_same_name_catalog_trash_num</code></a></li><li><a href="#cluster_id" class="table-of-contents__link toc-highlight"><code>cluster_id</code></a></li><li><a href="#heartbeat_mgr_blocking_queue_size" class="table-of-contents__link toc-highlight"><code>heartbeat_mgr_blocking_queue_size</code></a></li><li><a href="#heartbeat_mgr_threads_num" class="table-of-contents__link toc-highlight"><code>heartbeat_mgr_threads_num</code></a></li><li><a href="#disable_cluster_feature" class="table-of-contents__link toc-highlight"><code>disable_cluster_feature</code></a></li><li><a href="#enable_deploy_manager" class="table-of-contents__link toc-highlight"><code>enable_deploy_manager</code></a></li><li><a href="#with_k8s_certs" class="table-of-contents__link toc-highlight"><code>with_k8s_certs</code></a></li><li><a href="#enable_fqdn_mode" class="table-of-contents__link toc-highlight"><code>enable_fqdn_mode</code></a></li><li><a href="#enable_token_check" class="table-of-contents__link toc-highlight"><code>enable_token_check</code></a></li><li><a href="#enable_multi_tags" class="table-of-contents__link toc-highlight"><code>enable_multi_tags</code></a></li><li><a href="#initial_root_password" class="table-of-contents__link toc-highlight"><code>initial_root_password</code></a></li></ul></li><li><a href="#service" class="table-of-contents__link toc-highlight">Service</a><ul><li><a href="#query_port" class="table-of-contents__link toc-highlight"><code>query_port</code></a></li><li><a href="#arrow_flight_sql_port" class="table-of-contents__link toc-highlight"><code>arrow_flight_sql_port</code></a></li><li><a href="#frontend_address" class="table-of-contents__link toc-highlight"><code>frontend_address</code></a></li><li><a href="#priority_networks" class="table-of-contents__link toc-highlight"><code>priority_networks</code></a></li><li><a href="#http_port" class="table-of-contents__link toc-highlight"><code>http_port</code></a></li><li><a href="#https_port" class="table-of-contents__link toc-highlight"><code>https_port</code></a></li><li><a href="#enable_https" class="table-of-contents__link toc-highlight"><code>enable_https</code></a></li><li><a href="#enable_ssl" class="table-of-contents__link toc-highlight"><code>enable_ssl</code></a></li><li><a href="#qe_max_connection" class="table-of-contents__link toc-highlight"><code>qe_max_connection</code></a></li><li><a href="#check_java_version" class="table-of-contents__link toc-highlight"><code>check_java_version</code></a></li><li><a href="#rpc_port" class="table-of-contents__link toc-highlight"><code>rpc_port</code></a></li><li><a href="#thrift_server_type" class="table-of-contents__link toc-highlight"><code>thrift_server_type</code></a></li><li><a href="#thrift_server_max_worker_threads" class="table-of-contents__link toc-highlight"><code>thrift_server_max_worker_threads</code></a></li><li><a href="#thrift_backlog_num" class="table-of-contents__link toc-highlight"><code>thrift_backlog_num</code></a></li><li><a href="#thrift_client_timeout_ms" class="table-of-contents__link toc-highlight"><code>thrift_client_timeout_ms</code></a></li><li><a href="#thrift_max_message_size" class="table-of-contents__link toc-highlight"><code>thrift_max_message_size</code></a></li><li><a href="#use_compact_thrift_rpc" class="table-of-contents__link toc-highlight"><code>use_compact_thrift_rpc</code></a></li><li><a href="#grpc_max_message_size_bytes" class="table-of-contents__link toc-highlight"><code>grpc_max_message_size_bytes</code></a></li><li><a href="#max_mysql_service_task_threads_num" class="table-of-contents__link toc-highlight"><code>max_mysql_service_task_threads_num</code></a></li><li><a href="#mysql_service_io_threads_num" class="table-of-contents__link toc-highlight"><code>mysql_service_io_threads_num</code></a></li><li><a href="#mysql_nio_backlog_num" class="table-of-contents__link toc-highlight"><code>mysql_nio_backlog_num</code></a></li><li><a href="#broker_timeout_ms" class="table-of-contents__link toc-highlight"><code>broker_timeout_ms</code></a></li><li><a href="#backend_rpc_timeout_ms" class="table-of-contents__link toc-highlight"><code>backend_rpc_timeout_ms</code></a></li><li><a href="#drop_backend_after_decommission" class="table-of-contents__link toc-highlight"><code>drop_backend_after_decommission</code></a></li><li><a href="#max_backend_down_time_second" class="table-of-contents__link toc-highlight"><code>max_backend_down_time_second</code></a></li><li><a href="#disable_backend_black_list" class="table-of-contents__link toc-highlight"><code>disable_backend_black_list</code></a></li><li><a href="#max_backend_heartbeat_failure_tolerance_count" class="table-of-contents__link toc-highlight"><code>max_backend_heartbeat_failure_tolerance_count</code></a></li><li><a href="#enable_access_file_without_broker" class="table-of-contents__link toc-highlight"><code>enable_access_file_without_broker</code></a></li><li><a href="#agent_task_resend_wait_time_ms" class="table-of-contents__link toc-highlight"><code>agent_task_resend_wait_time_ms</code></a></li><li><a href="#max_agent_task_threads_num" class="table-of-contents__link toc-highlight"><code>max_agent_task_threads_num</code></a></li><li><a href="#remote_fragment_exec_timeout_ms" class="table-of-contents__link toc-highlight"><code>remote_fragment_exec_timeout_ms</code></a></li><li><a href="#auth_token" class="table-of-contents__link toc-highlight"><code>auth_token</code></a></li><li><a href="#enable_http_server_v2" class="table-of-contents__link toc-highlight"><code>enable_http_server_v2</code></a></li><li><a href="#http_api_extra_base_path" class="table-of-contents__link toc-highlight"><code>http_api_extra_base_path</code></a></li><li><a href="#jetty_server_acceptors" class="table-of-contents__link toc-highlight"><code>jetty_server_acceptors</code></a></li><li><a href="#jetty_server_selectors" class="table-of-contents__link toc-highlight"><code>jetty_server_selectors</code></a></li><li><a href="#jetty_server_workers" class="table-of-contents__link toc-highlight"><code>jetty_server_workers</code></a></li><li><a href="#jetty_server_max_http_post_size" class="table-of-contents__link toc-highlight"><code>jetty_server_max_http_post_size</code></a></li><li><a href="#jetty_server_max_http_header_size" class="table-of-contents__link toc-highlight"><code>jetty_server_max_http_header_size</code></a></li><li><a href="#http_sql_submitter_max_worker_threads" class="table-of-contents__link toc-highlight"><code>http_sql_submitter_max_worker_threads</code></a></li><li><a href="#http_load_submitter_max_worker_threads" class="table-of-contents__link toc-highlight"><code>http_load_submitter_max_worker_threads</code></a></li></ul></li><li><a href="#query-engine" class="table-of-contents__link toc-highlight">Query Engine</a><ul><li><a href="#default_max_query_instances" class="table-of-contents__link toc-highlight"><code>default_max_query_instances</code></a></li><li><a href="#max_query_retry_time" class="table-of-contents__link toc-highlight"><code>max_query_retry_time</code></a></li><li><a href="#max_dynamic_partition_num" class="table-of-contents__link toc-highlight"><code>max_dynamic_partition_num</code></a></li><li><a href="#dynamic_partition_enable" class="table-of-contents__link toc-highlight"><code>dynamic_partition_enable</code></a></li><li><a href="#dynamic_partition_check_interval_seconds" class="table-of-contents__link toc-highlight"><code>dynamic_partition_check_interval_seconds</code></a></li><li><a href="#max_multi_partition_num" class="table-of-contents__link toc-highlight"><code>max_multi_partition_num</code></a></li><li><a href="#multi_partition_name_prefix" class="table-of-contents__link toc-highlight"><code>multi_partition_name_prefix</code></a></li><li><a href="#partition_in_memory_update_interval_secs" class="table-of-contents__link toc-highlight"><code>partition_in_memory_update_interval_secs</code></a></li><li><a href="#enable_concurrent_update" class="table-of-contents__link toc-highlight"><code>enable_concurrent_update</code></a></li><li><a href="#lower_case_table_names" class="table-of-contents__link toc-highlight"><code>lower_case_table_names</code></a></li><li><a href="#table_name_length_limit" class="table-of-contents__link toc-highlight"><code>table_name_length_limit</code></a></li><li><a href="#cache_enable_sql_mode" class="table-of-contents__link toc-highlight"><code>cache_enable_sql_mode</code></a></li><li><a href="#cache_enable_partition_mode" class="table-of-contents__link toc-highlight"><code>cache_enable_partition_mode</code></a></li><li><a href="#cache_result_max_row_count" class="table-of-contents__link toc-highlight"><code>cache_result_max_row_count</code></a></li><li><a href="#cache_result_max_data_size" class="table-of-contents__link toc-highlight"><code>cache_result_max_data_size</code></a></li><li><a href="#cache_last_version_interval_second" class="table-of-contents__link toc-highlight"><code>cache_last_version_interval_second</code></a></li><li><a href="#enable_batch_delete_by_default" class="table-of-contents__link toc-highlight"><code>enable_batch_delete_by_default</code></a></li><li><a href="#max_allowed_in_element_num_of_delete" class="table-of-contents__link toc-highlight"><code>max_allowed_in_element_num_of_delete</code></a></li><li><a href="#max_running_rollup_job_num_per_table" class="table-of-contents__link toc-highlight"><code>max_running_rollup_job_num_per_table</code></a></li><li><a href="#max_distribution_pruner_recursion_depth" class="table-of-contents__link toc-highlight"><code>max_distribution_pruner_recursion_depth</code></a></li><li><a href="#enable_local_replica_selection" class="table-of-contents__link toc-highlight"><code>enable_local_replica_selection</code></a></li><li><a href="#enable_local_replica_selection_fallback" class="table-of-contents__link toc-highlight"><code>enable_local_replica_selection_fallback</code></a></li><li><a href="#expr_depth_limit" class="table-of-contents__link toc-highlight"><code>expr_depth_limit</code></a></li><li><a href="#expr_children_limit" class="table-of-contents__link toc-highlight"><code>expr_children_limit</code></a></li><li><a href="#be_exec_version" class="table-of-contents__link toc-highlight"><code>be_exec_version</code></a></li><li><a href="#max_be_exec_version" class="table-of-contents__link toc-highlight"><code>max_be_exec_version</code></a></li><li><a href="#min_be_exec_version" class="table-of-contents__link toc-highlight"><code>min_be_exec_version</code></a></li><li><a href="#max_query_profile_num" class="table-of-contents__link toc-highlight"><code>max_query_profile_num</code></a></li><li><a href="#publish_version_interval_ms" class="table-of-contents__link toc-highlight"><code>publish_version_interval_ms</code></a></li><li><a href="#publish_version_timeout_second" class="table-of-contents__link toc-highlight"><code>publish_version_timeout_second</code></a></li><li><a href="#query_colocate_join_memory_limit_penalty_factor" class="table-of-contents__link toc-highlight"><code>query_colocate_join_memory_limit_penalty_factor</code></a></li><li><a href="#rewrite_count_distinct_to_bitmap_hll" class="table-of-contents__link toc-highlight"><code>rewrite_count_distinct_to_bitmap_hll</code></a></li></ul></li><li><a href="#load-and-export" class="table-of-contents__link toc-highlight">Load And Export</a><ul><li><a href="#enable_pipeline_load" class="table-of-contents__link toc-highlight"><code>enable_pipeline_load</code></a></li><li><a href="#enable_vectorized_load" class="table-of-contents__link toc-highlight"><code>enable_vectorized_load</code></a></li><li><a href="#enable_new_load_scan_node" class="table-of-contents__link toc-highlight"><code>enable_new_load_scan_node</code></a></li><li><a href="#default_max_filter_ratio" class="table-of-contents__link toc-highlight"><code>default_max_filter_ratio</code></a></li><li><a href="#max_running_txn_num_per_db" class="table-of-contents__link toc-highlight"><code>max_running_txn_num_per_db</code></a></li><li><a href="#using_old_load_usage_pattern" class="table-of-contents__link toc-highlight"><code>using_old_load_usage_pattern</code></a></li><li><a href="#disable_load_job" class="table-of-contents__link toc-highlight"><code>disable_load_job</code></a></li><li><a href="#commit_timeout_second" class="table-of-contents__link toc-highlight"><code>commit_timeout_second</code></a></li><li><a href="#max_unfinished_load_job" class="table-of-contents__link toc-highlight"><code>max_unfinished_load_job</code></a></li><li><a href="#db_used_data_quota_update_interval_secs" class="table-of-contents__link toc-highlight"><code>db_used_data_quota_update_interval_secs</code></a></li><li><a href="#disable_show_stream_load" class="table-of-contents__link toc-highlight"><code>disable_show_stream_load</code></a></li><li><a href="#max_stream_load_record_size" class="table-of-contents__link toc-highlight"><code>max_stream_load_record_size</code></a></li><li><a href="#fetch_stream_load_record_interval_second" class="table-of-contents__link toc-highlight"><code>fetch_stream_load_record_interval_second</code></a></li><li><a href="#max_bytes_per_broker_scanner" class="table-of-contents__link toc-highlight"><code>max_bytes_per_broker_scanner</code></a></li><li><a href="#default_load_parallelism" class="table-of-contents__link toc-highlight"><code>default_load_parallelism</code></a></li><li><a href="#max_broker_concurrency" class="table-of-contents__link toc-highlight"><code>max_broker_concurrency</code></a></li><li><a href="#min_bytes_per_broker_scanner" class="table-of-contents__link toc-highlight"><code>min_bytes_per_broker_scanner</code></a></li><li><a href="#period_of_auto_resume_min" class="table-of-contents__link toc-highlight"><code>period_of_auto_resume_min</code></a></li><li><a href="#max_tolerable_backend_down_num" class="table-of-contents__link toc-highlight"><code>max_tolerable_backend_down_num</code></a></li><li><a href="#max_routine_load_task_num_per_be" class="table-of-contents__link toc-highlight"><code>max_routine_load_task_num_per_be</code></a></li><li><a href="#max_routine_load_task_concurrent_num" class="table-of-contents__link toc-highlight"><code>max_routine_load_task_concurrent_num</code></a></li><li><a href="#max_routine_load_job_num" class="table-of-contents__link toc-highlight"><code>max_routine_load_job_num</code></a></li><li><a href="#desired_max_waiting_jobs" class="table-of-contents__link toc-highlight"><code>desired_max_waiting_jobs</code></a></li><li><a href="#disable_hadoop_load" class="table-of-contents__link toc-highlight"><code>disable_hadoop_load</code></a></li><li><a href="#enable_spark_load" class="table-of-contents__link toc-highlight"><code>enable_spark_load</code></a></li><li><a href="#spark_load_checker_interval_second" class="table-of-contents__link toc-highlight"><code>spark_load_checker_interval_second</code></a></li><li><a href="#async_loading_load_task_pool_size" class="table-of-contents__link toc-highlight"><code>async_loading_load_task_pool_size</code></a></li><li><a href="#async_pending_load_task_pool_size" class="table-of-contents__link toc-highlight"><code>async_pending_load_task_pool_size</code></a></li><li><a href="#async_load_task_pool_size" class="table-of-contents__link toc-highlight"><code>async_load_task_pool_size</code></a></li><li><a href="#enable_single_replica_load" class="table-of-contents__link toc-highlight"><code>enable_single_replica_load</code></a></li><li><a href="#min_load_timeout_second" class="table-of-contents__link toc-highlight"><code>min_load_timeout_second</code></a></li><li><a href="#max_stream_load_timeout_second" class="table-of-contents__link toc-highlight"><code>max_stream_load_timeout_second</code></a></li><li><a href="#max_load_timeout_second" class="table-of-contents__link toc-highlight"><code>max_load_timeout_second</code></a></li><li><a href="#stream_load_default_timeout_second" class="table-of-contents__link toc-highlight"><code>stream_load_default_timeout_second</code></a></li><li><a href="#stream_load_default_precommit_timeout_second" class="table-of-contents__link toc-highlight"><code>stream_load_default_precommit_timeout_second</code></a></li><li><a href="#insert_load_default_timeout_second" class="table-of-contents__link toc-highlight"><code>insert_load_default_timeout_second</code></a></li><li><a href="#mini_load_default_timeout_second" class="table-of-contents__link toc-highlight"><code>mini_load_default_timeout_second</code></a></li><li><a href="#broker_load_default_timeout_second" class="table-of-contents__link toc-highlight"><code>broker_load_default_timeout_second</code></a></li><li><a href="#spark_load_default_timeout_second" class="table-of-contents__link toc-highlight"><code>spark_load_default_timeout_second</code></a></li><li><a href="#hadoop_load_default_timeout_second" class="table-of-contents__link toc-highlight"><code>hadoop_load_default_timeout_second</code></a></li><li><a href="#load_running_job_num_limit" class="table-of-contents__link toc-highlight"><code>load_running_job_num_limit</code></a></li><li><a href="#load_input_size_limit_gb" class="table-of-contents__link toc-highlight"><code>load_input_size_limit_gb</code></a></li><li><a href="#load_etl_thread_num_normal_priority" class="table-of-contents__link toc-highlight"><code>load_etl_thread_num_normal_priority</code></a></li><li><a href="#load_etl_thread_num_high_priority" class="table-of-contents__link toc-highlight"><code>load_etl_thread_num_high_priority</code></a></li><li><a href="#load_pending_thread_num_normal_priority" class="table-of-contents__link toc-highlight"><code>load_pending_thread_num_normal_priority</code></a></li><li><a href="#load_pending_thread_num_high_priority" class="table-of-contents__link toc-highlight"><code>load_pending_thread_num_high_priority</code></a></li><li><a href="#load_checker_interval_second" class="table-of-contents__link toc-highlight"><code>load_checker_interval_second</code></a></li><li><a href="#load_straggler_wait_second" class="table-of-contents__link toc-highlight"><code>load_straggler_wait_second</code></a></li><li><a href="#label_keep_max_second" class="table-of-contents__link toc-highlight"><code>label_keep_max_second</code></a></li><li><a href="#streaming_label_keep_max_second" class="table-of-contents__link toc-highlight"><code>streaming_label_keep_max_second</code></a></li><li><a href="#label_clean_interval_second" class="table-of-contents__link toc-highlight"><code>label_clean_interval_second</code></a></li><li><a href="#transaction_clean_interval_second" class="table-of-contents__link toc-highlight"><code>transaction_clean_interval_second</code></a></li><li><a href="#sync_commit_interval_second" class="table-of-contents__link toc-highlight"><code>sync_commit_interval_second</code></a></li><li><a href="#sync_checker_interval_second" class="table-of-contents__link toc-highlight"><code>sync_checker_interval_second</code></a></li><li><a href="#max_sync_task_threads_num" class="table-of-contents__link toc-highlight"><code>max_sync_task_threads_num</code></a></li><li><a href="#min_sync_commit_size" class="table-of-contents__link toc-highlight"><code>min_sync_commit_size</code></a></li><li><a href="#min_bytes_sync_commit" class="table-of-contents__link toc-highlight"><code>min_bytes_sync_commit</code></a></li><li><a href="#max_bytes_sync_commit" class="table-of-contents__link toc-highlight"><code>max_bytes_sync_commit</code></a></li><li><a href="#enable_outfile_to_local" class="table-of-contents__link toc-highlight"><code>enable_outfile_to_local</code></a></li><li><a href="#export_tablet_num_per_task" class="table-of-contents__link toc-highlight"><code>export_tablet_num_per_task</code></a></li><li><a href="#export_task_default_timeout_second" class="table-of-contents__link toc-highlight"><code>export_task_default_timeout_second</code></a></li><li><a href="#export_running_job_num_limit" class="table-of-contents__link toc-highlight"><code>export_running_job_num_limit</code></a></li><li><a href="#export_checker_interval_second" class="table-of-contents__link toc-highlight"><code>export_checker_interval_second</code></a></li></ul></li><li><a href="#log" class="table-of-contents__link toc-highlight">Log</a><ul><li><a href="#log_roll_size_mb" class="table-of-contents__link toc-highlight"><code>log_roll_size_mb</code></a></li><li><a href="#sys_log_dir" class="table-of-contents__link toc-highlight"><code>sys_log_dir</code></a></li><li><a href="#sys_log_level" class="table-of-contents__link toc-highlight"><code>sys_log_level</code></a></li><li><a href="#sys_log_roll_num" class="table-of-contents__link toc-highlight"><code>sys_log_roll_num</code></a></li><li><a href="#sys_log_verbose_modules" class="table-of-contents__link toc-highlight"><code>sys_log_verbose_modules</code></a></li><li><a href="#sys_log_roll_interval" class="table-of-contents__link toc-highlight"><code>sys_log_roll_interval</code></a></li><li><a href="#sys_log_delete_age" class="table-of-contents__link toc-highlight"><code>sys_log_delete_age</code></a></li><li><a href="#sys_log_roll_mode" class="table-of-contents__link toc-highlight"><code>sys_log_roll_mode</code></a></li><li><a href="#sys_log_enable_compress" class="table-of-contents__link toc-highlight"><code>sys_log_enable_compress</code></a></li><li><a href="#audit_log_dir" class="table-of-contents__link toc-highlight"><code>audit_log_dir</code></a></li><li><a href="#audit_log_roll_num" class="table-of-contents__link toc-highlight"><code>audit_log_roll_num</code></a></li><li><a href="#audit_log_modules" class="table-of-contents__link toc-highlight"><code>audit_log_modules</code></a></li><li><a href="#qe_slow_log_ms" class="table-of-contents__link toc-highlight"><code>qe_slow_log_ms</code></a></li><li><a href="#audit_log_roll_interval" class="table-of-contents__link toc-highlight"><code>audit_log_roll_interval</code></a></li><li><a href="#audit_log_delete_age" class="table-of-contents__link toc-highlight"><code>audit_log_delete_age</code></a></li><li><a href="#audit_log_enable_compress" class="table-of-contents__link toc-highlight"><code>audit_log_enable_compress</code></a></li></ul></li><li><a href="#storage" class="table-of-contents__link toc-highlight">Storage</a><ul><li><a href="#min_replication_num_per_tablet" class="table-of-contents__link toc-highlight"><code>min_replication_num_per_tablet</code></a></li><li><a href="#max_replication_num_per_tablet" class="table-of-contents__link toc-highlight"><code>max_replication_num_per_tablet</code></a></li><li><a href="#default_db_data_quota_bytes" class="table-of-contents__link toc-highlight"><code>default_db_data_quota_bytes</code></a></li><li><a href="#default_db_replica_quota_size" class="table-of-contents__link toc-highlight"><code>default_db_replica_quota_size</code></a></li><li><a href="#recover_with_empty_tablet" class="table-of-contents__link toc-highlight"><code>recover_with_empty_tablet</code></a></li><li><a href="#min_clone_task_timeout_sec-and-max_clone_task_timeout_sec" class="table-of-contents__link toc-highlight"><code>min_clone_task_timeout_sec</code> <code>And max_clone_task_timeout_sec</code></a></li><li><a href="#disable_storage_medium_check" class="table-of-contents__link toc-highlight"><code>disable_storage_medium_check</code></a></li><li><a href="#decommission_tablet_check_threshold" class="table-of-contents__link toc-highlight"><code>decommission_tablet_check_threshold</code></a></li><li><a href="#partition_rebalance_max_moves_num_per_selection" class="table-of-contents__link toc-highlight"><code>partition_rebalance_max_moves_num_per_selection</code></a></li><li><a href="#partition_rebalance_move_expire_after_access" class="table-of-contents__link toc-highlight"><code>partition_rebalance_move_expire_after_access</code></a></li><li><a href="#tablet_rebalancer_type" class="table-of-contents__link toc-highlight"><code>tablet_rebalancer_type</code></a></li><li><a href="#max_balancing_tablets" class="table-of-contents__link toc-highlight"><code>max_balancing_tablets</code></a></li><li><a href="#max_scheduling_tablets" class="table-of-contents__link toc-highlight"><code>max_scheduling_tablets</code></a></li><li><a href="#disable_balance" class="table-of-contents__link toc-highlight"><code>disable_balance</code></a></li><li><a href="#disable_disk_balance" class="table-of-contents__link toc-highlight"><code>disable_disk_balance</code></a></li><li><a href="#balance_load_score_threshold" class="table-of-contents__link toc-highlight"><code>balance_load_score_threshold</code></a></li><li><a href="#capacity_used_percent_high_water" class="table-of-contents__link toc-highlight"><code>capacity_used_percent_high_water</code></a></li><li><a href="#clone_distribution_balance_threshold" class="table-of-contents__link toc-highlight"><code>clone_distribution_balance_threshold</code></a></li><li><a href="#clone_capacity_balance_threshold" class="table-of-contents__link toc-highlight"><code>clone_capacity_balance_threshold</code></a></li><li><a href="#disable_colocate_balance" class="table-of-contents__link toc-highlight"><code>disable_colocate_balance</code></a></li><li><a href="#balance_slot_num_per_path" class="table-of-contents__link toc-highlight"><code>balance_slot_num_per_path</code></a></li><li><a href="#disable_tablet_scheduler" class="table-of-contents__link toc-highlight"><code>disable_tablet_scheduler</code></a></li><li><a href="#enable_force_drop_redundant_replica" class="table-of-contents__link toc-highlight"><code>enable_force_drop_redundant_replica</code></a></li><li><a href="#colocate_group_relocate_delay_second" class="table-of-contents__link toc-highlight"><code>colocate_group_relocate_delay_second</code></a></li><li><a href="#repair_slow_replica" class="table-of-contents__link toc-highlight"><code>repair_slow_replica</code></a></li><li><a href="#min_version_count_indicate_replica_compaction_too_slow" class="table-of-contents__link toc-highlight"><code>min_version_count_indicate_replica_compaction_too_slow</code></a></li><li><a href="#skip_compaction_slower_replica" class="table-of-contents__link toc-highlight"><code>skip_compaction_slower_replica</code></a></li><li><a href="#valid_version_count_delta_ratio_between_replicas" class="table-of-contents__link toc-highlight"><code>valid_version_count_delta_ratio_between_replicas</code></a></li><li><a href="#min_bytes_indicate_replica_too_large" class="table-of-contents__link toc-highlight"><code>min_bytes_indicate_replica_too_large</code></a></li><li><a href="#schedule_slot_num_per_path" class="table-of-contents__link toc-highlight"><code>schedule_slot_num_per_path</code></a></li><li><a href="#tablet_repair_delay_factor_second" class="table-of-contents__link toc-highlight"><code>tablet_repair_delay_factor_second</code></a></li><li><a href="#tablet_stat_update_interval_second" class="table-of-contents__link toc-highlight"><code>tablet_stat_update_interval_second</code></a></li><li><a href="#storage_flood_stage_usage_percent" class="table-of-contents__link toc-highlight"><code>storage_flood_stage_usage_percent</code></a></li><li><a href="#storage_high_watermark_usage_percent" class="table-of-contents__link toc-highlight"><code>storage_high_watermark_usage_percent</code></a></li><li><a href="#storage_min_left_capacity_bytes" class="table-of-contents__link toc-highlight"><code>storage_min_left_capacity_bytes</code></a></li><li><a href="#catalog_trash_expire_second" class="table-of-contents__link toc-highlight"><code>catalog_trash_expire_second</code></a></li><li><a href="#storage_cooldown_second" class="table-of-contents__link toc-highlight"><code>storage_cooldown_second</code></a></li><li><a href="#default_storage_medium" class="table-of-contents__link toc-highlight"><code>default_storage_medium</code></a></li><li><a href="#enable_storage_policy" class="table-of-contents__link toc-highlight"><code>enable_storage_policy</code></a></li><li><a href="#check_consistency_default_timeout_second" class="table-of-contents__link toc-highlight"><code>check_consistency_default_timeout_second</code></a></li><li><a href="#consistency_check_start_time" class="table-of-contents__link toc-highlight"><code>consistency_check_start_time</code></a></li><li><a href="#consistency_check_end_time" class="table-of-contents__link toc-highlight"><code>consistency_check_end_time</code></a></li><li><a href="#replica_delay_recovery_second" class="table-of-contents__link toc-highlight"><code>replica_delay_recovery_second</code></a></li><li><a href="#tablet_create_timeout_second" class="table-of-contents__link toc-highlight"><code>tablet_create_timeout_second</code></a></li><li><a href="#tablet_delete_timeout_second" class="table-of-contents__link toc-highlight"><code>tablet_delete_timeout_second</code></a></li><li><a href="#alter_table_timeout_second" class="table-of-contents__link toc-highlight"><code>alter_table_timeout_second</code></a></li><li><a href="#max_replica_count_when_schema_change" class="table-of-contents__link toc-highlight"><code>max_replica_count_when_schema_change</code></a></li><li><a href="#history_job_keep_max_second" class="table-of-contents__link toc-highlight"><code>history_job_keep_max_second</code></a></li><li><a href="#max_create_table_timeout_second" class="table-of-contents__link toc-highlight"><code>max_create_table_timeout_second</code></a></li></ul></li><li><a href="#external-table" class="table-of-contents__link toc-highlight">External Table</a><ul><li><a href="#file_scan_node_split_num" class="table-of-contents__link toc-highlight"><code>file_scan_node_split_num</code></a></li><li><a href="#file_scan_node_split_size" class="table-of-contents__link toc-highlight"><code>file_scan_node_split_size</code></a></li><li><a href="#enable_odbc_table" class="table-of-contents__link toc-highlight"><code>enable_odbc_table</code></a></li><li><a href="#disable_iceberg_hudi_table" class="table-of-contents__link toc-highlight"><code>disable_iceberg_hudi_table</code></a></li><li><a href="#iceberg_table_creation_interval_second" class="table-of-contents__link toc-highlight"><code>iceberg_table_creation_interval_second</code></a></li><li><a href="#iceberg_table_creation_strict_mode" class="table-of-contents__link toc-highlight"><code>iceberg_table_creation_strict_mode</code></a></li><li><a href="#max_iceberg_table_creation_record_size" class="table-of-contents__link toc-highlight"><code>max_iceberg_table_creation_record_size</code></a></li><li><a href="#max_hive_partition_cache_num" class="table-of-contents__link toc-highlight"><code>max_hive_partition_cache_num</code></a></li><li><a href="#hive_metastore_client_timeout_second" class="table-of-contents__link toc-highlight"><code>hive_metastore_client_timeout_second</code></a></li><li><a href="#max_external_cache_loader_thread_pool_size" class="table-of-contents__link toc-highlight"><code>max_external_cache_loader_thread_pool_size</code></a></li><li><a href="#max_external_file_cache_num" class="table-of-contents__link toc-highlight"><code>max_external_file_cache_num</code></a></li><li><a href="#max_external_schema_cache_num" class="table-of-contents__link toc-highlight"><code>max_external_schema_cache_num</code></a></li><li><a href="#external_cache_expire_time_minutes_after_access" class="table-of-contents__link toc-highlight"><code>external_cache_expire_time_minutes_after_access</code></a></li><li><a href="#es_state_sync_interval_second" class="table-of-contents__link toc-highlight"><code>es_state_sync_interval_second</code></a></li></ul></li><li><a href="#external-resources" class="table-of-contents__link toc-highlight">External Resources</a><ul><li><a href="#dpp_hadoop_client_path" class="table-of-contents__link toc-highlight"><code>dpp_hadoop_client_path</code></a></li><li><a href="#dpp_bytes_per_reduce" class="table-of-contents__link toc-highlight"><code>dpp_bytes_per_reduce</code></a></li><li><a href="#dpp_default_cluster" class="table-of-contents__link toc-highlight"><code>dpp_default_cluster</code></a></li><li><a href="#dpp_default_config_str" class="table-of-contents__link toc-highlight"><code>dpp_default_config_str</code></a></li><li><a href="#dpp_config_str" class="table-of-contents__link toc-highlight"><code>dpp_config_str</code></a></li><li><a href="#yarn_config_dir" class="table-of-contents__link toc-highlight"><code>yarn_config_dir</code></a></li><li><a href="#yarn_client_path" class="table-of-contents__link toc-highlight"><code>yarn_client_path</code></a></li><li><a href="#spark_launcher_log_dir" class="table-of-contents__link toc-highlight"><code>spark_launcher_log_dir</code></a></li><li><a href="#spark_resource_path" class="table-of-contents__link toc-highlight"><code>spark_resource_path</code></a></li><li><a href="#spark_home_default_dir" class="table-of-contents__link toc-highlight"><code>spark_home_default_dir</code></a></li><li><a href="#spark_dpp_version" class="table-of-contents__link toc-highlight"><code>spark_dpp_version</code></a></li></ul></li><li><a href="#else" class="table-of-contents__link toc-highlight">Else</a><ul><li><a href="#tmp_dir" class="table-of-contents__link toc-highlight"><code>tmp_dir</code></a></li><li><a href="#custom_config_dir" class="table-of-contents__link toc-highlight"><code>custom_config_dir</code></a></li><li><a href="#plugin_dir" class="table-of-contents__link toc-highlight"><code>plugin_dir</code></a></li><li><a href="#plugin_enable" class="table-of-contents__link toc-highlight"><code>plugin_enable</code></a></li><li><a href="#small_file_dir" class="table-of-contents__link toc-highlight"><code>small_file_dir</code></a></li><li><a href="#max_small_file_size_bytes" class="table-of-contents__link toc-highlight"><code>max_small_file_size_bytes</code></a></li><li><a href="#max_small_file_number" class="table-of-contents__link toc-highlight"><code>max_small_file_number</code></a></li><li><a href="#enable_metric_calculator" class="table-of-contents__link toc-highlight"><code>enable_metric_calculator</code></a></li><li><a href="#report_queue_size" class="table-of-contents__link toc-highlight"><code>report_queue_size</code></a></li><li><a href="#backup_job_default_timeout_ms" class="table-of-contents__link toc-highlight"><code>backup_job_default_timeout_ms</code></a></li><li><a href="#max_backup_restore_job_num_per_db" class="table-of-contents__link toc-highlight"><code>max_backup_restore_job_num_per_db</code></a></li><li><a href="#enable_quantile_state_type" class="table-of-contents__link toc-highlight"><code>enable_quantile_state_type</code></a></li><li><a href="#enable_date_conversion" class="table-of-contents__link toc-highlight"><code>enable_date_conversion</code></a></li><li><a href="#enable_decimal_conversion" class="table-of-contents__link toc-highlight"><code>enable_decimal_conversion</code></a></li><li><a href="#proxy_auth_magic_prefix" class="table-of-contents__link toc-highlight"><code>proxy_auth_magic_prefix</code></a></li><li><a href="#proxy_auth_enable" class="table-of-contents__link toc-highlight"><code>proxy_auth_enable</code></a></li><li><a href="#enable_func_pushdown" class="table-of-contents__link toc-highlight"><code>enable_func_pushdown</code></a></li><li><a href="#jdbc_drivers_dir" class="table-of-contents__link toc-highlight"><code>jdbc_drivers_dir</code></a></li><li><a href="#max_error_tablet_of_broker_load" class="table-of-contents__link toc-highlight"><code>max_error_tablet_of_broker_load</code></a></li><li><a href="#default_db_max_running_txn_num" class="table-of-contents__link toc-highlight"><code>default_db_max_running_txn_num</code></a></li><li><a href="#prefer_compute_node_for_external_table" class="table-of-contents__link toc-highlight"><code>prefer_compute_node_for_external_table</code></a></li><li><a href="#min_backend_num_for_external_table" class="table-of-contents__link toc-highlight"><code>min_backend_num_for_external_table</code></a></li><li><a href="#infodb_support_ext_catalog" class="table-of-contents__link toc-highlight"><code>infodb_support_ext_catalog</code></a></li><li><a href="#enable_query_hit_stats" class="table-of-contents__link toc-highlight"><code>enable_query_hit_stats</code></a></li><li><a href="#div_precision_increment" class="table-of-contents__link toc-highlight"><code>div_precision_increment</code></a></li><li><a href="#enable_convert_light_weight_schema_change" class="table-of-contents__link toc-highlight"><code>enable_convert_light_weight_schema_change</code></a></li><li><a href="#disable_local_deploy_manager_drop_node" class="table-of-contents__link toc-highlight"><code>disable_local_deploy_manager_drop_node</code></a></li><li><a href="#mysqldb_replace_name" class="table-of-contents__link toc-highlight"><code>mysqldb_replace_name</code></a></li><li><a href="#max_auto_partition_num" class="table-of-contents__link toc-highlight"><code>max_auto_partition_num</code></a></li></ul></li></ul></li></ul></div></div></div></div></main></div></div></div><div class="footer pt-16 pb-10"><div class="container"><div class="footer-box"><div class="left"><img src="/images/asf_logo_apache.svg" alt="" class="themedImage_ToTc themedImage--light_HNdA footer__logo"><img src="/images/asf_logo_apache.svg" alt="" class="themedImage_ToTc themedImage--dark_i4oU footer__logo"><div class="row footer__links"><div class="col footer__col"><div class="footer__title">ASF</div><ul class="footer__items clean-list"><li class="footer__item"><a href="https://www.apache.org/" target="_blank" rel="noopener noreferrer" class="footer__link-item">Foundation<svg width="13.5" height="13.5" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li class="footer__item"><a href="https://www.apache.org/licenses/" target="_blank" rel="noopener noreferrer" class="footer__link-item">License<svg width="13.5" height="13.5" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li class="footer__item"><a href="https://www.apache.org/events/current-event" target="_blank" rel="noopener noreferrer" class="footer__link-item">Events<svg width="13.5" height="13.5" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li class="footer__item"><a href="https://www.apache.org/foundation/sponsorship.html" target="_blank" rel="noopener noreferrer" class="footer__link-item">Sponsorship<svg width="13.5" height="13.5" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li class="footer__item"><a href="https://privacy.apache.org/policies/privacy-policy-public.html" target="_blank" rel="noopener noreferrer" class="footer__link-item">Privacy<svg width="13.5" height="13.5" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li class="footer__item"><a href="https://www.apache.org/security/" target="_blank" rel="noopener noreferrer" class="footer__link-item">Security<svg width="13.5" height="13.5" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li class="footer__item"><a href="https://www.apache.org/foundation/thanks.html" target="_blank" rel="noopener noreferrer" class="footer__link-item">Thanks<svg width="13.5" height="13.5" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li></ul></div><div class="col footer__col"><div class="footer__title">Resources</div><ul class="footer__items clean-list"><li class="footer__item"><a class="footer__link-item" href="/download">Download</a></li><li class="footer__item"><a class="footer__link-item" href="/docs/get-starting/quick-start">Docs</a></li><li class="footer__item"><a class="footer__link-item" href="/blog">Blog</a></li><li class="footer__item"><a class="footer__link-item" href="/ecosystem/cluster-management">Ecosystem</a></li><li class="footer__item"><a class="footer__link-item" href="/users">Users</a></li><li class="footer__item"><a href="https://github.com/apache/doris/discussions" target="_blank" rel="noopener noreferrer" class="footer__link-item">Discussions<svg width="13.5" height="13.5" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li></ul></div><div class="col footer__col"><div class="footer__title">Community</div><ul class="footer__items clean-list"><li class="footer__item"><a class="footer__link-item" href="/community/how-to-contribute/">How to contribute</a></li><li class="footer__item"><a href="https://github.com/apache/doris/" target="_blank" rel="noopener noreferrer" class="footer__link-item">Source code<svg width="13.5" height="13.5" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li class="footer__item"><a href="https://cwiki.apache.org/confluence/display/DORIS/Doris+Improvement+Proposals" target="_blank" rel="noopener noreferrer" class="footer__link-item">Improvement proposal<svg width="13.5" height="13.5" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li class="footer__item"><a class="footer__link-item" href="/community/team">Doris team</a></li><li class="footer__item"><a href="https://github.com/apache/doris/issues/30669" target="_blank" rel="noopener noreferrer" class="footer__link-item">Roadmap<svg width="13.5" height="13.5" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li></ul></div></div></div><div class="right"><div class="footer__title">Join the community</div><div class="social-list"><div class="social"><a href="mailto:dev@doris.apache.org" target="_blank" title="mail" class="item"><svg xmlns="http://www.w3.org/2000/svg" width="2em" height="2em" viewBox="0 0 32 32" fill="none"><path d="M5.6003 6H26.3997C27.8186 6 28.982 7.10964 29 8.46946L16.0045 15.454L3.01202 8.47829C3.02405 7.11258 4.1784 6 5.6003 6ZM3.01202 11.1508L3 23.5011C3 24.8756 4.16938 26 5.6003 26H26.3997C27.8306 26 29 24.8756 29 23.5011V11.145L16.3111 17.8028C16.1157 17.9058 15.8813 17.9058 15.6889 17.8028L3.01202 11.1508Z" fill="currentColor"></path></svg></a><a href="https://github.com/apache/doris" target="_blank" title="github" class="item"><svg width="2em" height="2em" viewBox="0 0 32 32" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M16.0001 2.66675C8.63342 2.66675 2.66675 8.63341 2.66675 16.0001C2.66524 18.7991 3.54517 21.5276 5.1817 23.7983C6.81824 26.0691 9.12828 27.7668 11.7841 28.6508C12.4508 28.7668 12.7001 28.3668 12.7001 28.0161C12.7001 27.7001 12.6828 26.6508 12.6828 25.5334C9.33342 26.1508 8.46675 24.7174 8.20008 23.9668C8.04942 23.5828 7.40008 22.4001 6.83342 22.0828C6.36675 21.8334 5.70008 21.2161 6.81608 21.2001C7.86675 21.1828 8.61608 22.1668 8.86675 22.5668C10.0668 24.5828 11.9841 24.0161 12.7494 23.6668C12.8668 22.8001 13.2161 22.2174 13.6001 21.8841C10.6334 21.5508 7.53342 20.4001 7.53342 15.3001C7.53342 13.8494 8.04942 12.6507 8.90008 11.7161C8.76675 11.3827 8.30008 10.0161 9.03342 8.18275C9.03342 8.18275 10.1494 7.83342 12.7001 9.55075C13.7855 9.2495 14.907 9.09787 16.0334 9.10008C17.1668 9.10008 18.3001 9.24942 19.3668 9.54942C21.9161 7.81608 23.0334 8.18408 23.0334 8.18408C23.7668 10.0174 23.3001 11.3841 23.1668 11.7174C24.0161 12.6507 24.5334 13.8334 24.5334 15.3001C24.5334 20.4174 21.4174 21.5508 18.4508 21.8841C18.9334 22.3001 19.3508 23.1001 19.3508 24.3508C19.3508 26.1334 19.3334 27.5668 19.3334 28.0174C19.3334 28.3668 19.5841 28.7828 20.2508 28.6494C22.8975 27.7558 25.1973 26.0547 26.8266 23.7856C28.4559 21.5165 29.3327 18.7936 29.3334 16.0001C29.3334 8.63341 23.3668 2.66675 16.0001 2.66675V2.66675Z" fill="currentColor"></path></svg></a><a href="https://twitter.com/doris_apache" target="_blank" title="twitter" class="item"><svg xmlns="http://www.w3.org/2000/svg" width="2em" height="2em" viewBox="0 0 32 32" fill="none"><path d="M4.625 4.625H11.2809L27.375 27.375H20.7191L4.625 4.625ZM7.52549 6.10639L21.5236 25.8936H24.4746L10.4764 6.10639H7.52549Z" fill="currentColor"></path><path d="M14.4268 18.4803L6.53447 27.375H4.625L13.5581 17.2525L14.4268 18.4803ZM18.1299 14.3066L26.7203 4.625H24.7017L17.2525 13.0662L18.1299 14.3066Z" fill="currentColor"></path></svg></a><a href="https://join.slack.com/t/apachedoriscommunity/shared_invite/zt-2kl08hzc0-SPJe4VWmL_qzrFd2u2XYQA" title="slack" target="_blank" class="item"><svg width="2em" height="2em" viewBox="0 0 32 32" fill="none" xmlns="http://www.w3.org/2000/svg"><g clip-path="url(#clip0_125_278)"><path d="M12.5875 16.6906C11.0844 16.6906 9.86562 17.9094 9.86562 19.4125V26.2375C9.86562 26.9594 10.1524 27.6517 10.6628 28.1622C11.1733 28.6726 11.8656 28.9594 12.5875 28.9594C13.3094 28.9594 14.0017 28.6726 14.5122 28.1622C15.0226 27.6517 15.3094 26.9594 15.3094 26.2375V19.4531C15.3094 17.9094 14.0906 16.6906 12.5875 16.6906ZM3 19.4531C3 20.175 3.28677 20.8673 3.79722 21.3778C4.30767 21.8882 4.99999 22.175 5.72187 22.175C6.44376 22.175 7.13608 21.8882 7.64653 21.3778C8.15698 20.8673 8.44375 20.175 8.44375 19.4531V16.7312H5.7625C4.25938 16.6906 3 17.9094 3 19.4531ZM12.5875 3C11.8656 3 11.1733 3.28677 10.6628 3.79722C10.1524 4.30767 9.86562 4.99999 9.86562 5.72187C9.86562 6.44376 10.1524 7.13608 10.6628 7.64653C11.1733 8.15698 11.8656 8.44375 12.5875 8.44375H15.3094V5.72187C15.3094 4.21875 14.0906 3 12.5875 3ZM5.72187 15.3094H12.5469C13.2688 15.3094 13.9611 15.0226 14.4715 14.5122C14.982 14.0017 15.2688 13.3094 15.2688 12.5875C15.2688 11.8656 14.982 11.1733 14.4715 10.6628C13.9611 10.1524 13.2688 9.86562 12.5469 9.86562H5.72187C4.99999 9.86562 4.30767 10.1524 3.79722 10.6628C3.28677 11.1733 3 11.8656 3 12.5875C3 13.3094 3.28677 14.0017 3.79722 14.5122C4.30767 15.0226 4.99999 15.3094 5.72187 15.3094ZM26.2375 9.86562C24.7344 9.86562 23.5156 11.0844 23.5156 12.5875V15.3094H26.2375C26.9594 15.3094 27.6517 15.0226 28.1622 14.5122C28.6726 14.0017 28.9594 13.3094 28.9594 12.5875C28.9594 11.8656 28.6726 11.1733 28.1622 10.6628C27.6517 10.1524 26.9594 9.86562 26.2375 9.86562ZM16.6906 5.72187V12.5875C16.6906 13.3094 16.9774 14.0017 17.4878 14.5122C17.9983 15.0226 18.6906 15.3094 19.4125 15.3094C20.1344 15.3094 20.8267 15.0226 21.3372 14.5122C21.8476 14.0017 22.1344 13.3094 22.1344 12.5875V5.72187C22.1344 4.99999 21.8476 4.30767 21.3372 3.79722C20.8267 3.28677 20.1344 3 19.4125 3C18.6906 3 17.9983 3.28677 17.4878 3.79722C16.9774 4.30767 16.6906 4.99999 16.6906 5.72187ZM22.1344 26.2781C22.1344 24.775 20.9156 23.5562 19.4125 23.5562H16.6906V26.2781C16.6906 27 16.9774 27.6923 17.4878 28.2028C17.9983 28.7132 18.6906 29 19.4125 29C20.1344 29 20.8267 28.7132 21.3372 28.2028C21.8476 27.6923 22.1344 27 22.1344 26.2781ZM26.2781 16.6906H19.4125C18.6906 16.6906 17.9983 16.9774 17.4878 17.4878C16.9774 17.9983 16.6906 18.6906 16.6906 19.4125C16.6906 20.1344 16.9774 20.8267 17.4878 21.3372C17.9983 21.8476 18.6906 22.1344 19.4125 22.1344H26.2375C27.7406 22.1344 28.9594 20.9156 28.9594 19.4125C29 17.9094 27.7812 16.6906 26.2781 16.6906Z" fill="currentColor"></path></g><defs><clipPath id="clip0_125_278"><rect width="26" height="26" fill="currentColor" transform="translate(3 3)"></rect></clipPath></defs></svg></a></div><div class="social"><a href="https://www.youtube.com/@apachedoris/channels" title="youtube" target="_blank" class="item"><svg xmlns="http://www.w3.org/2000/svg" width="2em" height="2em" viewBox="0 0 32 32" fill="none"><path d="M28.5167 7.83429C28.9436 8.25423 29.2532 8.77539 29.4154 9.34742C29.8205 11.5462 30.0159 13.7775 29.999 16.0121C30.0144 18.2382 29.819 20.4609 29.4154 22.6515C29.2532 23.2235 28.9436 23.7446 28.5167 24.1645C28.0898 24.5845 27.5601 24.889 26.9785 25.0486C24.7728 25.625 16.0124 25.625 16.0124 25.625C16.0124 25.625 7.22652 25.625 5.04638 25.0486C4.46489 24.889 3.9351 24.5845 3.5082 24.1645C3.08132 23.7446 2.77176 23.2235 2.60948 22.6515C2.19736 20.4617 1.9934 18.239 2.00025 16.0121C1.9918 13.7767 2.19577 11.5455 2.60948 9.34742C2.77176 8.77539 3.08132 8.25423 3.5082 7.83429C3.9351 7.41436 4.46489 7.10985 5.04638 6.95021C7.25103 6.36354 16.0124 6.37502 16.0124 6.37502C16.0124 6.37502 24.796 6.37502 26.9785 6.95021C27.5601 7.10985 28.0898 7.41436 28.5167 7.83429ZM12.5 21.25L21.25 16.008L12.5 10.75V21.25Z" fill="currentColor"></path></svg></a><a href="https://www.linkedin.com/company/doris-apache/" title="linkedin" target="_blank" class="item"><svg width="2rem" height="2rem" viewBox="0 0 32 32" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M4.29925 26.9996H9.66738V11.6781H4.29925V26.9996ZM22.1628 11.1949C19.9409 11.1949 18.7157 11.9388 17.3054 13.7407V11.6777H11.9459V26.9996H17.305V18.6738C17.305 16.9168 18.145 15.1982 20.1535 15.1982C22.162 15.1982 22.6559 16.9164 22.6559 18.632V27H28V18.2902C28 12.2386 24.3854 11.1949 22.1628 11.1949ZM6.99325 4C5.3395 4 4 5.21047 4 6.7046C4 8.19759 5.3395 9.40617 6.99325 9.40617C8.6455 9.40617 9.985 8.19722 9.985 6.7046C9.985 5.21047 8.6455 4 6.99325 4Z" fill="white"></path></svg></a><a href="https://medium.com/@ApacheDoris" title="medium" target="_blank" class="item"><svg width="2em" height="2em" viewBox="0 0 32 32" fill="none" xmlns="http://www.w3.org/2000/svg"><g id="Frame"><path id="Vector" d="M17.7967 16.5385C17.8029 18.53 16.9746 20.4425 15.4937 21.8559C14.0128 23.2693 12.0004 24.0681 9.89836 24.0769C7.79633 24.0681 5.78391 23.2693 4.30302 21.8559C2.82212 20.4425 1.99383 18.53 2.00003 16.5385C1.99383 14.5469 2.82212 12.6344 4.30302 11.221C5.78391 9.80759 7.79633 9.00878 9.89836 9C12.0004 9.00878 14.0128 9.80759 15.4937 11.221C16.9746 12.6344 17.8029 14.5469 17.7967 16.5385ZM26.4533 16.5385C26.4533 20.4514 24.6917 23.6348 22.51 23.6348C20.3283 23.6348 18.555 20.4514 18.555 16.5385C18.555 12.6255 20.3283 9.44214 22.51 9.44214C24.6917 9.44214 26.4533 12.6255 26.4533 16.5385ZM30 16.5385C30 20.0424 29.3817 22.8942 28.6117 22.8942C27.8417 22.8942 27.2233 20.0424 27.2233 16.5385C27.2233 13.0345 27.8417 10.1827 28.6117 10.1827C29.3817 10.1827 30 13.0345 30 16.5385Z" fill="currentColor"></path></g></svg></a><a class="item wechat"><svg width="2em" height="2em" viewBox="0 0 32 32" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M20.7578 11.5169C21.0708 11.5169 21.3795 11.5398 21.6851 11.573C20.8524 7.73517 16.7052 4.88306 11.9718 4.88306C6.67951 4.88306 2.34412 8.45283 2.34412 12.9854C2.34412 15.6013 3.78679 17.7498 6.19667 19.4161L5.2339 22.2827L8.59917 20.6122C9.80411 20.8478 10.7698 21.0906 11.9718 21.0906C12.2738 21.0906 12.5728 21.0759 12.8703 21.0523C12.682 20.4159 12.5728 19.7485 12.5728 19.0566C12.5728 14.8947 16.1847 11.5169 20.7578 11.5169ZM15.5822 8.9335C16.3072 8.9335 16.7871 9.40601 16.7871 10.1229C16.7871 10.8369 16.3072 11.3153 15.5822 11.3153C14.8601 11.3153 14.1365 10.8369 14.1365 10.1229C14.1365 9.40601 14.8601 8.9335 15.5822 8.9335ZM8.84429 11.3153C8.12218 11.3153 7.3942 10.8368 7.3942 10.1229C7.3942 9.40597 8.12218 8.93346 8.84429 8.93346C9.56559 8.93346 10.0463 9.40597 10.0463 10.1229C10.0463 10.8369 9.56559 11.3153 8.84429 11.3153ZM29.5453 18.9422C29.5453 15.1332 25.6935 12.0285 21.3677 12.0285C16.7871 12.0285 13.1797 15.1332 13.1797 18.9422C13.1797 22.7567 16.7871 25.8547 21.3677 25.8547C22.326 25.8547 23.2932 25.6169 24.2559 25.3777L26.897 26.8086L26.1726 24.4282C28.1056 22.993 29.5453 21.0906 29.5453 18.9422ZM18.7126 17.7498C18.2335 17.7498 17.7499 17.278 17.7499 16.7966C17.7499 16.3219 18.2335 15.8442 18.7126 15.8442C19.4406 15.8442 19.9176 16.3219 19.9176 16.7966C19.9176 17.278 19.4406 17.7498 18.7126 17.7498ZM24.0079 17.7498C23.5324 17.7498 23.0518 17.278 23.0518 16.7966C23.0518 16.3219 23.5324 15.8442 24.0079 15.8442C24.73 15.8442 25.2128 16.3219 25.2128 16.7966C25.2128 17.278 24.73 17.7498 24.0079 17.7498Z" fill="currentColor"></path></svg><div class="wechat-dropdown"><p class="text-[#4c576c] text-xs">Connect on WeChat</p><img src="https://cdnd.selectdb.com/assets/images/doris-wechat-b949e908a3bc2776d824f79a9100bd4b.png" alt=""></div></a></div></div></div></div><div class="footer__copyright">Copyright © 2024 The Apache Software Foundation,Licensed under the <a href="https://www.apache.org/licenses/LICENSE-2.0" target="_blank">Apache License, Version 2.0</a>. Apache, Doris, Apache Doris, the Apache feather logo and the Apache Doris logo are trademarks of The Apache Software Foundation.</div></div></div></div>
<script src="https://cdnd.selectdb.com/assets/js/runtime~main.17e841a6.js"></script>
<script src="https://cdnd.selectdb.com/assets/js/main.c9678103.js"></script>
</body>
</html>