连接到数据库

Superset 并不自带数据库连接功能。将 Superset 连接到数据库的主要步骤是在您的环境中安装正确的数据库驱动程序。

note

您需要为作为元数据数据库的目标数据库安装所需的包，同时也要安装通过 Superset 访问其他数据库所需的包。关于设置 Superset 的元数据数据库的信息，请参阅安装文档(Docker Compose, Kubernetes)。

此文档试图保留对常用数据库引擎的不同驱动程序的引用。

安装数据库驱动程序

Superset 需要为每个想要连接的数据库引擎安装 Python DB-API 数据库驱动程序以及 SQLAlchemy 方言。

你可以在这里阅读更多关于如何在 Docker 镜像中安装新的数据库驱动程序，以便配置你的 Superset 环境。

支持的数据库和依赖项

下面列出了一些推荐的包。关于与 Superset 兼容的版本，请参阅 pyproject.toml。

Database	PyPI package	Connection String
AWS Athena	`pip install pyathena[pandas]` , `pip install PyAthenaJDBC`	`awsathena+rest://{access_key_id}:{access_key}@athena.{region}.amazonaws.com/{schema}?s3_staging_dir={s3_staging_dir}&...`
AWS DynamoDB	`pip install pydynamodb`	`dynamodb://{access_key_id}:{secret_access_key}@dynamodb.{region_name}.amazonaws.com?connector=superset`
AWS Redshift	`pip install sqlalchemy-redshift`	`redshift+psycopg2://<userName>:<DBPassword>@<AWS End Point>:5439/<Database Name>`
Apache Doris	`pip install pydoris`	`doris://<User>:<Password>@<Host>:<Port>/<Catalog>.<Database>`
Apache Drill	`pip install sqlalchemy-drill`	`drill+sadrill:// For JDBC drill+jdbc://`
Apache Druid	`pip install pydruid`	`druid://<User>:<password>@<Host>:<Port-default-9088>/druid/v2/sql`
Apache Hive	`pip install pyhive`	`hive://hive@{hostname}:{port}/{database}`
Apache Impala	`pip install impyla`	`impala://{hostname}:{port}/{database}`
Apache Kylin	`pip install kylinpy`	`kylin://<username>:<password>@<hostname>:<port>/<project>?<param1>=<value1>&<param2>=<value2>`
Apache Pinot	`pip install pinotdb`	`pinot://BROKER:5436/query?server=http://CONTROLLER:5983/`
Apache Solr	`pip install sqlalchemy-solr`	`solr://{username}:{password}@{hostname}:{port}/{server_path}/{collection}`
Apache Spark SQL	`pip install pyhive`	`hive://hive@{hostname}:{port}/{database}`
Ascend.io	`pip install impyla`	`ascend://{username}:{password}@{hostname}:{port}/{database}?auth_mechanism=PLAIN;use_ssl=true`
Azure MS SQL	`pip install pymssql`	`mssql+pymssql://UserName@presetSQL:TestPassword@presetSQL.database.windows.net:1433/TestSchema`
ClickHouse	`pip install clickhouse-connect`	`clickhousedb://{username}:{password}@{hostname}:{port}/{database}`
CockroachDB	`pip install cockroachdb`	`cockroachdb://root@{hostname}:{port}/{database}?sslmode=disable`
CouchbaseDB	`pip install couchbase-sqlalchemy`	`couchbasedb://{username}:{password}@{hostname}:{port}?truststorepath={ssl certificate path}`
Dremio	`pip install sqlalchemy_dremio`	`dremio://user:pwd@host:31010/`
Elasticsearch	`pip install elasticsearch-dbapi`	`elasticsearch+http://{user}:{password}@{host}:9200/`
Exasol	`pip install sqlalchemy-exasol`	`exa+pyodbc://{username}:{password}@{hostname}:{port}/my_schema?CONNECTIONLCALL=en_US.UTF-8&driver=EXAODBC`
Google BigQuery	`pip install sqlalchemy-bigquery`	`bigquery://{project_id}`
Google Sheets	`pip install shillelagh[gsheetsapi]`	`gsheets://`
Firebolt	`pip install firebolt-sqlalchemy`	`firebolt://{client_id}:{client_secret}@{database}/{engine_name}?account_name={name}`
Hologres	`pip install psycopg2`	`postgresql+psycopg2://<UserName>:<DBPassword>@<Database Host>/<Database Name>`
IBM Db2	`pip install ibm_db_sa`	`db2+ibm_db://`
IBM Netezza Performance Server	`pip install nzalchemy`	`netezza+nzpy://<UserName>:<DBPassword>@<Database Host>/<Database Name>`
MySQL	`pip install mysqlclient`	`mysql://<UserName>:<DBPassword>@<Database Host>/<Database Name>`
OceanBase	`pip install oceanbase_py`	`oceanbase://<UserName>:<DBPassword>@<Database Host>/<Database Name>`
Oracle	`pip install cx_Oracle`	`oracle://`
PostgreSQL	`pip install psycopg2`	`postgresql://<UserName>:<DBPassword>@<Database Host>/<Database Name>`
Presto	`pip install pyhive`	`presto://`
Rockset	`pip install rockset-sqlalchemy`	`rockset://<api_key>:@<api_server>`
SAP Hana	`pip install hdbcli sqlalchemy-hana` or `pip install apache-superset[hana]`	`hana://{username}:{password}@{host}:{port}`
StarRocks	`pip install starrocks`	`starrocks://<User>:<Password>@<Host>:<Port>/<Catalog>.<Database>`
Snowflake	`pip install snowflake-sqlalchemy`	`snowflake://{user}:{password}@{account}.{region}/{database}?role={role}&warehouse={warehouse}`
SQLite	No additional library needed	`sqlite://path/to/file.db?check_same_thread=false`
SQL Server	`pip install pymssql`	`mssql+pymssql://`
Teradata	`pip install teradatasqlalchemy`	`teradatasql://{user}:{password}@{host}`
TimescaleDB	`pip install psycopg2`	`postgresql://<UserName>:<DBPassword>@<Database Host>:<Port>/<Database Name>`
Trino	`pip install trino`	`trino://{username}:{password}@{hostname}:{port}/{catalog}`
Vertica	`pip install sqlalchemy-vertica-python`	`vertica+vertica_python://<UserName>:<DBPassword>@<Database Host>/<Database Name>`
YugabyteDB	`pip install psycopg2`	`postgresql://<UserName>:<DBPassword>@<Database Host>/<Database Name>`

请注意，支持许多其他数据库，主要标准是存在功能性的 SQLAlchemy 方言和 Python 驱动程序。搜索关键词"sqlalchemy + (数据库名称)"应该能帮助你找到正确的地方。

如果你的数据库或数据引擎不在列表上，但存在 SQL 接口，请在 Superset GitHub 仓库上提交问题，这样我们可以着手进行文档编写和支持工作。

如果你想为 Superset 集成构建 database connector，请阅读以下教程。

在 Docker 镜像中安装驱动程序

对于你想要连接的每种额外类型的数据库，Superset 都需要安装一个 Python 数据库驱动程序。

