<!doctype html>
<html class="docs-version-current" lang="en" dir="ltr">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width,initial-scale=1">
<meta name="generator" content="Docusaurus v2.0.0-beta.17">
<link rel="preconnect" href="https://www.google-analytics.com">
<script>window.ga=window.ga||function(){(ga.q=ga.q||[]).push(arguments)},ga.l=+new Date,ga("create","G-133LHD3B3N","auto"),ga("set","anonymizeIp",!0),ga("send","pageview")</script>
<script async src="https://www.google-analytics.com/analytics.js"></script>
<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-133LHD3B3N"></script>
<script>function gtag(){dataLayer.push(arguments)}window.dataLayer=window.dataLayer||[],gtag("js",new Date),gtag("config","G-133LHD3B3N",{anonymize_ip:!0})</script>
<link rel="search" type="application/opensearchdescription+xml" title="Superset" href="/opensearch.xml">
<script src="/script/matomo.js"></script><title data-rh="true">Issue Codes | Superset</title><meta data-rh="true" name="twitter:card" content="summary_large_image"><meta data-rh="true" property="og:url" content="https://superset.apache.org/docs/miscellaneous/issue-codes"><meta data-rh="true" name="docusaurus_locale" content="en"><meta data-rh="true" name="docusaurus_version" content="current"><meta data-rh="true" name="docusaurus_tag" content="docs-default-current"><meta data-rh="true" name="docsearch:language" content="en"><meta data-rh="true" name="docsearch:version" content="current"><meta data-rh="true" name="docsearch:docusaurus_tag" content="docs-default-current"><meta data-rh="true" property="og:title" content="Issue Codes | Superset"><meta data-rh="true" name="description" content="This page lists issue codes that may be displayed in"><meta data-rh="true" property="og:description" content="This page lists issue codes that may be displayed in"><link data-rh="true" rel="icon" href="/img/favicon.ico"><link data-rh="true" rel="canonical" href="https://superset.apache.org/docs/miscellaneous/issue-codes"><link data-rh="true" rel="alternate" href="https://superset.apache.org/docs/miscellaneous/issue-codes" hreflang="en"><link data-rh="true" rel="alternate" href="https://superset.apache.org/docs/miscellaneous/issue-codes" hreflang="x-default"><link data-rh="true" rel="preconnect" href="https://WR5FASX5ED-dsn.algolia.net" crossorigin="anonymous"><link rel="stylesheet" href="/assets/css/styles.ba1779ef.css">
<link rel="preload" href="/assets/js/runtime~main.ed6925bb.js" as="script">
<link rel="preload" href="/assets/js/main.46afaa66.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=localStorage.getItem("theme")}catch(t){}return t}();t(null!==e?e:"light")}()</script><div id="__docusaurus">
<div role="region"><a href="#" class="skipToContent_ZgBM">Skip to main content</a></div><nav class="navbar navbar--fixed-top"><div class="navbar__inner"><div class="navbar__items"><button aria-label="Navigation bar toggle" class="navbar__toggle clean-btn" type="button" tabindex="0"><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><a class="navbar__brand" href="/"><div class="navbar__logo"><img src="/img/superset-logo-horiz.svg" alt="Superset Logo" class="themedImage_W2Cr themedImage--light_TfLj"><img src="/img/superset-logo-horiz-dark.svg" alt="Superset Logo" class="themedImage_W2Cr themedImage--dark_oUvU"></div></a><div class="navbar__item dropdown dropdown--hoverable"><a href="#" class="navbar__link">Documentation</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/docs/intro">Getting Started</a></li><li><a class="dropdown__link" href="/docs/frequently-asked-questions">FAQ</a></li></ul></div><div class="navbar__item dropdown dropdown--hoverable"><a href="#" class="navbar__link">Community</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/community">Resources</a></li><li><a href="https://github.com/apache/superset" target="_blank" rel="noopener noreferrer" class="dropdown__link"><span>GitHub<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_I5OW"><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></span></a></li><li><a href="http://bit.ly/join-superset-slack" target="_blank" rel="noopener noreferrer" class="dropdown__link"><span>Slack<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_I5OW"><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></span></a></li><li><a href="https://lists.apache.org/list.html?dev@superset.apache.org" target="_blank" rel="noopener noreferrer" class="dropdown__link"><span>Mailing List<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_I5OW"><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></span></a></li><li><a href="https://stackoverflow.com/questions/tagged/superset+apache-superset" target="_blank" rel="noopener noreferrer" class="dropdown__link"><span>Stack Overflow<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_I5OW"><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></span></a></li></ul></div></div><div class="navbar__items navbar__items--right"><a href="https://github.com/apache/superset" target="_blank" rel="noopener noreferrer" class="navbar__item navbar__link" class="github-logo-container"></a><div class="searchBox_qEbK"><button type="button" class="DocSearch DocSearch-Button" aria-label="Search"><span class="DocSearch-Button-Container"><svg width="20" height="20" class="DocSearch-Search-Icon" viewBox="0 0 20 20"><path d="M14.386 14.386l4.0877 4.0877-4.0877-4.0877c-2.9418 2.9419-7.7115 2.9419-10.6533 0-2.9419-2.9418-2.9419-7.7115 0-10.6533 2.9418-2.9419 7.7115-2.9419 10.6533 0 2.9419 2.9418 2.9419 7.7115 0 10.6533z" stroke="currentColor" fill="none" fill-rule="evenodd" stroke-linecap="round" stroke-linejoin="round"></path></svg><span class="DocSearch-Button-Placeholder">Search</span></span><span class="DocSearch-Button-Keys"></span></button></div></div></div><div role="presentation" class="navbar-sidebar__backdrop"></div></nav><div class="main-wrapper docs-wrapper docs-doc-page"><div class="docPage_P2Lg"><button aria-label="Scroll back to top" class="clean-btn theme-back-to-top-button backToTopButton_RiI4" type="button"></button><aside class="theme-doc-sidebar-container docSidebarContainer_rKC_"><div class="sidebar_CW9Y"><nav class="menu thin-scrollbar menu_SkdO"><ul class="theme-doc-sidebar-menu menu__list"><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-1 menu__list-item"><a class="menu__link" href="/docs/intro">Introduction</a></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 class="menu__link menu__link--sublist" href="/docs/installation/installing-superset-using-docker-compose">Installation and Configuration</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 class="menu__link menu__link--sublist" href="/docs/databases/installing-database-drivers">Connecting to Databases</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 class="menu__link menu__link--sublist" href="/docs/creating-charts-dashboards/creating-your-first-dashboard">Creating Charts and Dashboards</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 class="menu__link menu__link--sublist menu__link--active" href="/docs/miscellaneous/country-map-tools">Miscellaneous</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-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/miscellaneous/country-map-tools">Country Map Tools</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/miscellaneous/importing-exporting-datasources">Importing and Exporting Datasources</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link menu__link--active" aria-current="page" tabindex="0" href="/docs/miscellaneous/issue-codes">Issue Codes</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/miscellaneous/chart-params">Chart Parameters Reference</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 class="menu__link menu__link--sublist" href="/docs/contributing/contributing-page">Contributing</a></div></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-1 menu__list-item"><a class="menu__link" href="/docs/frequently-asked-questions">Frequently Asked Questions</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-1 menu__list-item"><a class="menu__link" href="/docs/api">API</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-1 menu__list-item"><a class="menu__link" href="/docs/security">Security</a></li></ul></nav></div></aside><main class="docMainContainer_TCnq"><div class="container padding-top--md padding-bottom--lg"><div class="row"><div class="col docItemCol_DM6M"><div class="docItemContainer_vinB"><article><nav class="theme-doc-breadcrumbs breadcrumbsContainer_Xlws" aria-label="breadcrumbs"><ul class="breadcrumbs"><li class="breadcrumbs__item"><a class="breadcrumbs__link breadcrumbsItemLink_e5ie" href="/">🏠</a></li><li class="breadcrumbs__item"><span class="breadcrumbs__link breadcrumbsItemLink_e5ie">Miscellaneous</span></li><li class="breadcrumbs__item breadcrumbs__item--active"><a class="breadcrumbs__link breadcrumbsItemLink_e5ie" href="/docs/miscellaneous/issue-codes">Issue Codes</a></li></ul></nav><div class="tocCollapsible_jdIR theme-doc-toc-mobile tocMobile_TmEX"><button type="button" class="clean-btn tocCollapsibleButton_Fzxq">On this page</button></div><div class="theme-doc-markdown markdown"><h1>Issue Code Reference</h1><p>This page lists issue codes that may be displayed in
Superset and provides additional context.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1000">Issue 1000<a class="hash-link" href="#issue-1000" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">The datasource is too large to query.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>It&#x27;s likely your datasource has grown too large to run the current
query, and is timing out. You can resolve this by reducing the
size of your datasource or by modifying your query to only process a
subset of your data.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1001">Issue 1001<a class="hash-link" href="#issue-1001" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">The database is under an unusual load.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>Your query may have timed out because of unusually high load on the
database engine. You can make your query simpler, or wait until the
database is under less load and try again.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1002">Issue 1002<a class="hash-link" href="#issue-1002" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">The database returned an unexpected error.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>Your query failed because of an error that occurred on the database.
This may be due to a syntax error, a bug in your query, or some other
internal failure within the database. This is usually not an
issue within Superset, but instead a problem with the underlying
database that serves your query.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1003">Issue 1003<a class="hash-link" href="#issue-1003" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">There is a syntax error in the SQL query. Perhaps there was a misspelling or a typo.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>Your query failed because of a syntax error within the underlying query. Please
validate that all columns or tables referenced within the query exist and are spelled
correctly.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1004">Issue 1004<a class="hash-link" href="#issue-1004" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">The column was deleted or renamed in the database.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>Your query failed because it is referencing a column that no longer exists in
the underlying datasource. You should modify the query to reference the
replacement column, or remove this column from your query.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1005">Issue 1005<a class="hash-link" href="#issue-1005" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">The table was deleted or renamed in the database.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>Your query failed because it is referencing a table that no longer exists in
the underlying database. You should modify your query to reference the correct
table.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1006">Issue 1006<a class="hash-link" href="#issue-1006" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">One or more parameters specified in the query are missing.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>Your query was not submitted to the database because it&#x27;s missing one or more
parameters. You should define all the parameters referenced in the query in a
valid JSON document. Check that the parameters are spelled correctly and that
the document has a valid syntax.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1007">Issue 1007<a class="hash-link" href="#issue-1007" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">The hostname provided can&#x27;t be resolved.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>The hostname provided when adding a new database is invalid and cannot be
resolved. Please check that there are no typos in the hostname.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1008">Issue 1008<a class="hash-link" href="#issue-1008" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">The port is closed.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>The port provided when adding a new database is not open. Please check that
the port number is correct, and that the database is running and listening on
that port.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1009">Issue 1009<a class="hash-link" href="#issue-1009" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">The host might be down, and cannot be reached on the provided port.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>The host provided when adding a new database doesn&#x27;t seem to be up.
Additionally, it cannot be reached on the provided port. Please check that
there are no firewall rules preventing access to the host.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1010">Issue 1010<a class="hash-link" href="#issue-1010" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">Superset encountered an error while running a command.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>Something unexpected happened, and Superset encountered an error while
running a command. Please reach out to your administrator.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1011">Issue 1011<a class="hash-link" href="#issue-1011" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">Superset encountered an unexpected error.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>Something unexpected happened in the Superset backend. Please reach out
to your administrator.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1012">Issue 1012<a class="hash-link" href="#issue-1012" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">The username provided when connecting to a database is not valid.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>The user provided a username that doesn&#x27;t exist in the database. Please check
that the username is typed correctly and exists in the database.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1013">Issue 1013<a class="hash-link" href="#issue-1013" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">The password provided when connecting to a database is not valid.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>The user provided a password that is incorrect. Please check that the
password is typed correctly.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1014">Issue 1014<a class="hash-link" href="#issue-1014" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">Either the username or the password used are incorrect.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>Either the username provided does not exist or the password was written incorrectly. Please
check that the username and password were typed correctly.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1015">Issue 1015<a class="hash-link" href="#issue-1015" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">Either the database is spelled incorrectly or does not exist.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>Either the database was written incorrectly or it does not exist. Check that it was typed correctly.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1016">Issue 1016<a class="hash-link" href="#issue-1016" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">The schema was deleted or renamed in the database.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>The schema was either removed or renamed. Check that the schema is typed correctly and exists.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1017">Issue 1017<a class="hash-link" href="#issue-1017" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">The user doesn&#x27;t have the proper permissions to connect to the database</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>We were unable to connect to your database. Please confirm that your service account has the Viewer and Job User roles on the project.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1018">Issue 1018<a class="hash-link" href="#issue-1018" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">One or more parameters needed to configure a database are missing.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>Not all parameters required to test, create, or edit a database were present. Please double check which parameters are needed, and that they are present.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1019">Issue 1019<a class="hash-link" href="#issue-1019" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">The submitted payload has the incorrect format.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>Please check that the request payload has the correct format (eg, JSON).</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1020">Issue 1020<a class="hash-link" href="#issue-1020" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">The submitted payload has the incorrect schema.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>Please check that the request payload has the expected schema.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1021">Issue 1021<a class="hash-link" href="#issue-1021" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">Results backend needed for asynchronous queries is not configured.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>Your instance of Superset doesn&#x27;t have a results backend configured, which is needed for asynchronous queries. Please contact an administrator for further assistance.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1022">Issue 1022<a class="hash-link" href="#issue-1022" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">Database does not allow data manipulation.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>Only <code>SELECT</code> statements are allowed against this database. Please contact an administrator if you need to run DML (data manipulation language) on this database.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1023">Issue 1023<a class="hash-link" href="#issue-1023" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">CTAS (create table as select) doesn&#x27;t have a SELECT statement at the end.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>The last statement in a query run as CTAS (create table as select) MUST be a SELECT statement. Please make sure the last statement in the query is a SELECT.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1024">Issue 1024<a class="hash-link" href="#issue-1024" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">CVAS (create view as select) query has more than one statement.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>When running a CVAS (create view as select) the query should have a single statement. Please make sure the query has a single statement, and no extra semi-colons other than the last one.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1025">Issue 1025<a class="hash-link" href="#issue-1025" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">CVAS (create view as select) query is not a SELECT statement.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>When running a CVAS (create view as select) the query should be a SELECT statement. Please make sure the query has a single statement and it&#x27;s a SELECT statement.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1026">Issue 1026<a class="hash-link" href="#issue-1026" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">Query is too complex and takes too long to run.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>The submitted query might be too complex to run under the time limit defined by your Superset administrator. Please double check your query and verify if it can be optimized. Alternatively, contact your administrator to increase the timeout period.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1027">Issue 1027<a class="hash-link" href="#issue-1027" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">The database is currently running too many queries.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>The database might be under heavy load, running too many queries. Please try again later, or contact an administrator for further assistance.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1028">Issue 1028<a class="hash-link" href="#issue-1028" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">One or more parameters specified in the query are malformatted.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>The query contains one or more malformed template parameters. Please check your query and confirm that all template parameters are surround by double braces, for example, &quot;{{ ds }}&quot;. Then, try running your query again.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1029">Issue 1029<a class="hash-link" href="#issue-1029" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">The object does not exist in this database.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>Either the schema, column, or table do not exist in the database.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1030">Issue 1030<a class="hash-link" href="#issue-1030" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">The query potentially has a syntax error.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>The query might have a syntax error. Please check and run again.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1031">Issue 1031<a class="hash-link" href="#issue-1031" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">The results backend no longer has the data from the query.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>The results from the query might have been deleted from the results backend after some period. Please re-run your query.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1032">Issue 1032<a class="hash-link" href="#issue-1032" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">The query associated with the results was deleted.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>The query associated with the stored results no longer exists. Please re-run your query.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1033">Issue 1033<a class="hash-link" href="#issue-1033" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">The results stored in the backend were stored in a different format, and no longer can be deserialized.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>The query results were stored in a format that is no longer supported. Please re-run your query.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1034">Issue 1034<a class="hash-link" href="#issue-1034" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">The database port provided is invalid.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>Please check that the provided database port is an integer between 0 and 65535 (inclusive).</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1035">Issue 1035<a class="hash-link" href="#issue-1035" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">Failed to start remote query on a worker.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>The query was not started by an asynchronous worker. Please reach out to your administrator for further assistance.</p><h2 class="anchor anchorWithStickyNavbar_mojV" id="issue-1036">Issue 1036<a class="hash-link" href="#issue-1036" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_I0IT theme-code-block"><div class="codeBlockContent_wNvx"><pre tabindex="0" class="prism-code language-text codeBlock_jd64 thin-scrollbar" style="color:#393A34;background-color:#f6f8fa"><code class="codeBlockLines_mRuA"><span class="token-line" style="color:#393A34"><span class="token plain">The database was deleted.</span><br></span></code></pre><button type="button" aria-label="Copy code to clipboard" class="copyButton_wuS7 clean-btn">Copy</button></div></div><p>The operation failed because the database referenced no longer exists. Please reach out to your administrator for further assistance.</p></div><footer class="theme-doc-footer docusaurus-mt-lg"><div class="theme-doc-footer-edit-meta-row row"><div class="col"><a href="https://github.com/apache/superset/tree/master/docs/docs/miscellaneous/issue-codes.mdx" target="_blank" rel="noreferrer noopener" class="theme-edit-this-page"><svg fill="currentColor" height="20" width="20" viewBox="0 0 40 40" class="iconEdit_dcUD" aria-hidden="true"><g><path d="m34.5 11.7l-3 3.1-6.3-6.3 3.1-3q0.5-0.5 1.2-0.5t1.1 0.5l3.9 3.9q0.5 0.4 0.5 1.1t-0.5 1.2z m-29.5 17.1l18.4-18.5 6.3 6.3-18.4 18.4h-6.3v-6.2z"></path></g></svg>Edit this page</a></div><div class="col lastUpdated_foO9"></div></div></footer></article><nav class="pagination-nav docusaurus-mt-lg" aria-label="Docs pages navigation"><div class="pagination-nav__item"><a class="pagination-nav__link" href="/docs/miscellaneous/importing-exporting-datasources"><div class="pagination-nav__sublabel">Previous</div><div class="pagination-nav__label">Importing and Exporting Datasources</div></a></div><div class="pagination-nav__item pagination-nav__item--next"><a class="pagination-nav__link" href="/docs/miscellaneous/chart-params"><div class="pagination-nav__sublabel">Next</div><div class="pagination-nav__label">Chart Parameters Reference</div></a></div></nav></div></div><div class="col col--3"><div class="tableOfContents_cNA8 thin-scrollbar theme-doc-toc-desktop"><ul class="table-of-contents table-of-contents__left-border"><li><a href="#issue-1000" class="table-of-contents__link toc-highlight">Issue 1000</a></li><li><a href="#issue-1001" class="table-of-contents__link toc-highlight">Issue 1001</a></li><li><a href="#issue-1002" class="table-of-contents__link toc-highlight">Issue 1002</a></li><li><a href="#issue-1003" class="table-of-contents__link toc-highlight">Issue 1003</a></li><li><a href="#issue-1004" class="table-of-contents__link toc-highlight">Issue 1004</a></li><li><a href="#issue-1005" class="table-of-contents__link toc-highlight">Issue 1005</a></li><li><a href="#issue-1006" class="table-of-contents__link toc-highlight">Issue 1006</a></li><li><a href="#issue-1007" class="table-of-contents__link toc-highlight">Issue 1007</a></li><li><a href="#issue-1008" class="table-of-contents__link toc-highlight">Issue 1008</a></li><li><a href="#issue-1009" class="table-of-contents__link toc-highlight">Issue 1009</a></li><li><a href="#issue-1010" class="table-of-contents__link toc-highlight">Issue 1010</a></li><li><a href="#issue-1011" class="table-of-contents__link toc-highlight">Issue 1011</a></li><li><a href="#issue-1012" class="table-of-contents__link toc-highlight">Issue 1012</a></li><li><a href="#issue-1013" class="table-of-contents__link toc-highlight">Issue 1013</a></li><li><a href="#issue-1014" class="table-of-contents__link toc-highlight">Issue 1014</a></li><li><a href="#issue-1015" class="table-of-contents__link toc-highlight">Issue 1015</a></li><li><a href="#issue-1016" class="table-of-contents__link toc-highlight">Issue 1016</a></li><li><a href="#issue-1017" class="table-of-contents__link toc-highlight">Issue 1017</a></li><li><a href="#issue-1018" class="table-of-contents__link toc-highlight">Issue 1018</a></li><li><a href="#issue-1019" class="table-of-contents__link toc-highlight">Issue 1019</a></li><li><a href="#issue-1020" class="table-of-contents__link toc-highlight">Issue 1020</a></li><li><a href="#issue-1021" class="table-of-contents__link toc-highlight">Issue 1021</a></li><li><a href="#issue-1022" class="table-of-contents__link toc-highlight">Issue 1022</a></li><li><a href="#issue-1023" class="table-of-contents__link toc-highlight">Issue 1023</a></li><li><a href="#issue-1024" class="table-of-contents__link toc-highlight">Issue 1024</a></li><li><a href="#issue-1025" class="table-of-contents__link toc-highlight">Issue 1025</a></li><li><a href="#issue-1026" class="table-of-contents__link toc-highlight">Issue 1026</a></li><li><a href="#issue-1027" class="table-of-contents__link toc-highlight">Issue 1027</a></li><li><a href="#issue-1028" class="table-of-contents__link toc-highlight">Issue 1028</a></li><li><a href="#issue-1029" class="table-of-contents__link toc-highlight">Issue 1029</a></li><li><a href="#issue-1030" class="table-of-contents__link toc-highlight">Issue 1030</a></li><li><a href="#issue-1031" class="table-of-contents__link toc-highlight">Issue 1031</a></li><li><a href="#issue-1032" class="table-of-contents__link toc-highlight">Issue 1032</a></li><li><a href="#issue-1033" class="table-of-contents__link toc-highlight">Issue 1033</a></li><li><a href="#issue-1034" class="table-of-contents__link toc-highlight">Issue 1034</a></li><li><a href="#issue-1035" class="table-of-contents__link toc-highlight">Issue 1035</a></li><li><a href="#issue-1036" class="table-of-contents__link toc-highlight">Issue 1036</a></li></ul></div></div></div></div></main></div></div><footer class="footer footer--dark"><div class="container container-fluid"><div class="footer__bottom text--center"><div class="footer__copyright">Copyright © 2023,
        The <a href="https://www.apache.org/" target="_blank" rel="noreferrer">Apache Software Foundation</a>,
        Licensed under the Apache <a href="https://apache.org/licenses/LICENSE-2.0" target="_blank" rel="noreferrer">License</a>. <br>
        <small>Apache Superset, Apache, Superset, the Superset logo, and the Apache feather logo are either registered trademarks or trademarks of The Apache Software Foundation. All other products or name brands are trademarks of their respective holders, including The Apache Software Foundation.
        <a href="https://www.apache.org/" target="_blank">Apache Software Foundation</a> resources</small><br>
        <small>
        <a href="https://www.apache.org/security/" target="_blank" rel="noreferrer">Security</a>&nbsp;|&nbsp;
        <a href="https://www.apache.org/foundation/sponsorship.html" target="_blank" rel="noreferrer">Donate</a>&nbsp;|&nbsp;
        <a href="https://www.apache.org/foundation/thanks.html" target="_blank" rel="noreferrer">Thanks</a>&nbsp;|&nbsp;
        <a href="https://apache.org/events/current-event" target="_blank" rel="noreferrer">Events</a>&nbsp;|&nbsp;
        <a href="https://apache.org/licenses/" target="_blank" rel="noreferrer">License</a>
        </small></div></div></div></footer></div>
<script src="/assets/js/runtime~main.ed6925bb.js"></script>
<script src="/assets/js/main.46afaa66.js"></script>
</body>
</html>