## Supported connections for on-premises databases

URL: https://docs.atlan.com/apps/connectors/database/on-premises-databases/references/supported-connections-for-on-premises-databases

> The metadata-extractor tool supports the following connection types.

:::danger **Deprecated**
This job execution mode was deprecated on June 30, 2026 and is no longer supported or maintained, including bug fixes. Existing workflows may break/be disabled without warning. For all implementations, switch to [Self-deployed runtime](https://docs.atlan.com/llms/platform/self-deployed-runtime/llms.txt).
:::

The metadata-extractor tool supports the following connection types.

These describe the details required when [setting up on-premises database access](https://docs.atlan.com/llms/connectors/on-premises-databases/set-up-on-premises-database-access/llms.txt).

## Amazon Redshift with basic authentication

Use `<<: *redshift` under the `environment` section to use this connection type.

Available attributes:

- `HOST` - database host name or IP address (_required_)
- `PORT` - database port (_optional, default is 5439_)
- `DATABASE` - database name (_required_)
- `USERNAME` - database username (_required_)
- `PASSWORD` - database user password (_required_)
- `EXCLUDE_FILTER_TEMPLATE` - exclude filter pattern (_optional_)
- `INCLUDE_FILTER_TEMPLATE` - include filter pattern (_optional_)
- `USE_SOURCE_SCHEMA_FILTERING` - Boolean to specify if schema-level filtering needs to be enabled while fetching schemas, tables, and columns (_optional_)
- `USE_JDBC_INTERNAL_METHODS` - Boolean to specify if JDBC internal methods need to be used as part of the extraction (_optional_)

**Example**

```
services:
 my-redshift-database:
 <<: *extract
 environment:
 <<: *redshift
 USERNAME: my-database-username
 PASSWORD: my-database-password
 HOST: redshift-host
 PORT: redshift-database-port
 DATABASE: my-database-name
 # If using Docker Swarm mode for offline extraction, format the filters as follows:
 INCLUDE_FILTER_TEMPLATE: '{"^DB1$$": ["^SCHEMA1$$", "^SCHEMA2$$"]}'
 EXCLUDE_FILTER_TEMPLATE: '{"^DB2$$": ["^SCHEMA1$$", "^SCHEMA2$$"]}'
 # If using Docker Compose for offline extraction, format the filters as follows:
 INCLUDE_FILTER_TEMPLATE: '{"^DB1$": ["^SCHEMA1$", "^SCHEMA2$"]}'
 EXCLUDE_FILTER_TEMPLATE: '{"^DB2$": ["^SCHEMA1$", "^SCHEMA2$"]}'
 USE_SOURCE_SCHEMA_FILTERING: "false"
 USE_JDBC_INTERNAL_METHODS: "false"
 volumes:
 - *shared-jdbc-drivers
 - ./output/redshift-example:/output
```

## Amazon Redshift with IAM user authentication

Use `<<: *redshift` under the `environment` section to use this connection type.

Available attributes:

- `HOST` - database host name or IP address (_required_)
- `PORT` - database port (_optional, default is 5439_)
- `DATABASE` - database name (_required_)
- `DATABASE_USER` - database username of the IAM user (_required_)
- `AWS_ACCESS_KEY_ID` - AWS access key ID (_required_)
- `AWS_SECRET_ACCESS_KEY` - AWS secret access key (_required_)
- `CLUSTER_ID` - cluster identifier of your private Amazon Redshift cluster (_optional_)
- `EXCLUDE_FILTER_TEMPLATE` - exclude filter pattern (_optional_)
- `INCLUDE_FILTER_TEMPLATE` - include filter pattern (_optional_)
- `USE_SOURCE_SCHEMA_FILTERING` - Boolean to specify if schema-level filtering needs to be enabled while fetching schemas, tables, and columns (_optional_)
- `USE_JDBC_INTERNAL_METHODS` - Boolean to specify if JDBC internal methods need to be used as part of the extraction (_optional_)

**Example**

```
services:
 redshift-iam-user-example:
 <<: *extract
 environment:
 <<: *redshift-iam-user
 AWS_ACCESS_KEY_ID: aws-access-key-id
 AWS_SECRET_ACCESS_KEY: aws-secret-access-key
 HOST: redshift-host
 DATABASE: my-database-name
 DATABASE_USER: my-database-user
 # If using Docker Swarm mode for offline extraction, format the filters as follows:
 INCLUDE_FILTER_TEMPLATE: '{"^DB1$$": ["^SCHEMA1$$", "^SCHEMA2$$"]}'
 EXCLUDE_FILTER_TEMPLATE: '{"^DB2$$": ["^SCHEMA1$$", "^SCHEMA2$$"]}'
 # If using Docker Compose for offline extraction, format the filters as follows:
 INCLUDE_FILTER_TEMPLATE: '{"^DB1$": ["^SCHEMA1$", "^SCHEMA2$"]}'
 EXCLUDE_FILTER_TEMPLATE: '{"^DB2$": ["^SCHEMA1$", "^SCHEMA2$"]}'
 CLUSTER_ID: private-cluster-id
 USE_SOURCE_SCHEMA_FILTERING: "false"
 USE_JDBC_INTERNAL_METHODS: "false"
 volumes:
 - *shared-jdbc-drivers
 - ./output/redshift-iam-user-example:/output
```

## Hive with basic authentication

Use `<<: *hive` under the `environment` section to use this connection type.

Available attributes:

- `HOST` - database host name or IP address (_required_)
- `PORT` - database port (_optional, default is 10000_)
- `DEFAULT_SCHEMA` - default schema name (_optional, default is_ `default`)
- `USERNAME` - database user name (_required_)
- `PASSWORD` - database user password (_required_)
- `SCHEMA_EXCLUDE_REGEX` - regex to exclude schemas (_optional_)
- `SCHEMA_INCLUDE_REGEX` - regex to include schemas (_optional_)
- `TEMP_TABLE_REGEX` - regex to exclude tables (_optional_)
- `USE_SOURCE_SCHEMA_FILTERING` - Boolean to specify if schema-level filtering needs to be enabled while fetching schemas, tables, and columns (_optional_)
- `EXCLUDE_FILTER_TEMPLATE` - exclude filter pattern (_optional_)
- `INCLUDE_FILTER_TEMPLATE` - include filter pattern (_optional_)
- `USE_JDBC_INTERNAL_METHODS` - Boolean to specify if JDBC internal methods need to be used as part of the extraction (_optional_)

**Example**

```
hive-example:
 <<: *hive-extract
 environment:
 <<: *hive
 HOST: hive-host
 PORT: hive-port
 DEFAULT_SCHEMA: default
 USERNAME: my-hive-username
 PASSWORD: my-hive-password
 # If using Docker Swarm mode for offline extraction, format the filters as follows:
 INCLUDE_FILTER_TEMPLATE: '{"^DB1$$": ["^SCHEMA1$$", "^SCHEMA2$$"]}'
 EXCLUDE_FILTER_TEMPLATE: '{"^DB2$$": ["^SCHEMA1$$", "^SCHEMA2$$"]}'
 # If using Docker Compose for offline extraction, format the filters as follows:
 INCLUDE_FILTER_TEMPLATE: '{"^DB1$": ["^SCHEMA1$", "^SCHEMA2$"]}'
 EXCLUDE_FILTER_TEMPLATE: '{"^DB2$": ["^SCHEMA1$", "^SCHEMA2$"]}'
 USE_SOURCE_SCHEMA_FILTERING: "false"
 USE_JDBC_INTERNAL_METHODS: "false"
 volumes:
 - *shared-jdbc-drivers
 - ./output/hive-example:/output
```

## Microsoft SQL Server with basic authentication

Use `<<: *mssql` under the `environment` section to use this connection type.

Available attributes:

- `HOST` - database host name or IP address (_required_)
- `DATABASE` - database name (_required_)
- `USERNAME` - database user name (_required_)
- `PASSWORD` - database user password (_required_)
- `USE_SOURCE_SCHEMA_FILTERING` - Boolean to specify if schema-level filtering needs to be enabled while fetching schemas, tables, and columns (_optional_)
- `EXCLUDE_FILTER_TEMPLATE` - exclude filter pattern (_optional_)
- `INCLUDE_FILTER_TEMPLATE` - include filter pattern (_optional_)
- `USE_JDBC_INTERNAL_METHODS` - Boolean to specify if JDBC internal methods need to be used as part of the extraction (_optional_)

**Example**

```
services:
 my-mssql-database:
 <<: *extract
 environment:
 <<: *mssql
 USERNAME: db-user
 PASSWORD: db-user-password
 HOST: mssql-database-host
 DATABASE: northwind
 # If using Docker Swarm mode for offline extraction, format the filters as follows:
 INCLUDE_FILTER_TEMPLATE: '{"^DB1$$": ["^SCHEMA1$$", "^SCHEMA2$$"]}'
 EXCLUDE_FILTER_TEMPLATE: '{"^DB2$$": ["^SCHEMA1$$", "^SCHEMA2$$"]}'
 # If using Docker Compose for offline extraction, format the filters as follows:
 INCLUDE_FILTER_TEMPLATE: '{"^DB1$": ["^SCHEMA1$", "^SCHEMA2$"]}'
 EXCLUDE_FILTER_TEMPLATE: '{"^DB2$": ["^SCHEMA1$", "^SCHEMA2$"]}'
 USE_SOURCE_SCHEMA_FILTERING: "false"
 USE_JDBC_INTERNAL_METHODS: "false"
 volumes:
 - *shared-jdbc-drivers
 - ./output/mssql-database:/output
```

## MySQL with basic authentication

Use `<<: *mysql` under the `environment` section to use this connection type.

Available attributes:

- `HOST` - database host name or IP address (_required_)
- `PORT` - database port (_optional, default is 3306_)
- `USERNAME` - database user name (_required_)
- `PASSWORD` - database user password (_required_)
- `USE_SOURCE_SCHEMA_FILTERING` - Boolean to specify if schema-level filtering needs to be enabled while fetching schemas, tables, and columns (_optional_)
- `EXCLUDE_FILTER_TEMPLATE` - exclude filter pattern (_optional_)
- `INCLUDE_FILTER_TEMPLATE` - include filter pattern (_optional_)
- `USE_JDBC_INTERNAL_METHODS` - Boolean to specify if JDBC internal methods need to be used as part of the extraction (_optional_)

**Example**

```
services:
 my-mysql-database:
 <<: *extract
 environment:
 <<: *mysql
 USERNAME: db-user
 PASSWORD: db-user-password
 HOST: mysql-database-host.internal
 # If using Docker Swarm mode for offline extraction, format the filters as follows:
 INCLUDE_FILTER_TEMPLATE: '{"^DB1$$": ["^SCHEMA1$$", "^SCHEMA2$$"]}'
 EXCLUDE_FILTER_TEMPLATE: '{"^DB2$$": ["^SCHEMA1$$", "^SCHEMA2$$"]}'
 # If using Docker Compose for offline extraction, format the filters as follows:
 INCLUDE_FILTER_TEMPLATE: '{"^DB1$": ["^SCHEMA1$", "^SCHEMA2$"]}'
 EXCLUDE_FILTER_TEMPLATE: '{"^DB2$": ["^SCHEMA1$", "^SCHEMA2$"]}'
 USE_SOURCE_SCHEMA_FILTERING: "false"
 USE_JDBC_INTERNAL_METHODS: "false"
 volumes:
 - *shared-jdbc-drivers
 - ./output/my-mysql-database:/output
```

## MySQL with IAM authentication

Use `<<: *mysql-iam` under the `environment` section to use this connection type.

Available attributes:

- `HOST` - database host name or IP address (_required_)
- `PORT` - database port (_optional, default is 3306_)
- `USERNAME` - database user name (_required_)
- `AWS_ACCESS_KEY_ID` - AWS access key id (_required_)
- `AWS_SECRET_ACCESS_KEY` - AWS secret access key (_required_)
- `USE_SOURCE_SCHEMA_FILTERING` - Boolean to specify if schema-level filtering needs to be enabled while fetching schemas, tables, and columns (_optional_)
- `EXCLUDE_FILTER_TEMPLATE` - exclude filter pattern (_optional_)
- `INCLUDE_FILTER_TEMPLATE` - include filter pattern (_optional_)
- `USE_JDBC_INTERNAL_METHODS` - Boolean to specify if JDBC internal methods need to be used as part of the extraction (_optional_)

**Example**

```
services:
 my-mysql-database:
 <<: *extract
 environment:
 <<: *mysql-iam
 AWS_ACCESS_KEY_ID: my-access-key-id
 AWS_SECRET_ACCESS_KEY: my-secret-access-key
 USERNAME: db-user
 HOST: mysql-database-host.internal
 # If using Docker Swarm mode for offline extraction, format the filters as follows:
 INCLUDE_FILTER_TEMPLATE: '{"^DB1$$": ["^SCHEMA1$$", "^SCHEMA2$$"]}'
 EXCLUDE_FILTER_TEMPLATE: '{"^DB2$$": ["^SCHEMA1$$", "^SCHEMA2$$"]}'
 # If using Docker Compose for offline extraction, format the filters as follows:
 INCLUDE_FILTER_TEMPLATE: '{"^DB1$": ["^SCHEMA1$", "^SCHEMA2$"]}'
 EXCLUDE_FILTER_TEMPLATE: '{"^DB2$": ["^SCHEMA1$", "^SCHEMA2$"]}'
 USE_SOURCE_SCHEMA_FILTERING: "false"
 USE_JDBC_INTERNAL_METHODS: "false"
 volumes:
 - *shared-jdbc-drivers
 - ./output/my-mysql-database:/output
```

## Oracle with basic authentication

Use `<<: *oracle` under the `environment` section to use this connection type.

Available attributes:

- `HOST` - database host name or IP address (_required_)
- `PORT` - database port (_optional, default is 1521_)
- `SERVICE_NAME` - database service name (_required_)
- `USERNAME` - database user name (_required_)
- `PASSWORD` - database user password (_required_)
- `USE_SOURCE_SCHEMA_FILTERING` - Boolean to specify if schema-level filtering needs to be enabled while fetching schemas, tables, and columns (_optional_)
- `EXCLUDE_FILTER_TEMPLATE` - exclude filter pattern (_optional_)
- `INCLUDE_FILTER_TEMPLATE` - include filter pattern (_optional_)
- `USE_JDBC_INTERNAL_METHODS` - Boolean to specify if JDBC internal methods need to be used as part of the extraction (_optional_)

**Example**

```
services:
 my-oracle-database:
 <<: *extract
 environment:
 <<: *oracle
 USERNAME: db-user
 PASSWORD: db-user-password
 HOST: oracle-database-host.internal
 SERVICE_NAME: my-service-name
 # If using Docker Swarm mode for offline extraction, format the filters as follows:
 INCLUDE_FILTER_TEMPLATE: '{"^DB1$$": ["^SCHEMA1$$", "^SCHEMA2$$"]}'
 EXCLUDE_FILTER_TEMPLATE: '{"^DB2$$": ["^SCHEMA1$$", "^SCHEMA2$$"]}'
 # If using Docker Compose for offline extraction, format the filters as follows:
 INCLUDE_FILTER_TEMPLATE: '{"^DB1$": ["^SCHEMA1$", "^SCHEMA2$"]}'
 EXCLUDE_FILTER_TEMPLATE: '{"^DB2$": ["^SCHEMA1$", "^SCHEMA2$"]}'
 USE_SOURCE_SCHEMA_FILTERING: "false"
 USE_JDBC_INTERNAL_METHODS: "false"
 volumes:
 - *shared-jdbc-drivers
 - ./output/my-oracle-database:/output
```

## PostgreSQL with basic authentication

Use `<<: *postgresql` under the `environment` section to use this connection type.

Available attributes:

- `HOST` - database host name or IP address (_required_)
- `PORT` - database port (_optional, default is 5432_)
- `DATABASE` - database name (_required_)
- `USERNAME` - database user name (_required_)
- `PASSWORD` - database user password (_required_)
- `USE_SOURCE_SCHEMA_FILTERING` - Boolean to specify if schema-level filtering needs to be enabled while fetching schemas, tables, and columns (_optional_)
- `EXCLUDE_FILTER_TEMPLATE` - exclude filter pattern (_optional_)
- `INCLUDE_FILTER_TEMPLATE` - include filter pattern (_optional_)
- `USE_JDBC_INTERNAL_METHODS` - Boolean to specify if JDBC internal methods need to be used as part of the extraction (_optional_)

**Example**

```
services:
 my-postgresql-database:
 <<: *extract
 environment:
 <<: *postgresql
 USERNAME: db-user
 PASSWORD: db-user-password
 HOST: postgresql-database-host.internal
 DATABASE: my-database-name
 # If using Docker Swarm mode for offline extraction, format the filters as follows:
 INCLUDE_FILTER_TEMPLATE: '{"^DB1$$": ["^SCHEMA1$$", "^SCHEMA2$$"]}'
 EXCLUDE_FILTER_TEMPLATE: '{"^DB2$$": ["^SCHEMA1$$", "^SCHEMA2$$"]}'
 # If using Docker Compose for offline extraction, format the filters as follows:
 INCLUDE_FILTER_TEMPLATE: '{"^DB1$": ["^SCHEMA1$", "^SCHEMA2$"]}'
 EXCLUDE_FILTER_TEMPLATE: '{"^DB2$": ["^SCHEMA1$", "^SCHEMA2$"]}'
 USE_SOURCE_SCHEMA_FILTERING: "false"
 USE_JDBC_INTERNAL_METHODS: "false"
 volumes:
 - *shared-jdbc-drivers
 - ./output/my-postgresql-database:/output
```

## PostgreSQL with IAM authentication

Use `<<: *postgresql-iam` under the `environment` section to use this connection type.

Available attributes:

- `HOST` - database host name or IP address (_required_)
- `PORT` - database port (_optional, default is 5432_)
- `DATABASE` - database name (_required_)
- `USERNAME` - database user name (_required_)
- `AWS_ACCESS_KEY_ID` - AWS access key id (_required_)
- `AWS_SECRET_ACCESS_KEY` - AWS secret access key (_required_)
- `USE_SOURCE_SCHEMA_FILTERING` - Boolean to specify if schema-level filtering needs to be enabled while fetching schemas, tables, and columns (_optional_)
- `EXCLUDE_FILTER_TEMPLATE` - exclude filter pattern (_optional_)
- `INCLUDE_FILTER_TEMPLATE` - include filter pattern (_optional_)
- `USE_JDBC_INTERNAL_METHODS` - Boolean to specify if JDBC internal methods need to be used as part of the extraction (_optional_)

**Example**

```
services:
 my-postgresql-database:
 <<: *extract
 environment:
 <<: *postgresql-iam
 AWS_ACCESS_KEY_ID: my-access-key-id
 AWS_SECRET_ACCESS_KEY: my-secret-access-key
 USERNAME: db-user
 HOST: postgresql-database-host.internal
 DATABASE: my-database-name
 # If using Docker Swarm mode for offline extraction, format the filters as follows:
 INCLUDE_FILTER_TEMPLATE: '{"^DB1$$": ["^SCHEMA1$$", "^SCHEMA2$$"]}'
 EXCLUDE_FILTER_TEMPLATE: '{"^DB2$$": ["^SCHEMA1$$", "^SCHEMA2$$"]}'
 # If using Docker Compose for offline extraction, format the filters as follows:
 INCLUDE_FILTER_TEMPLATE: '{"^DB1$": ["^SCHEMA1$", "^SCHEMA2$"]}'
 EXCLUDE_FILTER_TEMPLATE: '{"^DB2$": ["^SCHEMA1$", "^SCHEMA2$"]}'
 USE_SOURCE_SCHEMA_FILTERING: "false"
 USE_JDBC_INTERNAL_METHODS: "false"
 volumes:
 - *shared-jdbc-drivers
 - ./output/my-postgresql-database:/output
```

## Sap HANA (basic authentication)

Use `<<: *sap-hana` under the `environment` section to use this connection type.

Available attributes:

- `HOST` - database host name or IP address (_required_)
- `PORT` - database port (_optional, default is 39015_)
- `DATABASE` - database name (_required_)
- `USERNAME` - database user name (_required_)
- `PASSWORD` - database user password (_required_)
- `USE_SOURCE_SCHEMA_FILTERING` - Boolean to specify if schema-level filtering needs to be enabled while fetching schemas, tables, and columns (_optional_)
- `EXCLUDE_FILTER_TEMPLATE` - exclude filter pattern (_optional_)
- `INCLUDE_FILTER_TEMPLATE` - include filter pattern (_optional_)
- `USE_JDBC_INTERNAL_METHODS` - Boolean to specify if JDBC internal methods need to be used as part of the extraction (_optional_)

**Example**

```
services:
 my-sap-hana-database:
 <<: *extract
 environment:
 <<: *sap-hana
 USERNAME: db-user
 PASSWORD: db-user-password
 HOST: sap-hana-database-host.internal
 DATABASE: my-database-name
 # If using Docker Swarm mode for offline extraction, format the filters as follows:
 INCLUDE_FILTER_TEMPLATE: '{"^DB1$$": ["^SCHEMA1$$", "^SCHEMA2$$"]}'
 EXCLUDE_FILTER_TEMPLATE: '{"^DB2$$": ["^SCHEMA1$$", "^SCHEMA2$$"]}'
 # If using Docker Compose for offline extraction, format the filters as follows:
 INCLUDE_FILTER_TEMPLATE: '{"^DB1$": ["^SCHEMA1$", "^SCHEMA2$"]}'
 EXCLUDE_FILTER_TEMPLATE: '{"^DB2$": ["^SCHEMA1$", "^SCHEMA2$"]}'
 USE_SOURCE_SCHEMA_FILTERING: "false"
 USE_JDBC_INTERNAL_METHODS: "false"
 volumes:
 - *shared-jdbc-drivers
 - ./output/my-sap-hana-database:/output
```

## Snowflake with basic authentication

Use `<<: *snowflake` under the `environment` section to use this connection type.

Available attributes:

- `HOST` - database host name or IP address (_required_)
- `PORT` - database port (_optional, default is 443_)
- `DATABASE` - database name (_required_)
- `USERNAME` - database user name (_required_)
- `PASSWORD` - database user password (_required_)
- `USE_SOURCE_SCHEMA_FILTERING` - Boolean to specify if schema-level filtering needs to be enabled while fetching schemas, tables, and columns (_optional_)
- `EXCLUDE_FILTER_TEMPLATE` - exclude filter pattern (_optional_)
- `INCLUDE_FILTER_TEMPLATE` - include filter pattern (_optional_)
- `USE_JDBC_INTERNAL_METHODS` - Boolean to specify if JDBC internal methods need to be used as part of the extraction (_optional_)

**Example**

```
services:
 my-snowflake-database:
 <<: *extract
 environment:
 <<: *snowflake
 USERNAME: db-user
 PASSWORD: db-user-password
 HOST: snowflake-database-host.internal
 DATABASE: my-database-name
 # If using Docker Swarm mode for offline extraction, format the filters as follows:
 INCLUDE_FILTER_TEMPLATE: '{"^DB1$$": ["^SCHEMA1$$", "^SCHEMA2$$"]}'
 EXCLUDE_FILTER_TEMPLATE: '{"^DB2$$": ["^SCHEMA1$$", "^SCHEMA2$$"]}'
 # If using Docker Compose for offline extraction, format the filters as follows:
 INCLUDE_FILTER_TEMPLATE: '{"^DB1$": ["^SCHEMA1$", "^SCHEMA2$"]}'
 EXCLUDE_FILTER_TEMPLATE: '{"^DB2$": ["^SCHEMA1$", "^SCHEMA2$"]}'
 USE_SOURCE_SCHEMA_FILTERING: "false"
 USE_JDBC_INTERNAL_METHODS: "false"
 volumes:
 - *shared-jdbc-drivers
 - ./output/my-snowflake-database:/output
```

## Snowflake with OAuth authentication

Use `<<: *snowflake-oauth` under the `environment` section to use this connection type.

Available attributes:

- `HOST` - database host name or IP address (_required_)
- `PORT` - database port (_optional, default is 443_)
- `DATABASE` - database name (_required_)
- `USERNAME` - database user name (_required_)
- `CLIENT_ID` - OAuth client ID (_required_)
- `CLIENT_SECRET` - OAuth client secret (_required_)
- `USE_SOURCE_SCHEMA_FILTERING` - Boolean to specify if schema-level filtering needs to be enabled while fetching schemas, tables, and columns (_optional_)
- `EXCLUDE_FILTER_TEMPLATE` - exclude filter pattern (_optional_)
- `INCLUDE_FILTER_TEMPLATE` - include filter pattern (_optional_)
- `USE_JDBC_INTERNAL_METHODS` - Boolean to specify if JDBC internal methods need to be used as part of the extraction (_optional_)

**Example**

```
services:
 my-snowflake-database:
 <<: *extract
 environment:
 <<: *snowflake-oauth
 USERNAME: db-user
 CLIENT_ID: my-client-id
 CLIENT_SECRET: my-client-secret
 HOST: snowflake-database-host.internal
 DATABASE: my-database-name
 # If using Docker Swarm mode for offline extraction, format the filters as follows:
 INCLUDE_FILTER_TEMPLATE: '{"^DB1$$": ["^SCHEMA1$$", "^SCHEMA2$$"]}'
 EXCLUDE_FILTER_TEMPLATE: '{"^DB2$$": ["^SCHEMA1$$", "^SCHEMA2$$"]}'
 # If using Docker Compose for offline extraction, format the filters as follows:
 INCLUDE_FILTER_TEMPLATE: '{"^DB1$": ["^SCHEMA1$", "^SCHEMA2$"]}'
 EXCLUDE_FILTER_TEMPLATE: '{"^DB2$": ["^SCHEMA1$", "^SCHEMA2$"]}'
 USE_SOURCE_SCHEMA_FILTERING: "false"
 USE_JDBC_INTERNAL_METHODS: "false"
 volumes:
 - *shared-jdbc-drivers
 - ./output/my-snowflake-database:/output
```

## Teradata with basic authentication

Use `<<: *teradata` under the `environment` section to use this connection type.

Available attributes:

- `HOST` - database host name or IP address (_required_)
- `PORT` - database port (_optional, default is 1025_)
- `DATABASE` - database name (_required_)
- `USERNAME` - database user name (_required_)
- `PASSWORD` - database user password (_required_)
- `USE_SOURCE_SCHEMA_FILTERING` - Boolean to specify if schema-level filtering needs to be enabled while fetching schemas, tables, and columns (_optional_)
- `EXCLUDE_FILTER_TEMPLATE` - exclude filter pattern (_optional_)
- `INCLUDE_FILTER_TEMPLATE` - include filter pattern (_optional_)
- `USE_JDBC_INTERNAL_METHODS` - Boolean to specify if JDBC internal methods need to be used as part of the extraction (_optional_)

**Example**

```
services:
 my-teradata-database:
 <<: *extract
 environment:
 <<: *teradata
 USERNAME: db-user
 PASSWORD: db-user-password
 HOST: teradata-database-host.internal
 DATABASE: my-database-name
 # If using Docker Swarm mode for offline extraction, format the filters as follows:
 INCLUDE_FILTER_TEMPLATE: '{"^DB1$$": ["^SCHEMA1$$", "^SCHEMA2$$"]}'
 EXCLUDE_FILTER_TEMPLATE: '{"^DB2$$": ["^SCHEMA1$$", "^SCHEMA2$$"]}'
 # If using Docker Compose for offline extraction, format the filters as follows:
 INCLUDE_FILTER_TEMPLATE: '{"^DB1$": ["^SCHEMA1$", "^SCHEMA2$"]}'
 EXCLUDE_FILTER_TEMPLATE: '{"^DB2$": ["^SCHEMA1$", "^SCHEMA2$"]}'
 USE_SOURCE_SCHEMA_FILTERING: "false"
 USE_JDBC_INTERNAL_METHODS: "false"
 volumes:
 - *shared-jdbc-drivers
 - ./output/my-teradata-database:/output
```

---