Supported Integrations

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

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

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

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

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

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

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

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

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

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

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

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

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": "{...}"
};

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

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

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

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

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

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

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

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

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

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

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": "testbigquery@bgtest-11111.iam.gserviceaccount.com",
      "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"
      }
    };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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": "user@mindsdb.com",
  "password": "password",
  "protocol_version": 4,
  "keyspace": "keyspace_name",
  "secure_connect_bundle": {
    "path": "/home/zoran/Downloads/secure-connect-mindsdb.zip"
  }
};

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

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

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

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