在这个示例中，我们将逐步介绍如何安装 MySQL 连接库。连接库的安装过程对所有额外的库都是一样的。

1. 确定你需要的驱动程序

查阅数据库驱动程序列表，找到连接到你的数据库所需的 PyPI 包。在这个示例中，我们正在连接到 MySQL 数据库，因此我们需要 mysqlclient 连接库。

2. Install the driver in the container

We need to get the mysqlclient library installed into the Superset docker container (it doesn't matter if it's installed on the host machine). We could enter the running container with docker exec -it <container_name> bash and run pip install mysqlclient there, but that wouldn't persist permanently.

2. 在容器中安装驱动程序

我们需要将 mysqlclient 库安装到 Superset 的 Docker 容器中（无论它是否已安装在主机上）。我们可以使用 docker exec -it <container_name> bash 进入运行中的容器，并在那里运行 pip install mysqlclient，但这不会永久保留。

为了解决这个问题，Superset 的 docker compose 部署使用了 requirements-local.txt 文件的约定。此文件中列出的所有包将在运行时从 PyPI 安装到容器中。出于本地开发的目的，Git 将会忽略这个文件。

在包含你的 docker-compose.yml 或 docker-compose-non-dev.yml 文件的目录下的一个名为 docker 的子目录中创建 requirements-local.txt 文件。

# 从仓库根目录运行：
touch ./docker/requirements-local.txt

添加在上面步骤中确定的驱动程序。你可以使用文本编辑器，或者像下面这样从命令行操作：

echo "mysqlclient" >> ./docker/requirements-local.txt

如果你正在运行标准的（未定制的）Superset 镜像，那么你就完成了。使用 docker compose -f docker-compose-non-dev.yml up 启动 Superset，驱动程序应该已经存在。

你可以通过使用 docker exec -it <container_name> bash 进入运行中的容器并运行 pip freeze 来检查它的存在。打印出的列表中应该包含该 PyPI 包。

如果你正在运行自定义的 Docker 镜像，则需要重新构建你的本地镜像，以便将新的驱动程序包含在内：

docker compose build --force-rm

在 Docker 镜像重建完成后，通过运行 docker compose up 重新启动 Superset。

3. 连接到 MySQL

现在你已经在容器中安装了 MySQL 驱动程序，你应该能够通过 Superset 的 Web 界面连接到你的数据库。

作为管理员用户，转到 Settings -> Data: Database Connections 并点击 +DATABASE 按钮。从那里开始，按照使用数据库连接 UI 页面上的步骤操作。

查阅 Superset 文档中特定数据库类型的页面，以确定连接字符串和你需要输入的任何其他参数。例如，在 MySQL 页面上，我们看到连接到本地 MySQL 数据库的连接字符串根据是在 Linux 还是 Mac 上运行而有所不同。

点击 “Test Connection” 按钮，这应该会弹出一个消息框，显示 "Connection looks good!"。

4. 故障排除

如果测试失败，请查看你的 Docker 日志以查找错误消息。 Superset 使用 SQLAlchemy 连接到数据库；为了排查你的数据库连接字符串的问题，你可以在 Superset 应用程序容器或主机环境中启动 Python，并尝试直接连接到所需的数据库并获取数据。这样做可以排除 Superset，从而隔离问题。

对于你希望 Superset 连接到的每种类型的数据库，重复这一过程。

特定于数据库的说明

Ascend.io

连接到 Ascend.io 推荐的连接库是impyla。

预期的连接字符串格式如下：

ascend://{username}:{password}@{hostname}:{port}/{database}?auth_mechanism=PLAIN;use_ssl=true

Apache Doris

通过 SQLAlchemy 连接到 Apache Doris 的推荐方式是使用sqlalchemy-doris库。

你需要以下设置值来形成连接字符串：

User: 用户名
Password: 密码
Host: Doris FE 主机
Port: Doris FE 端口
Catalog: 目录名称
Database: 数据库名称

连接字符串看起来像这样：

doris://<User>:<Password>@<Host>:<Port>/<Catalog>.<Database>

AWS Athena

PyAthenaJDBC

PyAthenaJDBC 是符合 Python DB 2.0 标准的封装，用于 Amazon Athena JDBC驱动程序。

Amazon Athena的连接字符串如下所示：

awsathena+jdbc://{aws_access_key_id}:{aws_secret_access_key}@athena.{region_name}.amazonaws.com/{schema_name}?s3_staging_dir={s3_staging_dir}&...

注意，在形成连接字符串时，你需要进行转义和编码(escape & encode)，如下所示：

s3://... -> s3%3A//...

PyAthena

你也可以使用 PyAthena 库（无需 Java ）与以下连接字符串一起使用：

awsathena+rest://{aws_access_key_id}:{aws_secret_access_key}@athena.{region_name}.amazonaws.com/{schema_name}?s3_staging_dir={s3_staging_dir}&...

PyAthena 库还允许承担特定的 IAM 角色，你可以在 Superset 的 Athena 数据库连接 UI 的 ADVANCED --> Other --> ENGINE PARAMETERS 下通过添加以下参数来定义。

{
    "connect_args": {
        "role_arn": "<role arn>"
    }
}

AWS DynamoDB

PyDynamoDB

PyDynamoDB 是 Amazon DynamoDB 的 Python DB API 2.0（PEP 249）客户端。

Amazon DynamoDB 的连接字符串如下所示：

dynamodb://{aws_access_key_id}:{aws_secret_access_key}@dynamodb.{region_name}.amazonaws.com:443?connector=superset

要获取更多文档，请访问：PyDynamoDB WIKI。

AWS Redshift

sqlalchemy-redshift 库是通过 SQLAlchemy 连接到 Redshift 的推荐方式。

此方言需要 redshift_connector 或 psycopg2 才能正常工作。

为了形成连接字符串，你需要设置以下值：

User Name: userName
Password: DBPassword
Database Host: AWS Endpoint
Database Name: Database Name
Port: default 5439

psycopg2

SQLALCHEMY URI 看起来像这样：

redshift+psycopg2://<userName>:<DBPassword>@<AWS End Point>:5439/<Database Name>

redshift_connector

SQLALCHEMY URI 看起来像这样：

redshift+redshift_connector://<userName>:<DBPassword>@<AWS End Point>:5439/<Database Name>

使用基于 IAM 的凭证与 Redshift 集群：

Amazon Redshift 集群也支持生成临时的基于 IAM 的数据库用户凭证。

你的 Superset 应用的 IAM 角色应具有权限，以调用 redshift:GetClusterCredentials 操作。

你必须在 Superset 的 Redshift 数据库连接 UI 的 ADVANCED --> Others --> ENGINE PARAMETERS 下定义以下参数。

{"connect_args":{"iam":true,"database":"<database>","cluster_identifier":"<cluster_identifier>","db_user":"<db_user>"}}

并且 SQLALCHEMY URI 应设置为 redshift+redshift_connector://

使用基于 IAM 的凭证与 Redshift serverless：

Redshift serverless支持使用IAM角色进行连接。

你的 Superset 应用的 IAM 角色应在 RRedshift serverless workgroup 上具有 redshift-serverless:GetCredentials 和 redshift-serverless:GetWorkgroup 权限。

