ContextQMD
Back to Mindsdb

Supported Integrations

docs/integrations/data-integrations/all-data-integrations.mdx

26.1.070.1 KB
Original Source

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

<p align="center"> </p>

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.

<Tip> **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. </Tip>

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

<Tip> **From Our Community**

Check out the video guides created by our community:

Airtable

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE airtable_datasource WITH ENGINE = 'airtable', PARAMETERS = { "base_id": "appve10klsda2", "table_name": "my_table", "api_key": "KdJX2Q5km%5b$T$sQYm^gvN" }; ``` </Tab> </Tabs> <Info> Check out the Airtable data handler details [here](/data-integrations/airtable). </Info>

Amazon DynamoDB

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE dynamodb_datasource WITH ENGINE = 'dynamodb', PARAMETERS = { "aws_access_key_id": "PCAQ2LJDOSWLNSQKOCPW", "aws_secret_access_key": "U/VjewPlNopsDmmwItl34r2neyC6WhZpUiip57i", "region_name": "us-east-1" }; ``` </Tab> </Tabs> <Info> Check out the Amazon DynamoDB data handler details [here](/data-integrations/amazon-dynamodb). </Info>

Amazon Redshift

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE amazonredshift_datasource WITH ENGINE = 'amazonredshift', PARAMETERS = { "host": "127.0.0.1", "port": 5439, "database": "test", "user": "amazonredshift", "password": "password" }; ``` </Tab> </Tabs> <Info> Check out the Amazon Redshift data handler details [here](/data-integrations/amazon-redshift). </Info>

Amazon S3

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql 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'}}" }; ``` </Tab> </Tabs> <Info> Check out the Amazon S3 data handler details [here](/data-integrations/amazon-s3). </Info>

Apache Cassandra

<Tabs> <Tab title="Template"> ```sql 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" } }; ``` </Tab> <Tab title="Example"> ```sql 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 }; ``` </Tab> </Tabs> <Info> Check out the Apache Cassandra data handler details [here](/data-integrations/apache-cassandra). </Info>

Apache Druid

<Tabs> <Tab title="Template"> ```sql 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) }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE druid_datasource WITH ENGINE = 'druid', PARAMETERS = { "host": "127.0.0.1", "port": 8888, "path": "/druid/v2/sql/", "scheme": "http" }; ``` </Tab> </Tabs> <Info> Check out the Apache Druid data handler details [here](/data-integrations/apache-druid). </Info>

Apache Hive

<Tabs> <Tab title="Template"> ```sql 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/ }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE hive_datasource WITH ENGINE = 'hive', PARAMETERS = { "user": "hive", "password": "password", "host": "127.0.0.1", "port": 10000, "database": "hive_db", "auth": "CUSTOM" }; ``` </Tab> </Tabs> <Info> Check out the Apache Hive data handler details [here](/data-integrations/apache-hive). </Info>

Apache Impala

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE impala_datasource WITH ENGINE = 'impala', PARAMETERS = { "user": "impala_user", "password": "password", "host": "127.0.0.1", "port": 21050, "database": "impala_db" }; ``` </Tab> </Tabs> <Info> Check out the Apache Impala data handler details [here](/data-integrations/apache-impala). </Info>

Apache Pinot

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE pinot_datasource WITH ENGINE = 'pinot', PARAMETERS = { "host": "127.0.0.1", "broker_port": 8000, "controller_port": 9000, "path": "/query/sql", "scheme": "http" }; ``` </Tab> </Tabs> <Info> Check out the Apache Pinot data handler details [here](/data-integrations/apache-pinot). </Info>

Apache Solr

<Tabs> <Tab title="Template"> ```sql 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/ }; ``` </Tab> <Tab title="Example"> ```sql 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" }; ``` </Tab> </Tabs> <Info> Check out the Apache Solr data handler details [here](/data-integrations/apache-solr). </Info>

