{"version":3,"sources":["webpack:///./src/pages/docs/Connecting to Databases/crate.mdx"],"names":["_frontmatter","layoutProps","MDXLayout","DefaultLayout","MDXContent","components","props","mdxType","parentName","isMDXComponent"],"mappings":"0PAQaA,G,UAAe,S,kOAC5B,IAAMC,EAAc,CAClBD,gBAEIE,EAAYC,IACH,SAASC,EAAT,GAGZ,IAFDC,EAEC,EAFDA,WACGC,EACF,8BACD,OAAO,YAACJ,EAAD,eAAeD,EAAiBK,EAAhC,CAAuCD,WAAYA,EAAYE,QAAQ,cAG5E,iBAAQ,CACN,GAAM,WADR,WAGA,0EACF,6BAAGC,WAAW,KAAQ,CAChB,KAAQ,oCADd,SADE,kJAOA,uBAAK,gCAAMA,WAAW,OAAU,IAA3B,gCAEL,gFACA,uBAAK,gCAAMA,WAAW,OAAU,IAA3B,yC,gOAMTJ,EAAWK,gBAAiB","file":"component---src-pages-docs-connecting-to-databases-crate-mdx-dc678025cf0c078d2c6a.js","sourcesContent":["import * as React from 'react'\n  /* @jsx mdx */\nimport { mdx } from '@mdx-js/react';\n/* @jsxRuntime classic */\n\n/* @jsx mdx */\n\nimport DefaultLayout from \"/home/runner/work/superset/superset/docs/node_modules/gatsby-theme-docz/src/base/Layout.js\";\nexport const _frontmatter = {};\nconst layoutProps = {\n  _frontmatter\n};\nconst MDXLayout = DefaultLayout;\nexport default function MDXContent({\n  components,\n  ...props\n}) {\n  return <MDXLayout {...layoutProps} {...props} components={components} mdxType=\"MDXLayout\">\n\n\n    <h2 {...{\n      \"id\": \"cratedb\"\n    }}>{`CrateDB`}</h2>\n    <p>{`The recommended connector library for CrateDB is\n`}<a parentName=\"p\" {...{\n        \"href\": \"https://pypi.org/project/crate/\"\n      }}>{`crate`}</a>{`.\nYou need to install the extras as well for this library.\nWe recommend adding something like the following\ntext to your requirements file:`}</p>\n    <pre><code parentName=\"pre\" {...{}}>{`crate[sqlalchemy]==0.26.0\n`}</code></pre>\n    <p>{`The expected connection string is formatted as follows:`}</p>\n    <pre><code parentName=\"pre\" {...{}}>{`crate://crate@127.0.0.1:4200\n`}</code></pre>\n\n    </MDXLayout>;\n}\n;\nMDXContent.isMDXComponent = true;\n      "],"sourceRoot":""}