Skip to main content
The list of databases supported by MindsDB keeps growing. Here are the currently supported integrations:

You can find particular databases’ handler files here to see their connection arguments. For example, to see the latest updates to the Oracle handler, check Oracle’s readme.md file here.
MindsDB supports Model Context Protocol (MCP)MindsDB is an MCP server that enables your MCP applications to answer questions over large-scale federated data. Learn more here.
Let’s look at sample codes showing how to connect to each of the supported integrations.
From Our CommunityCheck out the video guides created by our community:

​
Airtable

  • Template
  • Example
CREATE DATABASE airtable_datasource          --- display name for the database
WITH ENGINE = 'airtable',                    --- name of the MindsDB handler
PARAMETERS = {
  "base_id": " ",                            --- the Airtable base ID
  "table_name": " ",                         --- the Airtable table name
  "api_key": " "                             --- the API key for the Airtable API
};
Check out the Airtable data handler details here.

​
Amazon DynamoDB

  • Template
  • Example
CREATE DATABASE dynamodb_datasource       --- display name for the database
WITH ENGINE = 'dynamodb',                 --- name of the MindsDB handler
PARAMETERS = {
  "aws_access_key_id": " ",               --- the AWS access key
  "aws_secret_access_key": " ",           --- the AWS secret access key
  "region_name": " "                      --- the AWS region
};
Check out the Amazon DynamoDB data handler details here.

​
Amazon Redshift

  • Template
  • Example
CREATE DATABASE amazonredshift_datasource         --- display name for the database
WITH ENGINE = 'amazonredshift',                   --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                                    --- host name or IP address of the Redshift cluster
  "port": ,                                       --- port used when connecting to the Redshift cluster
  "database": " ",                                --- database name used when connecting to the Redshift cluster
  "user": " ",                                    --- user to authenticate with the Redshift cluster
  "password": " "                                 --- password used to authenticate with the Redshift cluster
};
Check out the Amazon Redshift data handler details here.

​
Amazon S3

  • Template
  • Example
CREATE DATABASE amazons3_datasource     --- display name for the database
WITH ENGINE = 's3',                     --- name of the MindsDB handler
PARAMETERS = {
  "aws_access_key_id": " ",             --- the AWS access key
  "aws_secret_access_key": " ",         --- the AWS secret access key
  "region_name": " ",                   --- the AWS region
  "bucket": " ",                        --- name of the S3 bucket
  "key": " ",                           --- key of the object to be queried
  "input_serialization": " "            --- format of the data to be queried
};
Check out the Amazon S3 data handler details here.

​
Apache Cassandra

  • Template
  • Example
CREATE DATABASE cassandra_datasource        --- display name for the database
WITH ENGINE = 'cassandra',                  --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                              --- host name or IP address
  "port": ,                                 --- port used to make TCP/IP connection
  "user": " ",                              --- database user
  "password": " ",                          --- database password
  "keyspace": " ",                          --- database name
  "protocol_version": ,                     --- optional, protocol version (defaults to 4 if left blank)
  "secure_connect_bundle": {                --- optional, secure connect bundle file
    "path": " "                                 --- either "path" or "url"
  }
};
Check out the Apache Cassandra data handler details here.

​
Apache Druid

  • Template
  • Example
CREATE DATABASE druid_datasource        --- display name for the database
WITH ENGINE = 'druid',                  --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                          --- host name or IP address of Apache Druid
  "port": ,                             --- port where Apache Druid runs
  "user": " ",                          --- optional, user to authenticate with Apache Druid
  "password": " ",                      --- optional, password used to authenticate with Apache Druid
  "path": " ",                          --- query path
  "scheme": " "                         --- the URI scheme (defaults to `http` if left blank)
};
Check out the Apache Druid data handler details here.

​
Apache Hive

  • Template
  • Example
CREATE DATABASE hive_datasource   --- display name for the database
WITH ENGINE = 'hive',             --- name of the MindsDB handler
PARAMETERS = {
  "user": " ",                    --- database user
  "password": " ",                --- database password
  "host": " ",                    --- host name or IP address
  "port": ,                       --- port used to make TCP/IP connection
  "database": " ",                --- database name
  "auth": " "                     --- defaults to CUSTOM if not provided; check for options here: https://pypi.org/project/PyHive/
};
Check out the Apache Hive data handler details here.