Ckan

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE ckan_datasource WITH ENGINE = 'ckan', PARAMETERS = { "url": "http://demo.ckan.org/api/3/action/", "apikey": "YOUR_API_KEY" }; ``` </Tab> </Tabs> <Info> Check out the Ckan data handler details [here](/data-integrations/ckan). </Info>

ClickHouse

<Tabs> <Tab title="Template"> ```sql 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`) }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE clickhouse_datasource WITH ENGINE = 'clickhouse', PARAMETERS = { "host": "127.0.0.1", "port": 9000, "database": "test_data", "user": "root", "password": "password" }; ``` </Tab> </Tabs> <Info> Check out the ClickHouse data handler details [here](/data-integrations/clickhouse). </Info>

Cloud Spanner

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE cloud_spanner_datasource WITH ENGINE = 'cloud_spanner', PARAMETERS = { "instance_id": "my-instance", "database_id": "example-db", "project": "my-project", "credentials": "{...}" }; ``` </Tab> </Tabs> <Info> Check out the Cloud Spanner data handler details [here](/data-integrations/cloud-spanner). </Info>

CockroachDB

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE cockroach_datasource WITH ENGINE = 'cockroachdb', PARAMETERS = { "host": "127.0.0.1", "port": 26257, "database": "cockroachdb", "user": "username", "password": "password" }; ``` </Tab> </Tabs> <Info> Check out the CockroachDB data handler details [here](/data-integrations/cockroachdb). </Info>

Couchbase

<Tabs> <Tab title="Template"> ```sql 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 ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE couchbase_datasource WITH ENGINE = 'couchbase', PARAMETERS = { "host": "127.0.0.1", "user": "couchbase", "password": "password", "bucket": "test-bucket" }; ``` </Tab> </Tabs> <Info> Check out the Couchbase data handler details [here](/data-integrations/couchbase). </Info>

CrateDB

<Tabs> <Tab title="Template"> ```sql 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) }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE cratedb_datasource WITH ENGINE = 'crate', PARAMETERS = { "host": "127.0.0.1", "port": 4200, "user": "crate", "password": "password", "schema_name": "doc" }; ``` </Tab> </Tabs> <Info> Check out the CrateDB data handler details [here](/data-integrations/cratedb). </Info>

D0lt

<Tabs> <Tab title="Template"> ```sql 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" } }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE d0lt_datasource WITH ENGINE = 'd0lt', PARAMETERS = { "host": "127.0.0.1", "port": 3306, "database": "information_schema", "user": "root", "password": "password" }; ``` </Tab> </Tabs> <Info> Check out the D0lt data handler details [here](/data-integrations/d0lt). </Info>

Databend

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql 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" }; ``` </Tab> </Tabs> <Info> Check out the Databend data handler details [here](/data-integrations/databend). </Info>

Databricks

<Tabs> <Tab title="Template"> ```sql 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) }; ``` </Tab> <Tab title="Example"> ```sql 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" }; ``` </Tab> </Tabs> <Info> Check out the Databricks data handler details [here](/data-integrations/databricks). </Info>

DataStax

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql 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" } }; ``` </Tab> </Tabs> <Info> Check out the DataStax data handler details [here](/data-integrations/datastax). </Info>

DuckDB

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE duckdb_datasource WITH ENGINE = 'duckdb', PARAMETERS = { "database": "db.duckdb", "read_only": False }; ``` </Tab> </Tabs> <Info> Check out the DuckDB data handler details [here](/data-integrations/duckdb). </Info>

Elasticsearch

<Tabs> <Tab title="Template"> ```sql 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) }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE elastic_datasource WITH ENGINE = 'elasticsearch', PARAMETERS = { "hosts": "localhost:9200" }; ``` </Tab> </Tabs> <Info> Check out the Elasticsearch data handler details [here](/data-integrations/elasticsearch). </Info>

Firebird

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE firebird_datasource WITH ENGINE = 'firebird', PARAMETERS = { "host": "127.0.0.1", "database": "test", "user": "firebird", "password": "password" }; ``` </Tab> </Tabs> <Info> Check out the Firebird data handler details [here](/data-integrations/firebird). </Info>

Google BigQuery

