Supported Integrations

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:

Video guide on Connect Postgres Database to MindsDB by @akhilcoder
Video guide on Setting up data sources with mindsDB by Syed Zubeen

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
};

CREATE DATABASE airtable_datasource
WITH ENGINE = 'airtable',
PARAMETERS = {
  "base_id": "appve10klsda2",
  "table_name": "my_table",
  "api_key": "KdJX2Q5km%5b$T$sQYm^gvN"
};

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
};

CREATE DATABASE dynamodb_datasource
WITH ENGINE = 'dynamodb',
PARAMETERS = {
  "aws_access_key_id": "PCAQ2LJDOSWLNSQKOCPW",
  "aws_secret_access_key": "U/VjewPlNopsDmmwItl34r2neyC6WhZpUiip57i",
  "region_name": "us-east-1"
};

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
};

CREATE DATABASE amazonredshift_datasource
WITH ENGINE = 'amazonredshift',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 5439,
  "database": "test",
  "user": "amazonredshift",
  "password": "password"
};

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
};

CREATE DATABASE amazons3_datasource
WITH ENGINE = 's3',
PARAMETERS = {
    "aws_access_key_id": "PCAQ2LJDOSWLNSQKOCPW",
    "aws_secret_access_key": "U/VjewPlNopsDmmwItl34r2neyC6WhZpUiip57i",
    "region_name": "us-east-1",
    "bucket": "mindsdb-bucket",
    "key": "iris.csv",
    "input_serialization": "{'CSV': {'FileHeaderInfo': 'NONE'}}"
};

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"
  }
};

CREATE DATABASE cassandra_datasource
WITH ENGINE = 'cassandra',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 9043,
  "user": "user",
  "password": "password",
  "keyspace": "test_data",
  "protocol_version": 4
};

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)
};

CREATE DATABASE druid_datasource
WITH ENGINE = 'druid',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 8888,
  "path": "/druid/v2/sql/",
  "scheme": "http"
};

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/
};

CREATE DATABASE hive_datasource
WITH ENGINE = 'hive',
PARAMETERS = {
  "user": "hive",
  "password": "password",
  "host": "127.0.0.1",
  "port": 10000,
  "database": "hive_db",
  "auth": "CUSTOM"
};

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
};

CREATE DATABASE impala_datasource
WITH ENGINE = 'impala',
PARAMETERS = {
  "user": "impala_user",
  "password": "password",
  "host": "127.0.0.1",
  "port": 21050,
  "database": "impala_db"
};

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
};

CREATE DATABASE pinot_datasource
WITH ENGINE = 'pinot',
PARAMETERS = {
  "host": "127.0.0.1",
  "broker_port": 8000,
  "controller_port": 9000,
  "path": "/query/sql",
  "scheme": "http"
};

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/
};

CREATE DATABASE solr_datasource
WITH ENGINE = 'solr',
PARAMETERS = {
  "username": "solr_user",
  "password": "password",
  "host": "127.0.0.1",
  "port": 8981,
  "server_path": "solr",
  "collection": "collection_name",
  "use_ssl": "false"
};

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
};