​
Apache Impala

  • Template
  • Example
CREATE DATABASE impala_datasource      --- display name for the database
WITH ENGINE = 'impala',                --- name of the MindsDB handler
PARAMETERS = {
  "user": " ",                         --- database user
  "password": " ",                     --- database password
  "host": " ",                         --- host name or IP address
  "port": ,                            --- port used to make TCP/IP connection
  "database": " "                      --- database name
};
Check out the Apache Impala data handler details here.

​
Apache Pinot

  • Template
  • Example
CREATE DATABASE pinot_datasource        --- display name for the database
WITH ENGINE = 'pinot',                  --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                          --- host name or IP address of the Apache Pinot cluster
  "broker_port": ,                      --- port where the broker of the Apache Pinot cluster runs
  "controller_port": ,                  --- port where the controller of the Apache Pinot cluster runs
  "path": " ",                          --- query path
  "scheme": " ",                        --- scheme (defaults to `http` if left blank)
  "username": " ",                      --- optional, user
  "password": " ",                      --- optional, password
  "verify_ssl": " "                     --- optional, verify SSL
};
Check out the Apache Pinot data handler details here.

​
Apache Solr

  • Template
  • Example
CREATE DATABASE solr_datasource   --- display name for the database
WITH ENGINE = 'solr',             --- name of the MindsDB handler
PARAMETERS = {
  "username": " ",                --- optional, username used to authenticate with the Solr server
  "password": " ",                --- optional, password used to authenticate with the Solr server
  "host": " ",                    --- host name or IP address of the Solr serve
  "port": ,                       --- port number of the Solr server
  "server_path": " ",             --- defaults to `solr` if left blank
  "collection": " ",              --- Solr Collection name
  "use_ssl": " "                  --- defaults to `false` if left blank; refer to https://pypi.org/project/sqlalchemy-solr/
};
Check out the Apache Solr data handler details here.

​
Ckan

  • Template
  • Example
CREATE DATABASE ckan_datasource          --- display name for the database
WITH ENGINE = 'ckan',                    --- name of the MindsDB handler
PARAMETERS = {
  "url": " ",                            --- host name, IP address, or a URL
  "apikey": " "                          --- the API key used for authentication
};
Check out the Ckan data handler details here.

​
ClickHouse

  • Template
  • Example
CREATE DATABASE clickhouse_datasource       --- display name for the database
WITH ENGINE = 'clickhouse',                 --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                              --- host name or IP address
  "port": ,                                 --- port used to make TCP/IP connection
  "database": " ",                          --- database name
  "user": " ",                              --- database user
  "password": " ",                          --- database password
  "protocol": " "                           --- optional, http or https (defaults to `native`)
};
Check out the ClickHouse data handler details here.

​
Cloud Spanner

  • Template
  • Example
CREATE DATABASE cloud_spanner_datasource       --- display name for the database
WITH ENGINE = 'cloud_spanner',                 --- name of the MindsDB handler
PARAMETERS = {
  "instance_id": " ",                          --- the instance identifier
  "database_id": ,                             --- the database identifier
  "project_id": " ",                           --- the identifier of the project that owns the instances and data
  "credentials": " ",                          --- a stringified GCP service account key JSON
};
Check out the Cloud Spanner data handler details here.

​
CockroachDB

  • Template
  • Example
CREATE DATABASE cockroach_datasource        --- display name for the database
WITH ENGINE = 'cockroachdb',                --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                              --- host name or IP address
  "port": ,                                 --- port used to make TCP/IP connection
  "database": " ",                          --- database name
  "user": " ",                              --- database user
  "password": " ",                          --- database password
  "publish": " "                            --- optional, publish
};
Check out the CockroachDB data handler details here.

​
Couchbase

  • Template
  • Example
