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.

Let’s look at sample codes showing how to connect to each of the supported integrations.

From Our Community

Check out the video guides created by our community:

​
Airtable

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

For this connection, we recommend to use the Mongo API instead of the SQL API

MindsDB has a dedicated Mongo API that allows you to use the full power of the MindsDB platform. Using the Mongo API feels more natural for MongoDB users and allows you to use all the features of MindsDB.

You can find the instructions on how to connect MindsDB to MongoDB Compass or MongoDB Shell and proceed with the Mongo API documentation for further details.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

Was this page helpful?

YouTubeAirtable