你必须在 Superset 的 Redshift 数据库连接 UI 的 ADVANCED --> Others --> ENGINE PARAMETERS 下定义以下参数。

{"connect_args":{"iam":true,"is_serverless":true,"serverless_acct_id":"<aws account number>","serverless_work_group":"<redshift work group>","database":"<database>","user":"IAMR:<superset iam role name>"}}

ClickHouse

要使用 ClickHouse 与 Superset 一起，你需要安装 clickhouse-connect Python 库：

如果使用 Docker Compose 运行 Superset，请在你的 ./docker/requirements-local.txt 文件中添加以下内容：

clickhouse-connect>=0.6.8

ClickHouse 推荐的连接库是 clickhouse-connect。

预期的连接字符串格式如下：

clickhousedb://<user>:<password>@<host>:<port>/<database>[?options…]clickhouse://{username}:{password}@{hostname}:{port}/{database}

这里有一个实际连接字符串的具体示例：

clickhousedb://demo:demo@github.demo.trial.altinity.cloud/default?secure=true

如果你在计算机上本地使用 Clickhouse，你可以使用 http 协议 URL，该 URL 使用默认用户且无需密码（并且不加密连接）：

clickhousedb://localhost/default

CockroachDB

CockroachDB 推荐的连接库是 sqlalchemy-cockroachdb。

预期的连接字符串格式如下：

cockroachdb://root@{hostname}:{port}/{database}?sslmode=disable

CouchbaseDB

CouchbaseDB 推荐的连接库是 couchbase-sqlalchemy。

pip install couchbase-sqlalchemy

预期的连接字符串格式如下：

couchbasedb://{username}:{password}@{hostname}:{port}?truststorepath={certificate path}?ssl={true/false}

CrateDB

CrateDB 推荐的连接库是 crate。你需要为这个库同时安装额外组件。我们建议在你的 requirements 文件中添加类似以下的文本：

crate[sqlalchemy]==0.26.0

预期的连接字符串格式如下：

crate://crate@127.0.0.1:4200

Databend

Databend 推荐的连接库是databend-sqlalchemy。 Superset 已经在 databend-sqlalchemy>=0.2.3 上进行了测试。

推荐的连接字符串是：

databend://{username}:{password}@{host}:{port}/{database_name}

这是 Superset 连接到 Databend 数据库的连接字符串示例：

databend://user:password@localhost:8000/default?secure=false

Databricks

Databricks 现在提供了一个原生的 DB API 2.0 驱动程序 databricks-sql-connector，可以与 sqlalchemy-databricks 方言一起使用。你可以使用以下命令安装两者：

pip install "apache-superset[databricks]"

要使用 Hive connector，你需要从集群中获取以下信息：

Server hostname
Port
HTTP path

这些信息可以在 "Configuration" -> "Advanced Options" -> "JDBC/ODBC" 下找到。

你还需要从 "Settings" -> "User Settings" -> "Access Tokens" 获取一个访问令牌。

一旦你拥有所有这些信息，添加一个类型为 "Databricks Native Connector" 的数据库，并使用以下 SQLAlchemy URI：

databricks+connector://token:{access_token}@{server_hostname}:{port}/{database_name}

你还需要在 "Other" -> "Engine Parameters" 中添加以下配置，其中包含你的 HTTP 路径：

{
    "connect_args": {"http_path": "sql/protocolv1/o/****"}
}

较旧的驱动程序

最初，Superset 使用 databricks-dbapi 连接到 Databricks。如果你在官方 Databricks 连接器遇到问题，你可能想要尝试使用它：

pip install "databricks-dbapi[sqlalchemy]"

使用 databricks-dbapi 连接到 Databricks 有两种方式：使用 Hive connector 或 ODBC connector。这两种方式的工作原理相似，但只有 ODBC 可以用于连接到 SQL 终端。

Hive

要连接到 Hive 集群，在 Superset 中添加一个类型为 "Databricks Interactive Cluster" 的数据库，并使用以下 SQLAlchemy URI：

databricks+pyhive://token:{access_token}@{server_hostname}:{port}/{database_name}

你还需要在 "Other" -> "Engine Parameters" 中添加以下配置，其中包含你的 HTTP 路径：

{"connect_args": {"http_path": "sql/protocolv1/o/****"}}

ODBC

对于 ODBC，首先需要为你的平台安装ODBC 驱动程序。

根据你的使用场景，选择"数据库"下的 "Databricks Interactive Cluster" 或 "Databricks SQL Endpoint" 后，对于常规连接，可以将此作为 SQLAlchemy URI 使用：

databricks+pyodbc://token:{access_token}@{server_hostname}:{port}/{database_name}

对于连接参数：

{"connect_args": {"http_path": "sql/protocolv1/o/****", "driver_path": "/path/to/odbc/driver"}}

驱动程序路径应该是：

/Library/simba/spark/lib/libsparkodbc_sbu.dylib (Mac OS)
/opt/simba/spark/lib/64/libsparkodbc_sb64.so (Linux)

对于连接到 SQL endpoint，你需要使用来自 endpoint 的 HTTP 路径：

{"connect_args": {"http_path": "/sql/1.0/endpoints/****", "driver_path": "/path/to/odbc/driver"}}

Dremio

Dremio推荐的连接库是 sqlalchemy_dremio。

ODBC 的预期连接字符串（默认端口为 31010）格式如下：

dremio://{username}:{password}@{host}:{port}/{database_name}/dremio?SSL=1

Arrow Flight 的预期连接字符串（Dremio 4.9.1+。默认端口为 32010）格式如下：

dremio+flight://{username}:{password}@{host}:{port}/dremio

这篇 Dremio 的博客文章提供了关于将 Superset 连接到 Dremio 的一些额外有用的说明。

Apache Drill

SQLAlchemy

推荐通过 SQLAlchemy 连接到 Apache Drill。你可以使用 sqlalchemy-drill 包。

完成上述操作后，你可以通过两种方式连接到 Drill，要么通过 REST 接口，要么通过 JDBC。如果你通过 JDBC 连接，你必须安装 Drill JDBC 驱动程序。

Drill 的基本连接字符串看起来像这样：

drill+sadrill://<username>:<password>@<host>:<port>/<storage_plugin>?use_ssl=True

要连接到以嵌入模式在本地机器上运行的 Drill，你可以使用以下连接字符串：

drill+sadrill://localhost:8047/dfs?use_ssl=False

JDBC

通过 JDBC 连接到 Drill 更为复杂，我们建议遵循这个教程。

连接字符串看起来像：

drill+jdbc://<username>:<password>@<host>:<port>

ODBC

我们建议阅读 Apache Drill 文档并阅读 GitHub README，了解如何通过 ODBC 与 Drill 一起工作。

Apache Druid

Superset 附带了一个原生的 Druid 连接器（位于DRUID_IS_ACTIVE标志之后），但为了支持在 pydruid 库中提供的 SQLAlchemy / DBAPI 连接器，它正逐渐被弃用。

连接字符串看起来像：

druid://<User>:<password>@<Host>:<Port-default-9088>/druid/v2/sql