CREATE DATABASE couchbase_datasource        --- display name for the database
WITH ENGINE = 'couchbase',                  --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                              --- host name or IP address of the Couchbase server
  "user": " ",                              --- user to authenticate with the Couchbase server
  "password": " ",                          --- password used to authenticate with the Couchbase server
  "bucket": " ",                            --- bucket name
  "scope": " "                              --- scope used to query (defaults to `_default` if left blank)
};                                              --- a scope in Couchbase is equivalent to a schema in MySQL
Check out the Couchbase data handler details here.

​
CrateDB

  • Template
  • Example
CREATE DATABASE cratedb_datasource        --- display name for the database
WITH ENGINE = 'crate',                    --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                            --- host name or IP address
  "port": ,                               --- port used to make TCP/IP connection
  "user": " ",                            --- database user
  "password": " ",                        --- database password
  "schema_name": " "                      --- database schema name (defaults to `doc` if left blank)
};
Check out the CrateDB data handler details here.

​
D0lt

  • Template
  • Example
CREATE DATABASE d0lt_datasource             --- display name for the database
WITH ENGINE = 'd0lt',                       --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                              --- host name or IP address
  "port": ,                                 --- port used to make TCP/IP connection
  "database": " ",                          --- database name
  "user": " ",                              --- database user
  "password": " ",                          --- database password
  "ssl": ,                                  --- optional, the `ssl` parameter value indicates whether SSL is enabled (`True`) or disabled (`False`)
  "ssl_ca": {                               --- optional, SSL Certificate Authority
    "path": " "                                 --- either "path" or "url"
  },
  "ssl_cert": {                             --- optional, SSL certificates
    "url": " "                                  --- either "path" or "url"
  },
  "ssl_key": {                              --- optional, SSL keys
    "path": " "                                 --- either "path" or "url"
  }
};
Check out the D0lt data handler details here.

​
Databend

  • Template
  • Example
CREATE DATABASE databend_datasource     --- display name for the database
WITH ENGINE = 'databend',               --- name of the MindsDB handler
PARAMETERS = {
  "protocol": " ",                      --- protocol used to query Databend (defaults to `native` if left blank); supported protocols: native, http, https
  "user": " ",                          --- username used to authenticate with the Databend warehouse
  "port": ,                             --- TCP/IP port of the Databend warehouse
  "password": " ",                      --- password used to authenticate with the Databend warehouse
  "host": " ",                          --- host name or IP address of the Databend warehouse (use '127.0.0.1' instead of 'localhost' when connecting to a local server)
  "database": " "                       --- database name used when connecting to the Databend warehouse
};
Check out the Databend data handler details here.

​
Databricks

  • Template
  • Example
CREATE DATABASE databricks_datasource         --- display name for the database
WITH ENGINE = 'databricks',                   --- name of the MindsDB handler
PARAMETERS = {
  "server_hostname": " ",                     --- server hostname of the cluster or SQL warehouse
  "http_path": " ",                           --- http path to the cluster or SQL warehouse
  "access_token": " ",                        --- personal Databricks access token
  "schema": " ",                              --- schema name (defaults to `default` if left blank)
  "session_configuration": " ",               --- optional, dictionary of Spark session configuration parameters
  "http_headers": " ",                        --- optional, additional (key, value) pairs to set in HTTP headers on every RPC request the client makes
  "catalog": " "                              --- catalog (defaults to `hive_metastore` if left blank)
};
Check out the Databricks data handler details here.

​
DataStax

  • Template
  • Example
CREATE DATABASE datastax_datasource           --- display name for the database
WITH ENGINE = 'astra',                        --- name of the MindsDB handler
PARAMETERS = {
  "user": " ",                                --- user to be authenticated
  "password": " ",                            --- password for authentication
  "secure_connection_bundle": {               --- secure connection bundle zip file
    "path": " "                                   --- either "path" or "url"
  },
  "host": " ",                                --- optional, host name or IP address
  "port": ,                                   --- optional, port used to make TCP/IP connection
  "protocol_version": ,                       --- optional, protocol version
  "keyspace": " "                             --- optional, keyspace
};
Check out the DataStax data handler details here.

​
DuckDB

  • Template
  • Example