<Tabs> <Tab title="Template"> ```sql 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' }; ``` </Tab> <Tab title="Example for Self-Hosted MindsDB"> ```sql CREATE DATABASE bigquery_datasource WITH ENGINE = 'bigquery', PARAMETERS = { "project_id": "badger-345908", "service_account_keys": "/home/Downloads/badger-345908.json" }; ``` </Tab> <Tab title="Example for MindsDB Cloud"> ```sql CREATE DATABASE bigquery_datasource WITH ENGINE = 'bigquery', PARAMETERS = { "project_id": "badger-345908", "service_account_keys": { "url": "https://url/badger-345908.json" } }; ``` </Tab> <Tab title="Example without JSON File"> ```sql 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" } }; ``` </Tab> </Tabs> <Info> Check out the Google BigQuery data handler details [here](/data-integrations/google-bigquery). </Info>

Google Sheets

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql 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" }; ``` </Tab> </Tabs> <Info> Check out the Google Sheets data handler details [here](/data-integrations/google-sheets). </Info>

GreptimeDB

<Tabs> <Tab title="Template"> ```sql 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" } }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE greptimedb_datasource WITH ENGINE = 'greptimedb', PARAMETERS = { "host": "127.0.0.1", "port": 4002, "database": "public", "user": "username", "password": "password" }; ``` </Tab> </Tabs> <Info> Check out the GreptimeDB data handler details [here](/data-integrations/greptimedb). </Info>

IBM Db2

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE db2_datasource WITH ENGINE = 'DB2', PARAMETERS = { "host": "127.0.0.1", "port": 25000, "database": "BOOKS", "user": "db2admin", "password": "password", "schema_name": "db2admin" }; ``` </Tab> </Tabs> <Info> Check out the IBM Db2 data handler details [here](/data-integrations/ibm-db2). </Info>

IBM Informix

<Tabs> <Tab title="Template"> ```sql 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) }; ``` </Tab> <Tab title="Example"> ```sql 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 }; ``` </Tab> </Tabs> <Info> Check out the IBM Informix data handler details [here](/data-integrations/ibm-informix). </Info>

MariaDB

<Tabs> <Tab title="Template"> ```sql 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" } }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE maria_datasource WITH ENGINE = 'mariadb', PARAMETERS = { "host": "127.0.0.1", "port": 3306, "database": "mariadb", "user": "root", "password": "password" }; ``` </Tab> </Tabs> <Info> Check out the MariaDB data handler details [here](/data-integrations/mariadb). </Info>

MariaDB SkySQL

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql 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" } }; ``` </Tab> </Tabs> <Info> For more information on how to connect MariaDB SkySQL and MindsDB, visit our [doc page here](/connect/connect-mariadb-skysql/). </Info>

MatrixOne

<Tabs> <Tab title="Template"> ```sql 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" } }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE matrixone_datasource WITH ENGINE = 'matrixone', PARAMETERS = { "host": "127.0.0.1", "port": 6001, "database": "mo_catalog", "user": "matrixone", "password": "password" }; ``` </Tab> </Tabs> <Info> Check out the MatrixOne data handler details [here](/data-integrations/matrixone). </Info>

Microsoft Access

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE access_datasource WITH ENGINE = 'access', PARAMETERS = { "db_file": "example_db.accdb" }; ``` </Tab> </Tabs> <Info> Check out the Microsoft Access data handler details [here](/data-integrations/microsoft-access). </Info>

Microsoft SQL Server

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE mssql_datasource WITH ENGINE = 'mssql', PARAMETERS = { "host": "127.0.0.1", "port": 1433, "database": "master", "user": "sa", "password": "password" }; ``` </Tab> </Tabs> <Info> Check out the Microsoft SQL Server data handler details [here](/data-integrations/microsoft-sql-server). </Info>

MonetDB

<Tabs> <Tab title="Template"> ```sql 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) }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE monetdb_datasource WITH ENGINE = 'monetdb', PARAMETERS = { "host": "127.0.0.1", "port": 50000, "database": "demo", "user": "monetdb", "password": "password", "schema_name": "sys" }; ``` </Tab> </Tabs> <Info> Check out the MonetDB data handler details [here](/data-integrations/monetdb). </Info>