这是此连接字符串关键组成部分的分解：

User：连接到数据库所需凭据的用户名部分
Password：连接到数据库所需凭据的密码部分
Host：运行数据库的主机的 IP 地址（或 URL）
Port：在运行数据库的主机上暴露的具体端口

自定义 Druid 连接

在添加 Druid 连接时，你可以在Add Database表单中以几种不同的方式自定义连接。

自定义证书

在配置新的数据库连接到 Druid 时，你可以在 Root Certificate 字段中添加证书：

当使用自定义证书时，pydruid 将自动使用 https 方案。

禁用 SSL 验证

要禁用 SSL 验证，请在 Extras 字段中添加以下内容：

engine_params:
{"connect_args":
	{"scheme": "https", "ssl_verify_cert": false}}

Aggregations

常见的聚合或 Druid 指标可以在 Superset 中定义和使用。最简单和第一个使用场景是在数据源编辑视图中使用显示的复选框矩阵（Sources -> Druid Datasources -> [your datasource] -> Edit -> [tab] List Druid Column）。

在 Explore 视图中，点击 GroupBy 和 Filterable 复选框会使列出现在相关的下拉菜单中。选中 Count Distinct（计数唯一值）、Min（最小值）、Max（最大值）或Sum（求和）会在保存数据源后在 List Druid Metric 标签页中创建新指标并出现。

通过编辑这些指标，你会注意到它们的 JSON 元素对应于 Druid 聚合定义。你可以按照 Druid 文档手动从 List Druid Metric 标签页创建自己的聚合。

Post-Aggregations

Druid 支持后聚合，这在 Superset 中有效。你所需要做的就是创建一个指标，就像你手动创建聚合一样，但是将 postagg 指定为 Metric Type。然后，你必须在 JSON 字段中提供有效的 json 后聚合定义（如 Druid 文档中所述）。

Elasticsearch

Elasticsearch 推荐的连接库是 elasticsearch-dbapi。

Elasticsearch 的连接字符串看起来像这样：

elasticsearch+http://{user}:{password}@{host}:9200/

Using HTTPS

elasticsearch+https://{user}:{password}@{host}:9200/

Elasticsearch 默认限制为 10000 行，因此你可以在集群上增加此限制，或者在配置中设置 Superset 的行限制。

ROW_LIMIT = 10000

例如，你可以在 SQL Lab 中查询多个索引。

SELECT timestamp, agent FROM "logstash"

但是，要使用多个索引的可视化，你需要在集群上创建别名索引。

POST /_aliases
{
    "actions" : [
        { "add" : { "index" : "logstash-**", "alias" : "logstash_all" } }
    ]
}

然后使用别名 logstash_all 注册你的表。

Time zone

默认情况下，Superset 在 elasticsearch 查询中使用 UTC 时区。如果你需要指定时区，请编辑你的数据库，并在 Other > ENGINE PARAMETERS 中输入你指定时区的设置：

{
    "connect_args": {
        "time_zone": "Asia/Shanghai"
    }
}

关于时区问题的另一个需要注意的问题是，在 elasticsearch7.8 之前，如果你想将字符串转换为 DATETIME 对象，你需要使用 CAST 函数，但此函数不支持我们的 time_zone 设置。因此，建议升级到 elasticsearch7.8 后的版本。在 elasticsearch7.8 之后，你可以使用 DATETIME_PARSE 函数来解决这个问题。 DATETIME_PARSE 函数是为了支持我们的 time_zone 设置，这里你需要在 Other > VERSION 设置中填写你的 elasticsearch 版本号。 superset 将使用 DATETIME_PARSE 函数进行转换。

禁用 SSL 验证

要禁用 SSL 验证，请在 SQLALCHEMY URI 字段中添加以下内容：

elasticsearch+https://{user}:{password}@{host}:9200/?verify_certs=False

Exasol

Exasol 推荐的连接库是 sqlalchemy-exasol。

Exasol 的连接字符串看起来像这样：

exa+pyodbc://{username}:{password}@{hostname}:{port}/my_schema?CONNECTIONLCALL=en_US.UTF-8&driver=EXAODBC

Firebird

Firebird 推荐的连接库是 sqlalchemy-firebird。 Superset 已在 sqlalchemy-firebird>=0.7.0, <0.8 上进行了测试。

推荐的连接字符串是：

firebird+fdb://{username}:{password}@{host}:{port}//{path_to_db_file}

这是一个 Superset 连接到本地 Firebird 数据库的连接字符串示例：

firebird+fdb://SYSDBA:masterkey@192.168.86.38:3050//Library/Frameworks/Firebird.framework/Versions/A/Resources/examples/empbuild/employee.fdb

Firebolt

Firebolt 推荐的连接库是 firebolt-sqlalchemy。

推荐的连接字符串是：

firebolt://{username}:{password}@{database}?account_name={name}
or
firebolt://{username}:{password}@{database}/{engine_name}?account_name={name}

也可以使用服务帐户进行连接：

firebolt://{client_id}:{client_secret}@{database}?account_name={name}
or
firebolt://{client_id}:{client_secret}@{database}/{engine_name}?account_name={name}

Google BigQuery

BigQuery 推荐的连接库是 sqlalchemy-bigquery。

安装 BigQuery 驱动程序

在通过 docker compose 本地设置 Superset 时，有关如何安装新数据库驱动程序的步骤，请参阅此处。

echo "sqlalchemy-bigquery" >> ./docker/requirements-local.txt

连接到 BigQuery

在 Superset 中添加新的 BigQuery 连接时，你需要添加 GCP 服务帐户的凭据文件（as a JSON）。

通过 Google Cloud Platform 控制面板创建你的服务帐户，为其提供对适当的 BigQuery 数据集的访问权限，并下载 service account 的 JSON 配置文件。
在 Superset 中，你可以上传该 JSON，或者以以下格式添加 JSON 块（这应该是你的凭据 JSON 文件的内容）：

{
        "type": "service_account",
        "project_id": "...",
        "private_key_id": "...",
        "private_key": "...",
        "client_email": "...",
        "client_id": "...",
        "auth_uri": "...",
        "token_uri": "...",
        "auth_provider_x509_cert_url": "...",
        "client_x509_cert_url": "..."
    }

CleanShot 2021-10-22 at 04 18 11

另外，也可以通过 SQLAlchemy URI 进行连接

BigQuery的连接字符串看起来像：

bigquery://{project_id}

转到 Advanced 选项卡，在数据库配置表单的 Secure Extra 字段中添加 JSON 块，格式如下：

{
"credentials_info": <contents of credentials JSON file>
}

生成的文件应具有以下结构：

{
 "credentials_info": {
     "type": "service_account",
     "project_id": "...",
     "private_key_id": "...",
     "private_key": "...",
     "client_email": "...",
     "client_id": "...",
     "auth_uri": "...",
     "token_uri": "...",
     "auth_provider_x509_cert_url": "...",
     "client_x509_cert_url": "..."
     }
 }

你应该能够连接到你的 BigQuery 数据集。

CleanShot 2021-10-22 at 04 47 08