CREATE DATABASE duckdb_datasource       --- display name for the database
WITH ENGINE = 'duckdb',                 --- name of the MindsDB handler
PARAMETERS = {
  "database": " ",                      --- database file name
  "read_only":                          --- flag used to set the connection to read-only mode
};
Check out the DuckDB data handler details here.

​
Elasticsearch

  • Template
  • Example
CREATE DATABASE elastic_datasource      --- display name for the database
WITH ENGINE = 'elasticsearch',          --- name of the MindsDB handler
PARAMETERS = {
  "hosts": " ",                         --- one or more host names or IP addresses of the Elasticsearch server
  "username": " ",                      --- optional, username to authenticate with the Elasticsearch server
  "password": " ",                      --- optional, password used to authenticate with the Elasticsearch server
  "cloud_id": " "                       --- optional, unique ID of your hosted Elasticsearch cluster (must be provided when "hosts" is left blank)
};
Check out the Elasticsearch data handler details here.

​
Firebird

  • Template
  • Example
CREATE DATABASE firebird_datasource         --- display name for the database
WITH ENGINE = 'firebird',                   --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                              --- host name or IP address of the Firebird server
  "database": " ",                          --- database name
  "user": " ",                              --- user to authenticate with the Firebird server
  "password": " "                           --- password used to authenticate with the Firebird server
};
Check out the Firebird data handler details here.

​
Google BigQuery

  • Template
  • Example for Self-Hosted MindsDB
  • Example for MindsDB Cloud
  • Example without JSON File
CREATE DATABASE bigquery_datasource       --- display name for the database
WITH ENGINE = 'bigquery',                 --- name of the MindsDB handler
PARAMETERS = {
  "project_id": " ",                      --- globally unique project identifier
  "dataset": " ",                         --- default dataset
  "service_account_keys": " ",            --- service account keys file
  "service_account_json": {...}           --- it is an alternative to using 'service_account_keys'
};
Check out the Google BigQuery data handler details here.

​
Google Sheets

  • Template
  • Example
CREATE DATABASE sheets_datasource       --- display name for the database
WITH ENGINE = 'sheets',                 --- name of the MindsDB handler
PARAMETERS = {
  "spreadsheet_id": " ",                --- unique ID of the Google Sheet
  "sheet_name": " "                     --- name of the Google Sheet
};
Check out the Google Sheets data handler details here.

​
GreptimeDB

  • Template
  • Example
CREATE DATABASE greptimedb_datasource       --- display name for the database
WITH ENGINE = 'greptimedb',                 --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                              --- host IP address or URL
  "port": ,                                 --- port used to make TCP/IP connection
  "database": " ",                          --- database name
  "user": " ",                              --- database user
  "password": " ",                          --- database password
  "ssl": ,                                  --- optional, the `ssl` parameter value indicates whether SSL is enabled (`True`) or disabled (`False`)
  "ssl_ca": {                               --- optional, SSL Certificate Authority
    "path": " "                                 --- either "path" or "url"
  },
  "ssl_cert": {                             --- optional, SSL certificates
    "url": " "                                  --- either "path" or "url"
  },
  "ssl_key": {                              --- optional, SSL keys
    "path": " "                                 --- either "path" or "url"
  }
};
Check out the GreptimeDB data handler details here.

​
IBM Db2

  • Template
  • Example
CREATE DATABASE db2_datasource        --- display name for the database
WITH ENGINE = 'DB2',                  --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                        --- host name or IP address
  "port": ,                           --- port used to make TCP/IP connection
  "database": " ",                    --- database name
  "user": " ",                        --- database user
  "password": " ",                    --- database password
  "schema_name": " "                  --- database schema name
};
Check out the IBM Db2 data handler details here.

​
IBM Informix

  • Template
  • Example
CREATE DATABASE informix_datasource       --- display name for the database
WITH ENGINE = 'informix',                 --- name of the MindsDB handler
PARAMETERS = {
  "server": " ",                          --- server name
  "host": " ",                            --- host name or IP address
  "port": ,                               --- port used to make TCP/IP connection
  "database": " ",                        --- database name
  "user": " ",                            --- database user
  "password": " ",                        --- database password
  "schema_name": " ",                     --- database schema name
  "logging_enabled":                      --- indicates whether logging is enabled (defaults to `True` if left blank)
};
Check out the IBM Informix data handler details here.