MongoDB

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE mongo_datasource WITH ENGINE = 'mongo', PARAMETERS = { "host": "127.0.0.1", "port": 27017, "user": "mongo", "password": "password", "database": "database" }; ``` </Tab> </Tabs> <Info> Check out the MongoDB data handler details [here](/data-integrations/mongodb). </Info>

MySQL

<Tabs> <Tab title="Template"> ```sql 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" } }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE mysql_datasource WITH ENGINE = 'mysql', PARAMETERS = { "host": "127.0.0.1", "port": 3306, "database": "mysql", "user": "root", "password": "password" }; ``` </Tab> </Tabs> <Info> Check out the MySQL data handler details [here](/data-integrations/mysql). </Info>

OceanBase

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE oceanbase_datasource WITH ENGINE = 'oceanbase', PARAMETERS = { "host": "127.0.0.1", "user": "oceanbase_user", "password": "password", "port": 2881, "database": "oceanbase_db" }; ``` </Tab> </Tabs> <Info> Check out the OceanBase data handler details [here](/data-integrations/oceanbase). </Info>

OpenGauss

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE opengauss_datasource WITH ENGINE = 'opengauss', PARAMETERS = { "host": "127.0.0.1", "port": 5432, "database": "opengauss", "user": "mindsdb", "password": "password" }; ``` </Tab> </Tabs> <Info> Check out the OpenGauss data handler details [here](/data-integrations/opengauss). </Info>

Oracle

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE oracle_datasource WITH ENGINE = 'oracle', PARAMETERS = { "host": "127.0.0.1", "port": 1521, "sid": "ORCL", "user": "sys", "password": "password" }; ``` </Tab> </Tabs> <Info> Check out the Oracle data handler details [here](/data-integrations/oracle). </Info>

OrioleDB

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql 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" }; ``` </Tab> </Tabs> <Info> Check out the OrioleDB data handler details [here](/data-integrations/orioledb). </Info>

PlanetScale

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE planetscale_datasource WITH ENGINE = 'planet_scale', PARAMETERS = { "host": "127.0.0.1", "port": 3306, "user": "planetscale_user", "password": "password", "database": "planetscale_db" }; ``` </Tab> </Tabs> <Info> Check out the PlanetScale data handler details [here](/data-integrations/planetscale). </Info>

PostgreSQL

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE psql_datasource WITH ENGINE = 'postgres', PARAMETERS = { "host": "127.0.0.1", "port": 5432, "database": "postgres", "user": "postgres", "password": "password" }; ``` </Tab> </Tabs> <Info> Check out the PostgreSQL data handler details [here](/data-integrations/postgresql). </Info>

QuestDB

<Tabs> <Tab title="Template"> ```sql 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) }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE questdb_datasource WITH ENGINE = 'questdb', PARAMETERS = { "host": "127.0.0.1", "port": 8812, "database": "qdb", "user": "admin", "password": "password" }; ``` </Tab> </Tabs> <Info> Check out the QuestDB data handler details [here](/data-integrations/questdb). </Info>

SAP HANA

<Tabs> <Tab title="Template"> ```sql 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) }; ``` </Tab> <Tab title="Example"> ```sql 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 }; ``` </Tab> </Tabs> <Info> Check out the SAP HANA data handler details [here](/data-integrations/sap-hana). </Info>

ScyllaDB

<Tabs> <Tab title="Template"> ```sql 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" } }; ``` </Tab> <Tab title="Example"> ```sql 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" } }; ``` </Tab> </Tabs> <Info> Check out the ScyllaDB data handler details [here](/data-integrations/scylladb). </Info>

SingleStore

<Tabs> <Tab title="Template"> ```sql 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" } }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE singlestore_datasource WITH ENGINE = 'singlestore', PARAMETERS = { "host": "127.0.0.1", "port": 3306, "database": "singlestore", "user": "root", "password": "password" }; ``` </Tab> </Tabs> <Info> Check out the SingleStore data handler details [here](/data-integrations/singlestore). </Info>

Snowflake

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql 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" }; ``` </Tab> </Tabs> <Info> Check out the Snowflake data handler details [here](/data-integrations/snowflake). </Info>