要在 Superset 中将 CSV 或 Excel 文件上传到 BigQuery，你还需要添加 pandas_gbq 库。

目前，由于 gevent 对 Python 核心库进行了一些动态 monkeypatching，Google BigQuery Python SDK 与 gevent 不兼容。因此，当你使用 gunicorn 服务器部署 Superset 时，你必须使用除 gevent 之外的 worker 类型。

Google Sheets

Google Sheets 有一个非常有限的 SQL API。 Google Sheets 推荐的连接库是 shillelagh。

将 Superset 连接到 Google Sheets 涉及几个步骤。这个 tutorial 提供了最新的设置此连接的说明。

Hana

推荐的连接库是 sqlalchemy-hana。

连接字符串的格式如下：

hana://{username}:{password}@{host}:{port}

Apache Hive

通过 SQLAlchemy 连接到 Hive 的推荐方式是使用 pyhive 库。

预期的连接字符串格式如下：

hive://hive@{hostname}:{port}/{database}

Hologres

Hologres 是由阿里云开发的实时交互式分析服务。它与 PostgreSQL 11 完全兼容，并且与大数据生态系统无缝集成。

Hologres 示例连接参数：

User Name：你的阿里云账户的 AccessKey ID。
Password：你的阿里云账户的 AccessKey 密钥。
Database Host：Hologres 实例的公共端点。
Database Name：Hologres 数据库的名称。
Port：Hologres 实例的端口号。

连接字符串看起来像：

postgresql+psycopg2://{username}:{password}@{host}:{port}/{database}

IBM DB2

IBM_DB_SA 库为 IBM 数据服务器提供了 Python / SQLAlchemy 接口。

这是推荐的连接字符串：

db2+ibm_db://{username}:{passport}@{hostname}:{port}/{database}

SQLAlchemy 实现了两个 DB2 方言版本。如果你连接的是没有 LIMIT [n] 语法的 DB2 版本，为了能够使用 SQL Lab，推荐的连接字符串是：

ibm_db_sa://{username}:{passport}@{hostname}:{port}/{database}

Apache Impala

连接到 Apache Impala 的推荐连接库是 impyla。

预期的连接字符串格式如下：

impala://{hostname}:{port}/{database}

Kusto

Kusto 推荐的连接库是sqlalchemy-kusto>=2.0.0。

Kusto（sql 方言）的连接字符串看起来像这样：

kustosql+https://{cluster_url}/{database}?azure_ad_client_id={azure_ad_client_id}&azure_ad_client_secret={azure_ad_client_secret}&azure_ad_tenant_id={azure_ad_tenant_id}&msi=False

Kusto（kql 方言）的连接字符串看起来像这样：

kustokql+https://{cluster_url}/{database}?azure_ad_client_id={azure_ad_client_id}&azure_ad_client_secret={azure_ad_client_secret}&azure_ad_tenant_id={azure_ad_tenant_id}&msi=False

确保用户拥有访问和使用所有所需 databases/tables/views 的权限。

Apache Kylin

Apache Kylin 推荐的连接库是 kylinpy。

预期的连接字符串格式如下：

kylin://<username>:<password>@<hostname>:<port>/<project>?<param1>=<value1>&<param2>=<value2>

MySQL

MySQL 推荐的连接库是 mysqlclient。

这是连接字符串：

mysql://{username}:{password}@{host}/{database}

Host:

对于本地主机：localhost 或 127.0.0.1
在 Linux 上运行的 Docker：172.18.0.1
对于内部部署：IP 地址或主机名
对于在 OSX 上运行的 Docker：docker.for.mac.host.internal 端口：默认为3306

mysqlclient 的一个问题是，它无法连接使用 caching_sha2_password 进行身份验证的较新的 MySQL 数据库，因为该插件未包含在客户端中。在这种情况下，你应该改用 mysql-connector-python：

mysql+mysqlconnector://{username}:{password}@{host}/{database}

IBM Netezza Performance Server

nzalchemy库为 IBM Netezza Performance Server（即 Netezza）提供了 Python / SQLAlchemy 接口。

这是推荐的连接字符串：

netezza+nzpy://{username}:{password}@{hostname}:{port}/{database}

OceanBase

sqlalchemy-oceanbase库是通过 SQLAlchemy 连接到 OceanBase 的推荐方式。

OceanBase 的连接字符串看起来像这样：

oceanbase://<User>:<Password>@<Host>:<Port>/<Database>

Ocient DB

Ocient 推荐的连接库是 sqlalchemy-ocient。

安装 Ocient Driver

pip install sqlalchemy-ocient

连接到 Ocient

Ocient DSN 的格式是：

ocient://user:password@[host][:port][/database][?param1=value1&...]

Oracle

推荐的连接库是 cx_Oracle。

连接字符串的格式如下：

oracle://<username>:<password>@<hostname>:<port>

Apache Pinot

Apache Pinot 推荐的连接库是 pinotdb。

预期的连接字符串格式如下：

pinot+http://<pinot-broker-host>:<pinot-broker-port>/query?controller=http://<pinot-controller-host>:<pinot-controller-port>/``

使用用户名和密码的预期连接字符串格式如下：

pinot://<username>:<password>@<pinot-broker-host>:<pinot-broker-port>/query/sql?controller=http://<pinot-controller-host>:<pinot-controller-port>/verify_ssl=true``

如果你想使用探索视图或联接，窗口函数等，则启用 multi-stage 查询引擎。在 Advanced -> Other -> ENGINE PARAMETERS 中创建数据库连接时添加以下参数。

{"connect_args":{"use_multistage_engine":"true"}}

Postgres

请注意，如果你正在使用 docker compose，Postgres 连接库 psycopg2 是 Superset 自带的。

Postgres 示例连接参数：

User Name: 用户名
Password: 密码
Database Host:
- 对于本地主机：localhost 或 127.0.0.1
- 对于内部部署：IP 地址或主机名
- 对于 AWS Endpoint
Database Name: 数据库名称
Port: ：默认 5432

连接字符串看起来像：

postgresql://{username}:{password}@{host}:{port}/{database}

你可以在末尾添加 ?sslmode=require 来要求使用 SSL：

postgresql://{username}:{password}@{host}:{port}/{database}?sslmode=require

你可以从这份文档中的表 31-1阅读 Postgres 支持的其他 SSL 模式。

关于 PostgreSQL 连接选项的更多信息可以在 SQLAlchemy 文档和 PostgreSQL 文档中找到。

Presto

pyhive 库是通过 SQLAlchemy 连接到 Presto 的推荐方式。

预期的连接字符串格式如下：

presto://{hostname}:{port}/{database}

你也可以传递用户名和密码：

presto://{username}:{password}@{hostname}:{port}/{database}

这是一个带有值的示例连接字符串：

presto://datascientist:securepassword@presto.example.com:8080/hive

默认情况下，Superset 在查询数据源时假定使用的是 Presto 的最新版本。如果你正在使用 Presto 的旧版本，你可以在额外参数中配置它：

{
    "version": "0.123"
}

SSL 安全额外添加 JSON 配置到额外的连接信息中。

   {
     "connect_args":
    {"protocol": "https",
     "requests_kwargs":{"verify":false}
  }
}