​
MariaDB

  • Template
  • Example
CREATE DATABASE maria_datasource            --- display name for the database
WITH ENGINE = 'mariadb',                    --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                              --- host IP address or URL
  "port": ,                                 --- port used to make TCP/IP connection
  "database": " ",                          --- database name
  "user": " ",                              --- database user
  "password": " ",                          --- database password
  "ssl": ,                                  --- optional, the `ssl` parameter value indicates whether SSL is enabled (`True`) or disabled (`False`)
  "ssl_ca": {                               --- optional, SSL Certificate Authority
    "path": " "                                 --- either "path" or "url"
  },
  "ssl_cert": {                             --- optional, SSL certificates
    "url": " "                                  --- either "path" or "url"
  },
  "ssl_key": {                              --- optional, SSL keys
    "path": " "                                 --- either "path" or "url"
  }
};
Check out the MariaDB data handler details here.

​
MariaDB SkySQL

  • Template
  • Example
CREATE DATABASE skysql            --- display name for the database
WITH ENGINE = 'mariadb',          --- name of the MindsDB handler
PARAMETERS = {
  "user": " ",                    --- database user
  "password": " ",                --- database password
  "host": " ",                    --- host IP address or URL
  "port": ,                       --- port used to make TCP/IP connection
  "ssl": ,                        --- optional, the `ssl` parameter value indicates whether SSL is enabled (`True`) or disabled (`False`)
  "ssl-ca": {                     --- optional, SSL Certificate Authority
    "path": " "                       --- either "path" or "url"
  },
  "database": " "                 --- database name
};
For more information on how to connect MariaDB SkySQL and MindsDB, visit our doc page here.

​
MatrixOne

  • Template
  • Example
CREATE DATABASE matrixone_datasource        --- display name for the database
WITH ENGINE = 'matrixone',                  --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                              --- host IP address or URL
  "port": ,                                 --- port used to make TCP/IP connection
  "database": " ",                          --- database name
  "user": " ",                              --- database user
  "password": " ",                          --- database password
  "ssl": ,                                  --- optional, the `ssl` parameter value indicates whether SSL is enabled (`True`) or disabled (`False`)
  "ssl_ca": {                               --- optional, SSL Certificate Authority
    "path": " "                                 --- either "path" or "url"
  },
  "ssl_cert": {                             --- optional, SSL certificates
    "url": " "                                  --- either "path" or "url"
  },
  "ssl_key": {                              --- optional, SSL keys
    "path": " "                                 --- either "path" or "url"
  }
};
Check out the MatrixOne data handler details here.

​
Microsoft Access

  • Template
  • Example
CREATE DATABASE access_datasource       --- display name for the database
WITH ENGINE = 'access',                 --- name of the MindsDB handler
PARAMETERS = {
  "db_file": " "                        --- path to the database file to be used
};
Check out the Microsoft Access data handler details here.

​
Microsoft SQL Server

  • Template
  • Example
CREATE DATABASE mssql_datasource        --- display name for the database
WITH ENGINE = 'mssql',                  --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                          --- host name or IP address
  "port": ,                             --- port used to make TCP/IP connection
  "database": " ",                      --- database name
  "user": " ",                          --- database user
  "password": " "                       --- database password
};
Check out the Microsoft SQL Server data handler details here.

​
MonetDB

  • Template
  • Example
CREATE DATABASE monetdb_datasource          --- display name for the database
WITH ENGINE = 'monetdb',                    --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                              --- host name or IP address
  "port": ,                                 --- port used to make TCP/IP connection
  "database": " ",                          --- database name
  "user": " ",                              --- database user
  "password": " ",                          --- database password
  "schema_name": " "                        --- database schema name (defaults to the current schema if left blank)
};
Check out the MonetDB data handler details here.

​
MongoDB

  • Template
  • Example
CREATE DATABASE mongo_datasource          --- display name for the database
WITH ENGINE = 'mongo',                    --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                            --- host name or IP address
  "port": ,                               --- port used to make TCP/IP connection
  "user": " ",                            --- database user
  "password": " "                         --- database password
  "database": " "                         --- database name
};
Check out the MongoDB data handler details here.