SQL Anywhere

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql 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" }; ``` </Tab> </Tabs> <Info> Check out the SQL Anywhere data handler details [here](/data-integrations/sql-anywhere). </Info>

SQLite

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE sqlite_datasource WITH ENGINE = 'sqlite', PARAMETERS = { "db_file": "example.db" }; ``` </Tab> </Tabs> <Info> Check out the SQLite data handler details [here](/data-integrations/sqlite). </Info>

StarRocks

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE starrocks_datasource WITH ENGINE = 'starrocks', PARAMETERS = { "host": "127.0.0.1", "user": "starrocks_user", "password": "password", "port": 8030, "database": "starrocks_db" }; ``` </Tab> </Tabs> <Info> Check out the StarRocks data handler details [here](/data-integrations/starrocks). </Info>

Supabase

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE supabase_datasource WITH ENGINE = 'supabase', PARAMETERS = { "host": "127.0.0.1", "port": 54321, "database": "test", "user": "supabase", "password": "password" }; ``` </Tab> </Tabs> <Info> Check out the Supabase data handler details [here](/data-integrations/supabase). </Info>

TDengine

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE tdengine_datasource WITH ENGINE = 'tdengine', PARAMETERS = { "user": "tdengine_user", "password": "password", "url": "localhost:6041", "token": "token", "database": "tdengine_db" }; ``` </Tab> </Tabs> <Info> Check out the TDengine data handler details [here](/data-integrations/tdengine). </Info>

Teradata

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE teradata_datasource WITH ENGINE = 'teradata', PARAMETERS = { "host": "127.0.0.1", "user": "teradata", "password": "password", "database": "teradata_db", "port": 1025 }; ``` </Tab> </Tabs> <Info> Check out the Teradata data handler details [here](/data-integrations/teradata). </Info>

TiDB

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE tidb_datasource WITH ENGINE = 'tidb', PARAMETERS = { "host": "127.0.0.1", "port": 4000, "database": "tidb", "user": "root", "password": "password" }; ``` </Tab> </Tabs> <Info> Check out the TiDB data handler details [here](/data-integrations/tidb). </Info>

TimescaleDB

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE timescaledb_datasource WITH ENGINE = 'timescaledb', PARAMETERS = { "user": "timescaledb", "password": "password", "host": "127.0.0.1", "port": 36806, "database": "timescaledb_db" }; ``` </Tab> </Tabs> <Info> Check out the TimescaleDB data handler details [here](/data-integrations/timescaledb). </Info>

Trino

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example 1"> ```sql CREATE DATABASE trino_datasource WITH ENGINE = 'trino', PARAMETERS = { "host": "127.0.0.1", "port": 8080, "user": "trino", "password": "password", "catalog": "default", "schema": "test" }; ``` </Tab> <Tab title="Example 2"> ```sql 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)" }; ``` </Tab> </Tabs> <Info> Check out the Trino data handler details [here](/data-integrations/trino). </Info>

Vertica

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE vertica_datasource WITH ENGINE = 'vertica', PARAMETERS = { "host": "127.0.0.1", "port": 5433, "database": "VMart", "user": "vertica", "password": "password", "schema_name": "public" }; ``` </Tab> </Tabs> <Info> Check out the Vertica data handler details [here](/data-integrations/vertica). </Info>

Vitess

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE vitess_datasource WITH ENGINE = 'vitess', PARAMETERS = { "host": "127.0.0.1", "user": "vitess_user", "password": "password", "port": 33577, "database": "vitess_db" }; ``` </Tab> </Tabs> <Info> Check out the Vitess data handler details [here](/data-integrations/vitess). </Info>

YugabyteDB

<Tabs> <Tab title="Template"> ```sql 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 }; ``` </Tab> <Tab title="Example"> ```sql CREATE DATABASE yugabyte_datasource WITH ENGINE = 'yugabyte', PARAMETERS = { "user": "yugabyte", "password": "password", "host": "127.0.0.1", "port": 5433, "database": "yugabyte_db", "schema":"cd" }; ``` </Tab> </Tabs> <Info> Check out the YugabyteDB data handler details [here](/data-integrations/yugabytedb). </Info>