CREATE DATABASE ckan_datasource
WITH ENGINE = 'ckan',
PARAMETERS = {
  "url": "http://demo.ckan.org/api/3/action/",
  "apikey": "YOUR_API_KEY"
};

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`)
};

CREATE DATABASE clickhouse_datasource
WITH ENGINE = 'clickhouse',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 9000,
  "database": "test_data",
  "user": "root",
  "password": "password"
};

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
};

CREATE DATABASE cloud_spanner_datasource
WITH ENGINE = 'cloud_spanner',
PARAMETERS = {
  "instance_id": "my-instance",
  "database_id": "example-db",
  "project": "my-project",
  "credentials": "{...}"
};

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
};

CREATE DATABASE cockroach_datasource
WITH ENGINE = 'cockroachdb',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 26257,
  "database": "cockroachdb",
  "user": "username",
  "password": "password"
};

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

CREATE DATABASE couchbase_datasource
WITH ENGINE = 'couchbase',
PARAMETERS = {
  "host": "127.0.0.1",
  "user": "couchbase",
  "password": "password",
  "bucket": "test-bucket"
};

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)
};

CREATE DATABASE cratedb_datasource
WITH ENGINE = 'crate',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 4200,
  "user": "crate",
  "password": "password",
  "schema_name": "doc"
};

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"
  }
};

CREATE DATABASE d0lt_datasource
WITH ENGINE = 'd0lt',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 3306,
  "database": "information_schema",
  "user": "root",
  "password": "password"
};

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
};

CREATE DATABASE databend_datasource
WITH ENGINE = 'databend',
PARAMETERS = {
  "protocol": "native",
  "user": "databend_user",
  "port": 443,
  "password": "password",
  "host": "127.0.0.1",
  "database": "databend_db"
};

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)
};

CREATE DATABASE databricks_datasource
WITH ENGINE = 'databricks',
PARAMETERS = {
  "server_hostname": "adb-1234567890123456.7.azuredatabricks.net",
  "http_path": "sql/protocolv1/o/1234567890123456/1234-567890-test123",
  "access_token": "dapi1234567890ab1cde2f3ab456c7d89efa",
  "schema": "example_db"
};

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
};

CREATE DATABASE datastax_datasource
WITH ENGINE = 'astra',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 7077,
  "user": "datastax",
  "password": "password",
  "secure_connection_bundle": {
    "path": "/home/Downloads/file.zip"
  }
};

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
};

CREATE DATABASE duckdb_datasource
WITH ENGINE = 'duckdb',
PARAMETERS = {
  "database": "db.duckdb",
  "read_only": False
};

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)
};

CREATE DATABASE elastic_datasource
WITH ENGINE = 'elasticsearch',
PARAMETERS = {
  "hosts": "localhost:9200"
};

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
};

CREATE DATABASE firebird_datasource
WITH ENGINE = 'firebird',
PARAMETERS = {
  "host": "127.0.0.1",
  "database": "test",
  "user": "firebird",
  "password": "password"
};

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'
};

CREATE DATABASE bigquery_datasource
WITH ENGINE = 'bigquery',
PARAMETERS = {
  "project_id": "badger-345908",
  "service_account_keys": "/home/Downloads/badger-345908.json"
};

CREATE DATABASE bigquery_datasource
WITH ENGINE = 'bigquery',
PARAMETERS = {
  "project_id": "badger-345908",
  "service_account_keys": {
    "url": "https://url/badger-345908.json"
  }
};

CREATE DATABASE bq
WITH
  ENGINE = 'bigquery',
  PARAMETERS =  {
    "project_id": "bgtest-1111",
    "dataset": "mydataset",
    "service_account_json": {
      "type": "service_account",
      "project_id": "bgtest-1111",
      "private_key_id": "aaaaaaaaaa",
      "private_key": "---------BIG STRING WITH KEY-------\n",
      "client_email": "[email protected]",
      "client_id": "1111111111111",
      "auth_uri": "https://accounts.google.com/o/oauth2/auth",
      "token_uri": "https://oauth2.googleapis.com/token",
      "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
      "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/testbigquery%40bgtest-11111.iam.gserviceaccount.com"
      }
    };

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
};

CREATE DATABASE sheets_datasource
WITH ENGINE = 'sheets',
PARAMETERS = {
  "spreadsheet_id": "abc1234567",       --- located in the URL: https://docs.google.com/spreadsheets/d/abc1234567/edit#gid=0
  "sheet_name": "Invoice"
};

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"
  }
};

CREATE DATABASE greptimedb_datasource
WITH ENGINE = 'greptimedb',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 4002,
  "database": "public",
  "user": "username",
  "password": "password"
};

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
};

CREATE DATABASE db2_datasource
WITH ENGINE = 'DB2',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 25000,
  "database": "BOOKS",
  "user": "db2admin",
  "password": "password",
  "schema_name": "db2admin"
};

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)
};

CREATE DATABASE informix_datasource
WITH ENGINE = 'informix',
PARAMETERS = {
  "server": "server",
  "host": "127.0.0.1",
  "port": 9091,
  "database": "stores_demo",
  "user": "informix",
  "password": "password",
  "schema_name": "demo_schema",
  "logging_enabled": False
};

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"
  }
};

CREATE DATABASE maria_datasource
WITH ENGINE = 'mariadb',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 3306,
  "database": "mariadb",
  "user": "root",
  "password": "password"
};

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
};

CREATE DATABASE skysql_datasource
WITH ENGINE = 'mariadb',
PARAMETERS = {
  "host": "mindsdbtest.mdb0002956.db1.skysql.net",
  "port": 5001,
  "database": "mindsdb_data",
  "user": "DB00007539",
  "password": "password",
  "ssl-ca": {
    "url": "https://mindsdb-web-builds.s3.amazonaws.com/aws_skysql_chain.pem"
  }
};

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"
  }
};

CREATE DATABASE matrixone_datasource
WITH ENGINE = 'matrixone',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 6001,
  "database": "mo_catalog",
  "user": "matrixone",
  "password": "password"
};

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
};

CREATE DATABASE access_datasource
WITH ENGINE = 'access',
PARAMETERS = {
  "db_file": "example_db.accdb"
};

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
};

CREATE DATABASE mssql_datasource
WITH ENGINE = 'mssql',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 1433,
  "database": "master",
  "user": "sa",
  "password": "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)
};

CREATE DATABASE monetdb_datasource
WITH ENGINE = 'monetdb',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 50000,
  "database": "demo",
  "user": "monetdb",
  "password": "password",
  "schema_name": "sys"
};

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
};

CREATE DATABASE mongo_datasource
WITH ENGINE = 'mongo',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 27017,
  "user": "mongo",
  "password": "password",
  "database": "database"
};

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"
  }
};

CREATE DATABASE mysql_datasource
WITH ENGINE = 'mysql',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 3306,
  "database": "mysql",
  "user": "root",
  "password": "password"
};

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
};

CREATE DATABASE oceanbase_datasource
WITH ENGINE = 'oceanbase',
PARAMETERS = {
  "host": "127.0.0.1",
  "user": "oceanbase_user",
  "password": "password",
  "port": 2881,
  "database": "oceanbase_db"
};

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
};

CREATE DATABASE opengauss_datasource
WITH ENGINE = 'opengauss',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 5432,
  "database": "opengauss",
  "user": "mindsdb",
  "password": "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
};

CREATE DATABASE oracle_datasource
WITH ENGINE = 'oracle',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 1521,
  "sid": "ORCL",
  "user": "sys",
  "password": "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
};

CREATE DATABASE orioledb_datasource
WITH ENGINE = 'orioledb',
PARAMETERS = {
  "user": "orioledb_user",
  "password": "password",
  "host": "127.0.0.1",
  "port": 55505,
  "server": "server_name",
  "database": "oriole_db"
};

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
};

CREATE DATABASE planetscale_datasource
WITH ENGINE = 'planet_scale',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 3306,
  "user": "planetscale_user",
  "password": "password",
  "database": "planetscale_db"
};

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
};

CREATE DATABASE psql_datasource
WITH ENGINE = 'postgres',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 5432,
  "database": "postgres",
  "user": "postgres",
  "password": "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)
};

CREATE DATABASE questdb_datasource
WITH ENGINE = 'questdb',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 8812,
  "database": "qdb",
  "user": "admin",
  "password": "password"
};

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)
};

CREATE DATABASE sap_hana_datasource
WITH ENGINE = 'hana',
PARAMETERS = {
  "host": "<uuid>.hana.trial-us10.hanacloud.ondemand.com",
  "port": "443",
  "user": "DBADMIN",
  "password": "password",
  "schema": "MINDSDB",
  "encrypt": True
};

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"
  }
};

CREATE DATABASE scylladb_datasource
WITH ENGINE = 'scylladb',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 7199,
  "user": "[email protected]",
  "password": "password",
  "protocol_version": 4,
  "keyspace": "keyspace_name",
  "secure_connect_bundle": {
    "path": "/home/zoran/Downloads/secure-connect-mindsdb.zip"
  }
};

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"
  }
};

CREATE DATABASE singlestore_datasource
WITH ENGINE = 'singlestore',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 3306,
  "database": "singlestore",
  "user": "root",
  "password": "password"
};

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
};

CREATE DATABASE snowflake_datasource
WITH ENGINE = 'snowflake',
PARAMETERS = {
  "host": "account_name.snowflakecomputing.com",
  "port": 443,
  "database": "snowflake",
  "user": "user",
  "password": "password",
  "account": "account_name",
  "schema": "public",
  "protocol": "https",
  "warehouse": "warehouse"
};

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
};

CREATE DATABASE sqlany_datasource
WITH ENGINE = 'sqlany',
PARAMETERS = {
  "user": "sqlany_user",
  "password": "password",
  "host": "127.0.0.1",
  "port": 55505,
  "server": "server_name",
  "database": "sqlany_db"
};

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
};

CREATE DATABASE sqlite_datasource
WITH ENGINE = 'sqlite',
PARAMETERS = {
  "db_file": "example.db"
};

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
};

CREATE DATABASE starrocks_datasource
WITH ENGINE = 'starrocks',
PARAMETERS = {
  "host": "127.0.0.1",
  "user": "starrocks_user",
  "password": "password",
  "port": 8030,
  "database": "starrocks_db"
};

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
};

CREATE DATABASE supabase_datasource
WITH ENGINE = 'supabase',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 54321,
  "database": "test",
  "user": "supabase",
  "password": "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
};

CREATE DATABASE tdengine_datasource
WITH ENGINE = 'tdengine',
PARAMETERS = {
  "user": "tdengine_user",
  "password": "password",
  "url": "localhost:6041",
  "token": "token",
  "database": "tdengine_db"
};

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
};

CREATE DATABASE teradata_datasource
WITH ENGINE = 'teradata',
PARAMETERS = {
  "host": "127.0.0.1",
  "user": "teradata",
  "password": "password",
  "database": "teradata_db",
  "port": 1025
};

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
};

CREATE DATABASE tidb_datasource
WITH ENGINE = 'tidb',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 4000,
  "database": "tidb",
  "user": "root",
  "password": "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
};

CREATE DATABASE timescaledb_datasource
WITH ENGINE = 'timescaledb',
PARAMETERS = {
  "user": "timescaledb",
  "password": "password",
  "host": "127.0.0.1",
  "port": 36806,
  "database": "timescaledb_db"
};

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
};

CREATE DATABASE trino_datasource
WITH ENGINE = 'trino',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 8080,
  "user": "trino",
  "password": "password",
  "catalog": "default",
  "schema": "test"
};

CREATE DATABASE trino_datasource
WITH ENGINE = 'trino',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 443,
  "auth": "basic",
  "http_scheme": "https",
  "user": "trino",
  "password": "password",
  "catalog": "default",
  "schema": "test",
  "with": "with (transactional = true)"
};

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
};

CREATE DATABASE vertica_datasource
WITH ENGINE = 'vertica',
PARAMETERS = {
  "host": "127.0.0.1",
  "port": 5433,
  "database": "VMart",
  "user": "vertica",
  "password": "password",
  "schema_name": "public"
};

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
};

CREATE DATABASE vitess_datasource
WITH ENGINE = 'vitess',
PARAMETERS = {
  "host": "127.0.0.1",
  "user": "vitess_user",
  "password": "password",
  "port": 33577,
  "database": "vitess_db"
};

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
};

CREATE DATABASE yugabyte_datasource
WITH ENGINE = 'yugabyte',
PARAMETERS = {
  "user": "yugabyte",
  "password": "password",
  "host": "127.0.0.1",
  "port": 5433,
  "database": "yugabyte_db",
  "schema":"cd"
};

Check out the YugabyteDB data handler details here.

Overview

Data Sources

Connection

Data Catalog

Bring Your Own Models

​Airtable

​Amazon DynamoDB

​Amazon Redshift

​Amazon S3

​Apache Cassandra

​Apache Druid

​Apache Hive

​Apache Impala

​Apache Pinot

​Apache Solr

​Ckan

​ClickHouse

​Cloud Spanner

​CockroachDB

​Couchbase

​CrateDB

​D0lt

​Databend

​Databricks

​DataStax

​DuckDB

​Elasticsearch

​Firebird

​Google BigQuery

​Google Sheets

​GreptimeDB

​IBM Db2

​IBM Informix

​MariaDB

​MariaDB SkySQL

​MatrixOne

​Microsoft Access

​Microsoft SQL Server

​MonetDB

​MongoDB

​MySQL

​OceanBase

​OpenGauss

​Oracle

​OrioleDB

​PlanetScale

​PostgreSQL

​QuestDB

​SAP HANA

​ScyllaDB

​SingleStore

​Snowflake

​SQL Anywhere

​SQLite

​StarRocks

​Supabase

​TDengine

​Teradata

​TiDB

​TimescaleDB

​Trino

​Vertica

​Vitess

​YugabyteDB

Airtable

Amazon DynamoDB

Amazon Redshift

Amazon S3

Apache Cassandra

Apache Druid

Apache Hive

Apache Impala

Apache Pinot

Apache Solr

Ckan

ClickHouse

Cloud Spanner

CockroachDB

Couchbase

CrateDB

D0lt

Databend

Databricks

DataStax

DuckDB

Elasticsearch

Firebird

Google BigQuery

Google Sheets

GreptimeDB

IBM Db2

IBM Informix

MariaDB

MariaDB SkySQL

MatrixOne

Microsoft Access

Microsoft SQL Server

MonetDB

MongoDB

MySQL

OceanBase

OpenGauss

Oracle

OrioleDB

PlanetScale

PostgreSQL

QuestDB

SAP HANA

ScyllaDB

SingleStore

Snowflake

SQL Anywhere

SQLite

StarRocks

Supabase

TDengine

Teradata

TiDB

TimescaleDB

Trino

Vertica

Vitess

YugabyteDB