​
MySQL

  • Template
  • Example
CREATE DATABASE mysql_datasource            --- display name for the database
WITH ENGINE = 'mysql',                      --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                              --- host name or IP address
  "port": ,                                 --- port used to make TCP/IP connection
  "database": " ",                          --- database name
  "user": " ",                              --- database user
  "password": " ",                          --- database password
  "ssl": ,                                  --- optional, the `ssl` parameter value indicates whether SSL is enabled (`True`) or disabled (`False`)
  "ssl_ca": {                               --- optional, SSL Certificate Authority
    "path": " "                                 --- either "path" or "url"
  },
  "ssl_cert": {                             --- optional, SSL certificates
    "url": " "                                  --- either "path" or "url"
  },
  "ssl_key": {                              --- optional, SSL keys
    "path": " "                                 --- either "path" or "url"
  }
};
Check out the MySQL data handler details here.

​
OceanBase

  • Template
  • Example
CREATE DATABASE oceanbase_datasource      --- display name for the database
WITH ENGINE = 'oceanbase',                --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                            --- host name or IP address
  "user": " ",                            --- database user
  "password": " ",                        --- database password
  "port": ,                               --- port used to make TCP/IP connection
  "database": " "                         --- database name
};
Check out the OceanBase data handler details here.

​
OpenGauss

  • Template
  • Example
CREATE DATABASE opengauss_datasource            --- display name for the database
WITH ENGINE = 'opengauss',                      --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                                  --- host name or IP address
  "port": ,                                     --- port used to make TCP/IP connection
  "database": " ",                              --- database name
  "user": " ",                                  --- database user
  "password": " ",                              --- database password
};
Check out the OpenGauss data handler details here.

​
Oracle

  • Template
  • Example
CREATE DATABASE oracle_datasource         --- display name for the database
WITH ENGINE = 'oracle',                   --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                            --- host name or IP address
  "port": ,                               --- port used to make TCP/IP connection
  "sid": " ",                             --- unique identifier of the database instance
  "user": " ",                            --- database user
  "password": " "                         --- database password
};
Check out the Oracle data handler details here.

​
OrioleDB

  • Template
  • Example
CREATE DATABASE orioledb_datasource      --- display name for the database
WITH ENGINE = 'orioledb',                --- name of the MindsDB handler
PARAMETERS = {
  "user": " ",                           --- database user
  "password": " ",                       --- database password
  "host": " ",                           --- host name or IP address
  "port": ,                              --- port used to make TCP/IP connection
  "server": " ",                         --- sets the current server
  "database": " "                        --- sets the current database
};
Check out the OrioleDB data handler details here.

​
PlanetScale

  • Template
  • Example
CREATE DATABASE planetscale_datasource     --- display name for the database
WITH ENGINE = 'planet_scale',              --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                             --- host name or IP address
  "port": ,                                --- port used to make TCP/IP connection
  "user": " ",                             --- database user
  "password": " ",                         --- database password
  "database": " "                          --- database name
};
Check out the PlanetScale data handler details here.

​
PostgreSQL

  • Template
  • Example
CREATE DATABASE psql_datasource         --- display name for the database
WITH ENGINE = 'postgres',               --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                          --- host name or IP address
  "port": ,                             --- port used to make TCP/IP connection
  "database": " ",                      --- database name
  "user": " ",                          --- database user
  "password": " "                       --- database password
};
Check out the PostgreSQL data handler details here.

​
QuestDB

  • Template
  • Example
CREATE DATABASE questdb_datasource      --- display name for the database
WITH ENGINE = 'questdb',                --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                          --- host name or IP address
  "port": ,                             --- port used to make TCP/IP connection
  "database": " ",                      --- database name
  "user": " ",                          --- database user
  "password": " ",                      --- database password
  "public":                             --- value of `True` or `False` (defaults to `True` if left blank)
};
Check out the QuestDB data handler details here.

​
SAP HANA

  • Template
  • Example