RisingWave

RisingWave 推荐的连接库是 sqlalchemy-risingwave。

预期的连接字符串格式如下：

risingwave://root@{hostname}:{port}/{database}?sslmode=disable

Rockset

Rockset 的连接字符串是：

rockset://{api key}:@{api server}

从 Rockset console 获取你的 API 密钥。从 API reference 中找到你的 API 服务器。省略 URL 中的 https:// 部分。

为了针对特定的虚拟实例，使用以下 URI 格式：

rockset://{api key}:@{api server}/{VI ID}

对于更完整的说明，我们建议参考 Rockset 文档。

Snowflake

安装 Snowflake Driver

在通过 docker compose 本地设置 Superset 时，按照此处的步骤了解如何安装新的数据库驱动程序。

echo "snowflake-sqlalchemy" >> ./docker/requirements-local.txt

Snowflake 推荐的连接库是 snowflake-sqlalchemy。

Snowflake 的连接字符串看起来像这样：

snowflake://{user}:{password}@{account}.{region}/{database}?role={role}&warehouse={warehouse}

在连接字符串中不需要包含模式(schema)，因为它是针对每个表或查询定义的。如果用户已经定义了默认的角色(role)和仓库(warehouse)，则可以省略它们，即。

snowflake://{user}:{password}@{account}.{region}/{database}

确保用户具有访问和使用所有所需数据库(databases)/模式(schemas)/表(tables)/视图(views)/仓库(warehouses)的权限，因为 Snowflake SQLAlchemy 引擎在默认情况下创建引擎时不会检测用户/角色权限。但是，在创建或编辑数据库对话框中按下 “Test Connection” 按钮时，通过在创建引擎时将 “validate_default_parameters”: True 传递给 connect() 方法来验证用户/角色凭据。如果用户/角色未被授权访问数据库，则会在 Superset logs 中记录错误。

如果您想通过密钥对认证连接到 Snowflake，请确保您拥有密钥对，并且公钥已在 Snowflake 中注册。为了使用密钥对认证连接到 Snowflake，您需要在 "SECURE EXTRA" 字段中添加以下参数。

请注意，您需要将多行私钥内容合并为一行，并在每行之间插入\n

{
     "auth_method": "keypair",
     "auth_params": {
         "privatekey_body": "-----BEGIN ENCRYPTED PRIVATE KEY-----\n...\n...\n-----END ENCRYPTED PRIVATE KEY-----",
         "privatekey_pass":"Your Private Key Password"
     }
 }

如果您的私钥存储在服务器上，您可以在参数中用 “privatekey_path” 替换 "privatekey_body"。

{
    "auth_method": "keypair",
    "auth_params": {
        "privatekey_path":"Your Private Key Path",
        "privatekey_pass":"Your Private Key Password"
    }
}

Apache Solr

sqlalchemy-solr库提供了 Python/SQLAlchemy 接口到 Apache Solr。

Solr 的连接字符串看起来像这样：

solr://{username}:{password}@{host}:{port}/{server_path}/{collection}[/?use_ssl=true|false]

Apache Spark SQL

对于 Apache Spark SQL 推荐的连接器库是 pyhive。

期望的连接字符串格式如下：

hive://hive@{hostname}:{port}/{database}

SQL Server

对于 SQL Server 推荐的连接器库是 pymssql。

SQL Server 的连接字符串看起来像这样：

mssql+pymssql://<Username>:<Password>@<Host>:<Port-default:1433>/<Database Name>/?Encrypt=yes

也可以使用参数 odbc_connect通过 pyodbc 进行连接。

SQL Server 的连接字符串看起来像这样：

mssql+pyodbc:///?odbc_connect=Driver%3D%7BODBC+Driver+17+for+SQL+Server%7D%3BServer%3Dtcp%3A%3Cmy_server%3E%2C1433%3BDatabase%3Dmy_database%3BUid%3Dmy_user_name%3BPwd%3Dmy_password%3BEncrypt%3Dyes%3BConnection+Timeout%3D30

StarRocks

sqlalchemy-starrocks 库是通过 SQLAlchemy 连接到 StarRocks 的推荐方式。

您需要以下设置值来形成连接字符串：

User: 用户名
Password: 数据库密码
Host: StarRocks FE 主机
Catalog: 目录名称
Database: 数据库名称
Port: StarRocks FE 端口

连接字符串看起来像这样：

starrocks://<User>:<Password>@<Host>:<Port>/<Catalog>.<Database>

Teradata

推荐的连接器库是 teradatasqlalchemy。

Teradata 的连接字符串看起来像这样：

teradatasql://{user}:{password}@{host}

ODBC Driver

还有一个较旧的连接器名为 sqlalchemy-teradata，它需要安装 ODBC 驱动程序。 Teradata ODBC 驱动程序可在此处获取：https://downloads.teradata.com/download/connectivity/odbc-driver/linux

以下是必需的环境变量：

export ODBCINI=/.../teradata/client/ODBC_64/odbc.ini
export ODBCINST=/.../teradata/client/ODBC_64/odbcinst.ini

我们建议使用第一个库，因为它不需要 ODBC 驱动程序，而且更新更频繁。

TimescaleDB

TimescaleDB是一个开源的关系型数据库，用于时间序列和分析，以构建强大的数据密集型应用。 TimescaleDB 是 PostgreSQL 的一个扩展，您可以使用标准的 PostgreSQL 连接器库 psycopg2 来连接到数据库。

如果您正在使用 docker compose，psycopg2 随 Superset一起开箱即用。

TimescaleDB 示例连接参数：

User Name: 用户
Password: 密码
Database Host：
- 对于本地主机：localhost 或 127.0.0.1
- 对于本地部署：IP地址或主机名
- 对于Timescale Cloud服务：主机名
- 对于Managed Service for TimescaleDB服务：主机名
Database Name: 数据库名称
Port：默认 5432 或服务的端口号

连接字符串看起来像：

postgresql://{username}:{password}@{host}:{port}/{database name}

您可以通过在末尾添加 ?sslmode=require 来要求 SSL（例如，在您使用 Timescale Cloud的情况下）：

postgresql://{username}:{password}@{host}:{port}/{database name}?sslmode=require

了解更多关于 TimescaleDB 的信息！

Trino

支持 Trino 版本 352 及以上

连接字符串

连接字符串的格式如下：

trino://{username}:{password}@{hostname}:{port}/{catalog}

如果您在本地机器上使用 docker 运行 Trino，请使用以下连接 URL

trino://trino@host.docker.internal:8080

认证

1. 基本认证

您可以在连接字符串中或在 Advanced / Security 中的 Secure Extra 字段中提供 username/password

在连接字符串中

trino://{username}:{password}@{hostname}:{port}/{catalog}

在 Secure Extra 字段中

{
    "auth_method": "basic",
    "auth_params": {
        "username": "<username>",
        "password": "<password>"
    }
}

注意：如果两者都提供，Secure Extra 始终具有更高的优先级。

2. Kerberos 认证

在Secure Extra字段中，按照以下示例配置：

{
    "auth_method": "kerberos",
    "auth_params": {
        "service_name": "superset",
        "config": "/path/to/krb5.config",
        ...
    }
}

auth_params 中的所有字段都直接传递给 KerberosAuthentication 类。

注意：Kerberos 认证需要本地安装带有 all 或 kerberos 可选功能的 trino-python-client，即分别安装 trino[all] 或 trino[kerberos]。

3. 证书认证

在 Secure Extra 字段中，按照以下示例配置：

{
    "auth_method": "certificate",
    "auth_params": {
        "cert": "/path/to/cert.pem",
        "key": "/path/to/key.pem"
    }
}

auth_params 中的所有字段都直接传递给 CertificateAuthentication 类。

4. JWT认证

配置 auth_method 并在 Secure Extra 字段中提供令牌

{
    "auth_method": "jwt",
    "auth_params": {
        "token": "<your-jwt-token>"
    }
}

5. 自定义认证

要使用自定义认证，首先需要将其添加到 Superset 配置文件中的 ALLOWED_EXTRA_AUTHENTICATIONS 允许列表中：

from your.module import AuthClass
from another.extra import auth_method

ALLOWED_EXTRA_AUTHENTICATIONS: Dict[str, Dict[str, Callable[..., Any]]] = {
    "trino": {
        "custom_auth": AuthClass,
        "another_auth_method": auth_method,
    },
}

然后在Secure Extra字段中：

{
    "auth_method": "custom_auth",
    "auth_params": {
        ...
    }
}

您还可以通过向 auth_method 提供对您的 trino.auth.Authentication 类的引用或工厂函数（返回一个Authentication实例）来使用自定义认证。

auth_params 中的所有字段都直接传递给您的类/函数。

Reference:

Trino-Superset-Podcast

Vertica

推荐的连接器库是 sqlalchemy-vertica-python。 Vertica 的连接参数是：

User Name: 用户名
Password: 密码
Database Host:
- 对于本地主机：localhost 或 127.0.0.1
- 对于本地部署：IP 地址或主机名
- 对于云：IP 地址或主机名
Database Name: 数据库名称
Port: 默认 5433

连接字符串格式如下：

vertica+vertica_python://{username}:{password}@{host}/{database}

其他参数：

Load Balancer - Backup Host

YugabyteDB

YugabyteDB 是一个基于 PostgreSQL 构建的分布式 SQL 数据库。

请注意，如果您正在使用 docker compose，Postgres 连接器库 psycopg2随 Superset 一起开箱即用。

连接字符串看起来像：

postgresql://{username}:{password}@{host}:{port}/{database}

通过 UI 进行连接

以下是有关如何利用新的 DB 连接 UI 的文档。这将为管理员提供增强用户体验的能力，以便用户可以连接到新数据库。

db-conn-docs

在新 UI 中连接到数据库现在有 3 个步骤：

步骤1：首先，管理员必须告知 superset 他们想要连接到哪个引擎。此页面由 /available 端点提供动力，该端点会提取当前环境中已安装的引擎，以便仅显示受支持的数据库。

步骤2：接下来，提示管理员输入特定于数据库的参数。根据是否有适用于该特定引擎的动态表单，管理员将看到新的自定义表单或旧版 SQLAlchemy 表单。我们目前为（Redshift、MySQL、Postgres和BigQuery）构建了动态表单。新表单会提示用户输入连接所需的参数（例如，用户名、密码、主机、端口等），并立即反馈错误。

步骤3：最后，一旦管理员使用动态表单连接到他们的 DB，他们有机会更新任何可选的高级设置。

我们希望此功能将有助于消除用户进入应用程序并开始创建数据集的巨大瓶颈。

如何设置首选数据库选项和 logo

我们新增了一个配置选项，管理员可以定义他们首选的数据库，按顺序排列：

# 首选数据库列表，按顺序排列。这些数据库将在 "Add Database" 对话框中突出显示。
# 应使用对应 DB 引擎规范中的 "engine_name" 属性，在 `superset/db_engine_specs/` 中。
PREFERRED_DATABASES: list[str] = [
    "PostgreSQL",
    "Presto",
    "MySQL",
    "SQLite",
]

由于版权原因，每个数据库的 logo 不会随 Superset 一起发布。

设置 logo

要设置您首选数据库的 logo，管理员必须在 superset_text.yml 文件中创建一个映射，包括引擎和 logo 的位置。logo 可以托管在本地的 static/file 目录下或在线上（例如 S3）

DB_IMAGES:
  postgresql: "path/to/image/postgres.jpg"
  bigquery: "path/to/s3bucket/bigquery.jpg"
  snowflake: "path/to/image/snowflake.jpg"

如何向可用端点添加新的数据库引擎

当前新模态支持以下数据库：

Postgres
Redshift
MySQL
BigQuery

当用户选择不在这个列表中的数据库时，他们会看到旧的对话框，要求输入 SQLAlchemy URI。新的数据库可以逐步添加到新流程中。为了支持丰富的配置，DB 引擎规范需要具有以下属性：

parameters_schema：一个 Marshmallow 模式，定义了配置数据库所需的参数。对于 Postgres，这包括用户名、密码、主机、端口等。（参见）。
default_driver：DB 引擎规范推荐的驱动程序名称。许多 SQLAlchemy 方言支持多个驱动程序，但通常有一个官方推荐的驱动程序。对于 Postgres，我们使用 "psycopg2"。
sqlalchemy_uri_placeholder：一个字符串，帮助用户在直接键入 URI 时使用。
encryption_parameters：用于构建 URI 的参数，当用户选择加密连接时使用。对于 Postgres，这是 {"sslmode": "require"}。

此外，DB 引擎规范必须实现以下类方法：

build_sqlalchemy_uri(cls, parameters, encrypted_extra)：此方法接收不同的参数并从它们构建 URI。
get_parameters_from_uri(cls, uri, encrypted_extra)：此方法相反，从给定的URI提取参数。
validate_parameters(cls, parameters)：此方法用于表单的 onBlur 验证。它应该返回一个 SupersetError 列表，指示哪些参数缺失，哪些参数肯定是错误的（示例）。

对于像 MySQL 和 Postgres 这样使用标准格式 engine+driver://user:password@host:port/dbname 的数据库，你只需要向 DB 引擎规范添加 BasicParametersMixin，然后定义参数 2-4（parameters_schema 已经在 mixin 中存在）。

对于其他数据库，你需要自己实现这些方法。BigQuery DB 引擎规范是实现这一点的一个好例子。

额外的数据库设置

更深入的 SQLAlchemy 集成

可以使用 SQLAlchemy 暴露的参数来调整数据库连接信息。在 Database edit 视图中，可以将 Extra 字段作为 JSON blob 进行编辑。

这个 JSON 字符串包含额外的配置元素。 engine_params 对象会解包到 sqlalchemy.create_engine 调用中，而 metadata_params 会被解包到 sqlalchemy.MetaData 调用中。更多详细信息，请参考 SQLAlchemy 文档。

Schemas(模式)

像 Postgres 和 Redshift 这样的数据库使用 schema 作为数据库之上的逻辑实体。为了让 Superset 连接到特定的 schema，你可以在 Edit Tables 表单中设置 schema 参数（Sources > Tables > Edit record）。