CREATE DATABASE sap_hana_datasource           --- display name for the database
WITH ENGINE = 'hana',                         --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                                --- host name or IP address
  "port": ,                                   --- port used to make TCP/IP connection
  "user": " ",                                --- user
  "password": " ",                            --- password
  "schema": " ",                              --- database schema name (defaults to the current schema if left blank)
  "encrypt":                                  --- indicates whether connection is encrypted (required for cloud usage)
};
Check out the SAP HANA data handler details here.

​
ScyllaDB

  • Template
  • Example
CREATE DATABASE scylladb_datasource           --- display name for the database
WITH ENGINE = 'scylladb',                     --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                                --- host name or IP address
  "port": ,                                   --- port used to make TCP/IP connection
  "user": " ",                                --- user
  "password": " ",                            --- password
  "protocol_version": ,                       --- optional, protocol version (defaults to 4 if left blank)
  "keyspace": " ",                            --- keyspace name (it is the top level container for tables)
  "secure_connect_bundle": {                  --- secure connect bundle file
    "path": " "                                   --- either "path" or "url"
  }
};
Check out the ScyllaDB data handler details here.

​
SingleStore

  • Template
  • Example
CREATE DATABASE singlestore_datasource          --- display name for the database
WITH ENGINE = 'singlestore',                    --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                                  --- host name or IP address
  "port": ,                                     --- port used to make TCP/IP connection
  "database": " ",                              --- database name
  "user": " ",                                  --- database user
  "password": " ",                              --- database password
  "ssl": ,                                      --- optional, the `ssl` parameter value indicates whether SSL is enabled (`True`) or disabled (`False`)
  "ssl_ca": {                                   --- optional, SSL Certificate Authority
    "path": " "                                     --- either "path" or "url"
  },
  "ssl_cert": {                                 --- optional, SSL certificates
    "url": " "                                      --- either "path" or "url"
  },
  "ssl_key": {                                  --- optional, SSL keys
    "path": " "                                     --- either "path" or "url"
  }
};
Check out the SingleStore data handler details here.

​
Snowflake

  • Template
  • Example
CREATE DATABASE snowflake_datasource              --- display name for the database
WITH ENGINE = 'snowflake',                        --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                                    --- host name or IP address
  "port": ,                                       --- port used to make TCP/IP connection
  "database": " ",                                --- database name
  "user": " ",                                    --- database user
  "password": " ",                                --- database password
  "account": " ",                                 --- the Snowflake account
  "schema": " ",                                  --- schema name (defaults to `public` if left blank)
  "protocol": " ",                                --- protocol (defaults to `https` if left blank)
  "warehouse": " "                                --- the warehouse account
};
Check out the Snowflake data handler details here.

​
SQL Anywhere

  • Template
  • Example
CREATE DATABASE sqlany_datasource   --- display name for the database
WITH ENGINE = 'sqlany',             --- name of the MindsDB handler
PARAMETERS = {
  "user": " ",                      --- username
  "password": " ",                  --- password
  "host": " ",                      --- host name or IP address of the SAP SQL Anywhere instance
  "port": ,                         --- port number of the SAP SQL Anywhere instance
  "server": " ",                    --- sets the current server
  "database": " "                   --- sets the current database
};
Check out the SQL Anywhere data handler details here.

​
SQLite

  • Template
  • Example
CREATE DATABASE sqlite_datasource         --- display name for the database
WITH ENGINE = 'sqlite',                   --- name of the MindsDB handler
PARAMETERS = {
  "db_file": " "                          --- path to the database file to be used
};
Check out the SQLite data handler details here.

​
StarRocks

  • Template
  • Example
CREATE DATABASE starrocks_datasource      --- display name for the database
WITH ENGINE = 'starrocks',                --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                            --- host name or IP address
  "user": " ",                            --- database user
  "password": " ",                        --- database password
  "port": ,                               --- port used to make TCP/IP connection
  "database": " "                         --- database name
};
Check out the StarRocks data handler details here.

​
Supabase

  • Template
  • Example
CREATE DATABASE supabase_datasource             --- display name for the database
WITH ENGINE = 'supabase',                       --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                                  --- host name or IP address
  "port": ,                                     --- port used to make TCP/IP connection
  "database": " ",                              --- database name
  "user": " ",                                  --- database user
  "password": " ",                              --- database password
};
Check out the Supabase data handler details here.