SQLAlchemy 连接的外部密码存储

Superset 可以配置为使用外部存储库来存储数据库密码。如果你正在运行自定义的 secret 分发框架，并且不希望在 Superset 的元数据库中存储 secrets，这将非常有用。

示例：编写一个函数，接受一个 sqla.engine.url 类型的单一参数，并返回给定连接字符串的密码。然后在你的配置文件中将 SQLALCHEMY_CUSTOM_PASSWORD_STORE 设置为指向该函数。

def example_lookup_password(url):
    secret = <<从外部框架获取密码>>
    return 'secret'

SQLALCHEMY_CUSTOM_PASSWORD_STORE = example_lookup_password

常见的模式是使用环境变量使 secrets 可用。 SQLALCHEMY_CUSTOM_PASSWORD_STORE 也可以为此目的使用。

def example_password_as_env_var(url):
    # 假设 uri 看起来像
    # mysql://localhost?superset_user:{SUPERSET_PASSWORD}
    return url.password.format(**os.environ)

SQLALCHEMY_CUSTOM_PASSWORD_STORE = example_password_as_env_var

数据库的 SSL 访问

你可以在 Edit Databases 表单的 Extra 字段中配置 SSL：

{
    "metadata_params": {},
    "engine_params": {
          "connect_args":{
              "sslmode":"require",
              "sslrootcert": "/path/to/my/pem"
        }
     }
}

杂项

跨数据库查询

Superset 提供了一个实验性功能，用于跨不同数据库进行查询。这是通过一个特殊数据库实现的，称为 "Superset meta database"，使用 "superset://" 的 SQLAlchemy URI。当使用该数据库时，可以使用以下语法查询任何已配置数据库中的任何表：

SELECT * FROM "database name.[[catalog.].schema].table name";

例如：

SELECT * FROM "examples.birth_names";

允许使用空格，但名称中的句点必须替换为 %2E。例如：

SELECT * FROM "Superset meta database.examples%2Ebirth_names";

上述查询返回与 SELECT * FROM "examples.birth_names" 相同的行，同时也展示了元数据库可以从任何表中查询数据 — 甚至包括自身！

考虑事项

启用此功能之前，你应该考虑几个方面。首先，元数据库对被查询的表强制执行权限，因此用户应该仅能通过数据库访问他们原本有权访问的表。然而，元数据库是一个潜在攻击的新界面，漏洞可能允许用户查看他们不应看到的数据。

其次，有性能方面的考虑。元数据库会将任何过滤、排序和限制推送到底层数据库，但任何聚合和连接都将在运行查询的过程中在内存中发生。因此，建议以异步模式运行数据库，以便查询在 Celery workers 中执行，而不是在 web workers 中执行。此外，可以指定从底层数据库返回的行数的硬限制。

启用元数据库

要启用 Superset 元数据库，首先需要将 ENABLE_SUPERSET_META_DB 功能标志设置为 true。然后，添加一个新的数据库类型为 "Superset meta database"，SQLAlchemy URI 为 "superset://"。

如果你在元数据库中启用了 DML，用户将能够在底层数据库上运行 DML 查询只要 DML 在其中也已启用。这允许用户运行跨数据库移动数据的查询。

其次，你可能想要更改 SUPERSET_META_DB_LIMIT 的值。默认值是 1000，定义了在执行任何聚合和连接之前从每个数据库读取的数量。如果只有小表格，也可以将此值设置为 None。

另外，你可能想要限制元数据库可以访问的数据库。这可以在数据库配置中完成，在 "Advanced" -> "Other" -> "ENGINE PARAMETERS" 下添加：

{"allowed_dbs":["Google Sheets","examples"]}

连接到数据库

安装数据库驱动程序​

支持的数据库和依赖项​

在 Docker 镜像中安装驱动程序​

1. 确定你需要的驱动程序​

2. Install the driver in the container​

2. 在容器中安装驱动程序​

3. 连接到 MySQL​

4. 故障排除​

特定于数据库的说明​

Ascend.io​

Apache Doris​

AWS Athena​

PyAthenaJDBC​

PyAthena​

AWS DynamoDB​

PyDynamoDB​

AWS Redshift​

psycopg2​

redshift_connector​

使用基于 IAM 的凭证与 Redshift 集群：​

使用基于 IAM 的凭证与 Redshift serverless：​

ClickHouse​

CockroachDB​

CouchbaseDB​

CrateDB​

Databend​

Databricks​

较旧的驱动程序​

Hive​

ODBC​

Dremio​

Apache Drill​

SQLAlchemy​

JDBC​

ODBC​

Apache Druid​

自定义 Druid 连接​

Aggregations​

Post-Aggregations​

Elasticsearch​

Exasol​

Firebird​

Firebolt​

Google BigQuery​

安装 BigQuery 驱动程序​

连接到 BigQuery​

Google Sheets​

Hana​

Apache Hive​

Hologres​

IBM DB2​

Apache Impala​

Kusto​

Apache Kylin​

MySQL​

IBM Netezza Performance Server​

OceanBase​

Ocient DB​

安装 Ocient Driver​

连接到 Ocient​

Oracle​

Apache Pinot​

Postgres​

Presto​

RisingWave​

Rockset​

Snowflake​

安装 Snowflake Driver​

Apache Solr​

Apache Spark SQL​

SQL Server​

StarRocks​

Teradata​

ODBC Driver​

TimescaleDB​

Trino​

连接字符串​

认证​

1. 基本认证​

安装数据库驱动程序

支持的数据库和依赖项

在 Docker 镜像中安装驱动程序

1. 确定你需要的驱动程序

2. Install the driver in the container

2. 在容器中安装驱动程序

3. 连接到 MySQL

4. 故障排除

特定于数据库的说明

Ascend.io

Apache Doris

AWS Athena

PyAthenaJDBC

PyAthena

AWS DynamoDB

PyDynamoDB

AWS Redshift

psycopg2

redshift_connector

使用基于 IAM 的凭证与 Redshift 集群：

使用基于 IAM 的凭证与 Redshift serverless：

ClickHouse

CockroachDB

CouchbaseDB

CrateDB

Databend

Databricks

较旧的驱动程序

Hive

ODBC

Dremio

Apache Drill

SQLAlchemy

JDBC

ODBC

Apache Druid

自定义 Druid 连接

Aggregations

Post-Aggregations

Elasticsearch

Exasol

Firebird

Firebolt

Google BigQuery

安装 BigQuery 驱动程序

连接到 BigQuery

Google Sheets

Hana

Apache Hive

Hologres

IBM DB2

Apache Impala

Kusto

Apache Kylin

MySQL

IBM Netezza Performance Server

OceanBase

Ocient DB

安装 Ocient Driver

连接到 Ocient

Oracle

Apache Pinot

Postgres

Presto

RisingWave

Rockset

Snowflake

安装 Snowflake Driver

Apache Solr

Apache Spark SQL

SQL Server

StarRocks

Teradata

ODBC Driver

TimescaleDB

Trino

连接字符串

认证

1. 基本认证

2. Kerberos 认证