​
TDengine

  • Template
  • Example
CREATE DATABASE tdengine_datasource   --- display name for the database
WITH ENGINE = 'tdengine',             --- name of the MindsDB handler
PARAMETERS = {
  "user": " ",                        --- server username
  "password": " ",                    --- server password
  "url": " ",                         --- URL to the TDEngine server (for local server, it is localhost:6041 by default)
  "token": " ",                       --- unique token provided when using TDEngine Cloud
  "database": " "                     --- database name
};
Check out the TDengine data handler details here.

​
Teradata

  • Template
  • Example
CREATE DATABASE teradata_datasource     --- display name for the database
WITH ENGINE = 'teradata',               --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                          --- host name or IP address
  "user": " ",                          --- database user
  "password": " ",                      --- database password
  "database": " ",                      --- database name
  "port":                               --- port used to make TCP/IP connection
};
Check out the Teradata data handler details here.

​
TiDB

  • Template
  • Example
CREATE DATABASE tidb_datasource                 --- display name for the database
WITH ENGINE = 'tidb',                           --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                                  --- host name or IP address
  "port": ,                                     --- port used to make TCP/IP connection
  "database": " ",                              --- database name
  "user": " ",                                  --- database user
  "password": " ",                              --- database password
};
Check out the TiDB data handler details here.

​
TimescaleDB

  • Template
  • Example
CREATE DATABASE timescaledb_datasource    --- display name for the database
WITH ENGINE = 'timescaledb',              --- name of the MindsDB handler
PARAMETERS = {
  "user": " ",                            --- database user
  "password": " ",                        --- database password
  "host": " ",                            --- host name or IP address
  "port": ,                               --- port used to make TCP/IP connection
  "database": " "                         --- database name
};
Check out the TimescaleDB data handler details here.

​
Trino

  • Template
  • Example 1
  • Example 2
CREATE DATABASE trino_datasource          --- display name for the database
WITH ENGINE = 'trino',                    --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                            --- host name or IP address
  "port": ,                               --- port used to make TCP/IP connection
  "auth": " ",                            --- optional, authentication method, currently only `basic` is supported
  "http_scheme": " ",                     --- optional, `http`(default) or `https`
  "user": " ",                            --- database user
  "password": " ",                        --- database password
  "catalog": " ",                         --- optional, catalog
  "schema": " "                           --- optional, schema
  "with":                                 --- optional, default WITH-clause (properties) for ALL tables
                                              --- this parameter is experimental and might be changed or removed in future release
};
Check out the Trino data handler details here.

​
Vertica

  • Template
  • Example
CREATE DATABASE vertica_datasource        --- display name for the database
WITH ENGINE = 'vertica',                  --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                            --- host name or IP address
  "port": ,                               --- port used to make TCP/IP connection
  "database": " ",                        --- database name
  "user": " ",                            --- database user
  "password": " ",                        --- database password
  "schema_name": " "                      --- database schema name
};
Check out the Vertica data handler details here.

​
Vitess

  • Template
  • Example
CREATE DATABASE vitess_datasource       --- display name for the database
WITH ENGINE = 'vitess',                 --- name of the MindsDB handler
PARAMETERS = {
  "host": " ",                          --- host name or IP address
  "user": " ",                          --- database user
  "password": " ",                      --- database password
  "port": ,                             --- port used to make TCP/IP connection
  "database": " "                       --- database name
};
Check out the Vitess data handler details here.

​
YugabyteDB

  • Template
  • Example
CREATE DATABASE yugabyte_datasource       --- display name for the database
WITH ENGINE = 'yugabyte',                 --- name of the MindsDB handler
PARAMETERS = {
  "user": " ",                            --- database user
  "password": " ",                        --- database password
  "host": " ",                            --- host name or IP address
  "port": ,                               --- port used to make TCP/IP connection
  "database": " "                         --- database name
  "schema": " "                           --- schema name, if multiple schemas then comma separated
};
Check out the YugabyteDB data handler details here.