---
title: Oracle EBS connector
description: The Oracle E-Business Suite (EBS) connector enables you to manage EBS accounts and synchronize accounts between EBS and the IDM managed user repository.
component: openicf
page_id: openicf:connector-reference:ebs
canonical_url: https://docs.pingidentity.com/openicf/connector-reference/ebs.html
section_ids:
  before_you_start: Before you start
  install_the_ebs_connector: Install the EBS connector
  configure_the_ebs_connector: Configure the EBS connector
  test_the_ebs_connector: Test the EBS connector
  ebs_remote_connector: EBS remote connector
  config-connection-pooling-ebs: Configure connection pooling
  ebs-resource-types: Supported resource types
  ebs-search-filters: Supported search filters
  attributes: Attributes
  use_the_ebs_connector: Use the EBS connector
  ebs-users: Users
  ebs-responsibilities: Responsibilities
  implemented-interfaces-org-forgerock-openicf-connectors-oracleebs-OracleEbsConnector-1.5.20.34: OpenICF Interfaces Implemented by the Oracle EBS Connector
  config-properties-org-forgerock-openicf-connectors-oracleebs-OracleEbsConnector-1.5.20.34: Oracle EBS Connector Configuration
  configuration-properties-org-forgerock-openicf-connectors-oracleebs-OracleEbsConnector-1.5.20.34: Configuration properties
  basic-configuration-properties-org-forgerock-openicf-connectors-oracleebs-OracleEbsConnector-1.5.20.34: Basic Configuration Properties
---

# Oracle EBS connector

The Oracle E-Business Suite (EBS) connector enables you to manage EBS accounts and synchronize accounts between EBS and the IDM managed user repository.

## Before you start

These instructions assume you have an EBS administrator account and access to an Oracle EBS Database. You will need the following information to configure the connector:

* Username

  Your EBS administrator account username.

* Password

  Your EBS administrator account password.

* JDBC Connection URL

  The URL to establish the connection between the connector and the EBS application.

For more information, refer to the [Oracle E-Business Suite documentation](https://docs.oracle.com/en/cloud/paas/identity-cloud/idcsc/oracleebusinesssuite-usermanagement.html#provision-and-synchronize-a-users-roles-and-responsibilities).

## Install the EBS connector

|   |                                                                                                                                                                                                                                                                                                 |
| - | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|   | To check for an Advanced Identity Cloud application for this connector, refer to:- [Application management](https://docs.pingidentity.com/pingoneaic/latest/app-management/applications.html)

- [App catalog](https://docs.pingidentity.com/pingoneaic/latest/app-management/app-catalog.html) |

You can download any connector from [Backstage](https://backstage.forgerock.com/downloads/browse/idm/featured/connectors), but some are included in the default deployment for Advanced Identity Cloud, IDM, or RCS. When using an included connector, you can skip installing it and move directly to configuration.

**Connector included in default deployment**

| Connector              | IDM                     | RCS                      |
| ---------------------- | ----------------------- | ------------------------ |
| [Oracle EBS](ebs.html) | [icon: times, set=fa]No | [icon: check, set=fa]Yes |

Download the connector .jar file from [Backstage](https://backstage.forgerock.com/downloads/browse/idm/featured/connectors).

* If you're running the connector locally, place it in the `/path/to/openidm/connectors` directory, for example:

  ```
  mv ~/Downloads/ebs-connector-1.5.20.34.jar /path/to/openidm/connectors/
  ```

* If you're using a remote connector server (RCS), place it in the `/path/to/openicf/connectors` directory on the RCS.

Download the [Oracle JDBC driver (`ojdbc8.jar`)](https://www.oracle.com/database/technologies/appdev/jdbc-downloads.html).

* If you are running the connector locally, place the library in the `/path/to/openidm/lib/` directory:

  ```
  mv ~/Downloads/ojdbc8.jar /path/to/openidm/lib/
  ```

* If you are using a remote connector server (RCS), place the library in the `/path/to/openicf/lib` directory on the RCS.

## Configure the EBS connector

Create a connector configuration using the IDM admin UI:

1. From the navigation bar, click Configure > Connectors.

2. On the Connectors page, click New Connector.

3. On the New Connector page, type a Connector Name.

4. From the Connector Type list, select EBS Connector - 1.5.20.34.

5. Complete the Base Connector Details and any applicable Additional Options.

   |   |                                                                                                              |
   | - | ------------------------------------------------------------------------------------------------------------ |
   |   | For a list of all configuration properties, refer to [EBS Connector Configuration](#ebs-config-prop-ezLink). |

6. Click Save.

When your connector is configured correctly, the connector displays as Active in the admin UI.

Refer to [this procedure](configure-connector.html#connector-wiz-REST) to create a connector configuration over REST.

## Test the EBS connector

Test that the configuration is correct by running the following command:

```
curl \
--header "X-OpenIDM-Username: openidm-admin" \
--header "X-OpenIDM-Password: openidm-admin" \
--header "Content-Type: application/json" \
--header "Accept-API-Version: resource=1.0" \
--request POST \
"https://localhost:8443/openidm/system/ebs?_action=test"
{
  "name" : "ebs",
  "enabled" : true,
  "config" : "config/provisioner.openicf/ebs",
  "connectorRef" : {
    "bundleVersion" : "[1.5.0.0,1.6.0.0)",
    "bundleName" : "org.forgerock.openicf.connectors.ebs-connector",
    "connectorName" : "org.forgerock.openicf.connectors.oracleebs.OracleEbsConnector"
  },
  "displayName" : "Oracle EBS Connector",
  "objectTypes" : [
    "__ACCOUNT__",
    "__ALL__"
  ],
  "ok" : true
}
```

If the command returns `"ok": true`, your connector has been configured correctly and can authenticate to the Oracle EBS server.

### EBS remote connector

If you want to run this connector outside of PingOne Advanced Identity Cloud or IDM, you can configure the EBS connector as a remote connector. Java Connectors installed remotely on a Java Connector Server function identically to those bundled locally within PingOne Advanced Identity Cloud or installed locally on IDM.

You can download the EBS connector [from here](https://backstage.forgerock.com/downloads/browse/idm/all/productId:idm-connectors).

Refer to [Remote connectors](remote-connector.html) for configuring the EBS remote connector.

### Configure connection pooling

The EBS connector embeds the [Apache Tomcat 9 JDBC Connection Pool](https://tomcat.apache.org/tomcat-9.0-doc/jdbc-pool.html). Learn more about the different pooling mechanisms in [Connectors by pooling mechanism](pooling.html#pooling-table).

## Supported resource types

The EBS connector supports the following resource types:

**EBS connector supported resource types**

| ICF Native Type | EBS Resource Type                         | Naming Attribute |
| --------------- | ----------------------------------------- | ---------------- |
| \_\_ACCOUNT\_\_ | [User](#ebs-users)                        | \_\_NAME\_\_     |
| RESPONSIBILITY  | [Responsibilities](#ebs-responsibilities) | \_\_NAME\_\_     |

## Supported search filters

The EBS connector supports Search operations with the following filter operators and attributes:

**Supported Operators and Filter Attributes With EBS Searches**

| Object Type     | Operators                                       | Attributes                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| --------------- | ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| \_\_ACCOUNT\_\_ | And, Contains, StartsWith, Equals, EndsWith, Or | * USER\_ID

* USER\_NAME

* LAST\_UPDATE\_DATE

* LAST\_UPDATE\_BY

* CREATION\_DATE

* CREATED\_BY

* LAST\_UPDATE\_LOGIN

* ENCRYPTED\_USER\_PASSWORD

* SESSION\_NUMBER

* START\_DATE

* END\_DATE

* DESCRIPTION

* LAST\_LOGON\_DATE

* PASSWORD\_DATE

* PASSWORD\_ACCESSES\_LEFT

* PASSWORD\_LIFESPAN\_ACCESSES

* PASSWORD\_LIFESPAN\_DAYS

* EMAIL\_ADDRESS

* FAX

* RESPONSIBILITY                                                                                 |
| RESPONSIBILITY  | Equals, And, Or                                 | - RESPONSIBILITY\_ID

- APPLICATION\_ID

- LAST\_UPDATE\_DATE

- LAST\_UPDATED\_BY

- CREATION\_DATE

- CREATED\_BY

- LAST\_UPDATE\_LOGIN

- DATA\_GROUP\_APPLICATION\_ID

- DATA\_GROUP\_ID

- MENU\_ID

- TERM\_SECURITY\_ENABLED\_FLAG

- START\_DATE

- END\_DATE

- GROUP\_APPLICATION\_ID

- REQUEST\_GROUP\_ID

- VERSION

- WEB\_HOST\_NAME

- WEB\_AGENT\_NAME

- RESPONSIBILITY\_KEY

- RESPONSIBILITY\_NAME

- SECURITY\_GROUP\_ID

- ZD\_EDITION\_NAME

- ZD\_SYNC |

## Attributes

The following attributes are supported by the connector:

| Attributes                   | Description                                     |
| ---------------------------- | ----------------------------------------------- |
| `USER_ID`                    | The user's User ID                              |
| `USER_NAME`                  | The user's username                             |
| `ENCRYPTED_USER_PASSWORD`    | The user's encrypted password                   |
| `SESSION_NUMBER`             | Number of sessions                              |
| `START_DATE`                 | Start date for the created user                 |
| `END_DATE`                   | End date for the created user                   |
| `DESCRIPTION`                | The user's description                          |
| `LAST_LOGON_DATE`            | Last logged on date                             |
| `PASSWORD_DATE`              | The date the current password was set           |
| `PASSWORD_ACCESSES_LEFT`     | The number of accesses left for the password    |
| `PASSWORD_LIFESPAN_ACCESSES` | The number of accesses allowed for the password |
| `PASSWORD_LIFESPAN_DAYS`     | The number of days allowed for the password     |
| `EMAIL_ADDRESS`              | The user's email address                        |
| `FAX`                        | The user's fax number                           |

## Use the EBS connector

The EBS connector can perform the following actions:

### Users

> **Collapse: Create a user**
>
> The following example creates a user with all the creatable attributes:
>
> ```
> curl \
> --header "X-OpenIDM-Username: openidm-admin" \
> --header "X-OpenIDM-Password: openidm-admin" \
> --header "Content-Type: application/json" \
> --request POST \
> --data
> '{
>   "__NAME__": "BJENSEN",
>   "__PASSWORD__": "Test@123",
>   "EMAIL_ADDRESS": "bjensen@forgerock.com",
>   "SESSION_NUMBER": "2",
>   "START_DATE": "03-Nov-22",
>   "END_DATE": "08-Nov-22",
>   "LAST_LOGON_DATE": "08-DEC-2021",
>   "PASSWORD_DATE": "08-JUN-2021",
>   "PASSWORD_ACCESSES_LEFT": "1",
>   "PASSWORD_LIFESPAN_ACCESSES": "1",
>   "PASSWORD_LIFESPAN_DAYS": "1"
> }' \
> "https://localhost:8443/openidm/system/ebs/__ACCOUNT__?_action=create"
> {
>   "_id": "1015488",
>   "USER_ID": "1015488",
>   "START_DATE": "03-Nov-22",
>   "LAST_UPDATE_LOGIN": 1015131,
>   "USER_NAME": "BJENSEN",
>   "__ENABLE__": false,
>   "EMAIL_ADDRESS": "bjensen@forgerock.com",
>   "SESSION_NUMBER": 2,
>   "LAST_LOGON_DATE": "08-Dec-21",
>   "PASSWORD_ACCESSES_LEFT": 1,
>   "PASSWORD_LIFESPAN_ACCESSES": 1,
>   "END_DATE": "08-Nov-22",
>   "PASSWORD_LIFESPAN_DAYS": 1,
>   "PASSWORD_DATE": "08-Jun-21",
>   "__NAME__": "BJENSEN",
>   "LAST_UPDATE_DATE": "02-Dec-22"
> }
> ```
>
> |   |                                                                                                                                                                                |
> | - | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
> |   | When you create a new user, you must specify at least the `__NAME__` attribute.`__NAME__` has a maximum length of 100 characters, should be in UPPER CASE, and must be unique. |

> **Collapse: Query a user by id**
>
> The following queries a specific user by their ID:
>
> ```
> curl \
> --header "X-OpenIDM-Username: openidm-admin" \
> --header "X-OpenIDM-Password: openidm-admin" \
> --header "Content-Type: application/json" \
> --request GET \
> "https://localhost:8443/openidm/system/ebs/__ACCOUNT__/1015488"
> {
>   "_id": "1015488",
>   "USER_ID": "1015488",
>   "START_DATE": "03-Nov-22",
>   "LAST_UPDATE_LOGIN": 1015131,
>   "USER_NAME": "BJENSEN",
>   "__ENABLE__": false,
>   "EMAIL_ADDRESS": "bjensen@forgerock.com",
>   "SESSION_NUMBER": 7,
>   "LAST_LOGON_DATE": "08-Dec-21",
>   "PASSWORD_ACCESSES_LEFT": 1,
>   "PASSWORD_LIFESPAN_ACCESSES": 1,
>   "END_DATE": "08-Nov-22",
>   "PASSWORD_LIFESPAN_DAYS": 1,
>   "PASSWORD_DATE": "08-Jun-21",
>   "__NAME__": "BJENSEN",
>   "DESCRIPTION": "ebsuser",
>   "LAST_UPDATE_DATE": "02-Dec-22"
> }
> ```

> **Collapse: Query all users**
>
> The following example queries all users:
>
> ```
> curl \
> --header "X-OpenIDM-Username: openidm-admin" \
> --header "X-OpenIDM-Password: openidm-admin" \
> --header "Content-Type: application/json" \
> --header "Accept-API-Version: resource=1.0" \
> --request GET \
> "https://localhost:8443/openidm/system/ebs/__ACCOUNT__?_queryId=query-all-ids"
> {
>   "result":[
>     {"_id":"1000001"},
>     {"_id":"3"},
>     {"_id":"2"},
>     {"_id":"0"},
>     {"_id":"1001"},
>     {"_id":"1555"},
>     {"_id":"1003"},
>     {"_id":"1004"},
>     {"_id":"1005"},
>     {"_id":"1007"}
>     ],
>   "resultCount":10,
>   "pagedResultsCookie":null,
>   "totalPagedResultsPolicy":"NONE",
>   "totalPagedResults":-1,
>   "remainingPagedResults":-1
> }
> ```

> **Collapse: Update a user**
>
> The EBS Connector can modify the following attributes of a user entry:
>
> * `__PASSWORD__`
>
> * `__ENABLE__`
>
> * `EMAIL_ADDRESS`
>
> * `START_DATE`
>
> * `END_DATE`
>
> The following example updates a user:
>
> ```
> curl \
> --header "X-OpenIDM-Username: openidm-admin" \
> --header "X-OpenIDM-Password: openidm-admin" \
> --header "If-Match: *" \
> --header "Content-Type: application/json" \
> --request  PUT \
> --data '{
>   "__NAME__": "BJENSEN",
>   "__PASSWORD__": "Test@123",
>   "EMAIL_ADDRESS": "bjensen@forgerock.com",
>   "SESSION_NUMBER": "7",
>   "START_DATE": "03-Nov-22",
>   "END_DATE": "08-Nov-22",
>   "LAST_LOGON_DATE": "08-DEC-2021",
>   "PASSWORD_DATE": "08-JUN-2021",
>   "PASSWORD_ACCESSES_LEFT": "1",
>   "PASSWORD_LIFESPAN_ACCESSES": "1",
>   "PASSWORD_LIFESPAN_DAYS": "1",
>   "DESCRIPTION": "ebsuser"
> }' \
> "https://localhost:8443/openidm/system/ebs/__ACCOUNT__/1015488"
> {
>   "_id" : "1015488",
>   "USER_ID" : "1015488",
>   "START_DATE" : "03-Nov-22",
>   "LAST_UPDATE_LOGIN" : 1015131,
>   "USER_NAME" : "BJENSEN",
>   "__ENABLE__" : false,
>   "EMAIL_ADDRESS" : "bjensen@forgerock.com",
>   "SESSION_NUMBER" : 7,
>   "LAST_LOGON_DATE" : "08-Dec-21",
>   "PASSWORD_ACCESSES_LEFT" : 1,
>   "PASSWORD_LIFESPAN_ACCESSES" : 1,
>   "END_DATE" : "08-Nov-22",
>   "PASSWORD_LIFESPAN_DAYS" : 1,
>   "PASSWORD_DATE" : "08-Jun-21",
>   "__NAME__" : "BJENSEN",
>   "DESCRIPTION" : "ebsuser",
>   "LAST_UPDATE_DATE" : "02-Dec-22"
> }
> ```

> **Collapse: Reset a user's password**
>
> To reset the password for a user account, update the user's `"__PASSWORD__"` attribute:
>
> ```
> curl \
> --header "Content-Type: application/json" \
> --header "X-OpenIDM-Username: openidm-admin" \
> --header "X-OpenIDM-Password: openidm-admin" \
> --header "if-Match:*" \
> --request PUT \
> --data '{
>   "__NAME__": "BJENSEN",
>   "__PASSWORD__": "RRvts125!"
> }' \
> "https://localhost:8443/openidm/system/ebs/__ACCOUNT__/1015488"
> {
>   "_id" : "1015488",
>   "USER_ID" : "1015488",
>   "START_DATE" : "03-Nov-22",
>   "LAST_UPDATE_LOGIN" : 1015131,
>   "USER_NAME" : "BJENSEN",
>   "__ENABLE__" : false,
>   "EMAIL_ADDRESS" : "bjensen@forgerock.com",
>   "SESSION_NUMBER" : 7,
>   "LAST_LOGON_DATE" : "08-Dec-21",
>   "PASSWORD_ACCESSES_LEFT" : 1,
>   "PASSWORD_LIFESPAN_ACCESSES" : 1,
>   "END_DATE" : "08-Nov-22",
>   "PASSWORD_LIFESPAN_DAYS" : 1,
>   "PASSWORD_DATE" : "08-Jun-21",
>   "__NAME__": "BJENSEN",
>   "DESCRIPTION" : "ebsuser",
>   "LAST_UPDATE_DATE" : "02-Dec-22"
> }
> ```

> **Collapse: Enable a user**
>
> The following example enables a user. Include only the `__ENABLE__` attribute in the payload.
>
> ```
> curl \
> --header "Content-Type: application/json" \
> --header "X-OpenIDM-Username: openidm-admin" \
> --header "X-OpenIDM-Password: openidm-admin" \
> --request PATCH \
> --data '[ {
>   "operation": "replace",
>   "field": "__ENABLE__",
>   "value": true
> } ]' \
> "https://localhost:8443/openidm/system/ebs/__ACCOUNT__/1015488"
> {
>   "_id" : "1015488",
>   "USER_ID" : "1015488",
>   "START_DATE" : "02-Dec-22",
>   "LAST_UPDATE_LOGIN" : -1,
>   "USER_NAME" : "BJENSEN",
>   "__ENABLE__" : true,
>   "EMAIL_ADDRESS" : "bjensen@forgerock.com",
>   "SESSION_NUMBER" : 7,
>   "LAST_LOGON_DATE" : "08-Dec-21",
>   "PASSWORD_ACCESSES_LEFT" : 1,
>   "PASSWORD_LIFESPAN_ACCESSES" : 1,
>   "PASSWORD_LIFESPAN_DAYS" : 1,
>   "PASSWORD_DATE" : "08-Jun-21",
>   "__NAME__" : "BJENSEN",
>   "DESCRIPTION" : "ebsuser",
>   "LAST_UPDATE_DATE" : "02-Dec-22"
> }
> ```

> **Collapse: Disable a user**
>
> The following example disables a user. Include only the `__ENABLE__` attribute in the payload.
>
> ```
> curl \
> --header "Content-Type: application/json" \
> --header "X-OpenIDM-Username: openidm-admin" \
> --header "X-OpenIDM-Password: openidm-admin" \
> --request PATCH \
> --data '[ {
>   "operation": "replace",
>   "field": "__ENABLE__",
>   "value": false
> } ]' \
> "https://localhost:8443/openidm/system/ebs/__ACCOUNT__/1015488"
> {
>   "_id" : "1015488",
>   "USER_ID" : "1015488",
>   "START_DATE" : "03-Nov-22",
>   "LAST_UPDATE_LOGIN" : -1,
>   "USER_NAME" : "BJENSEN",
>   "__ENABLE__" : false,
>   "EMAIL_ADDRESS" : "bjensen@forgerock.com",
>   "SESSION_NUMBER" : 7,
>   "LAST_LOGON_DATE" : "08-Dec-21",
>   "PASSWORD_ACCESSES_LEFT" : 1,
>   "PASSWORD_LIFESPAN_ACCESSES" : 1,
>   "END_DATE" : "02-Dec-22",
>   "PASSWORD_LIFESPAN_DAYS" : 1,
>   "PASSWORD_DATE" : "08-Jun-21",
>   "__NAME__" : "BJENSEN",
>   "DESCRIPTION" : "ebsuser",
>   "LAST_UPDATE_DATE" : "02-Dec-22"
> }
> ```

### Responsibilities

> **Collapse: Assign responsibilities to a user**
>
> |   |                                                                                                                                                                                     |
> | - | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
> |   | After a user has been assigned a responsibility, the `START_DATE` and `END_DATE` can't be changed. To edit either of these values, remove the responsibility and then add it again. |
>
> ```
> curl \
> --header "X-OpenIDM-Username: openidm-admin" \
> --header "X-OpenIDM-Password: openidm-admin" \
> --header "Content-Type: application/json" \
> --header "if-Match:*" \
> --request PUT \
> --data '{
>   "__NAME__": "STUBBS",
>   "__PASSWORD__": "Test@231",
>   "EMAIL_ADDRESS": "STUBBS.SON@example.com",
>   "SESSION_NUMBER": "3",
>   "FAX": "56",
>   "START_DATE": "15-Jan-24",
>   "END_DATE": "23-Jan-24",
>   "LAST_LOGON_DATE": "23-DEC-2021",
>   "PASSWORD_DATE": "12-JUN-2022",
>   "PASSWORD_ACCESSES_LEFT": "2",
>   "PASSWORD_LIFESPAN_ACCESSES": "3",
>   "DESCRIPTION": "EBSBARUSER",
>   "PASSWORD_LIFESPAN_DAYS": "2",
>   "RESPONSIBILITY": [
>     {
>       "RESP_APP": "IBE",
>       "RESP_KEY": "IBE_CUSTOMER",
>       "RESPONSIBILITY_SECURITY_GROUP": "STANDARD",
>       "RESPONSIBILITY_DESCRIPTION": "updated",
>       "RESPONSIBILITY_START_DATE": "29-SEP-2021",
>       "RESPONSIBILITY_END_DATE": "29-SEP-2024"
>     },
>     {
>       "RESP_APP": "CS",
>       "RESP_KEY": "CS_KB_SYSTEM_ADMIN",
>       "RESPONSIBILITY_SECURITY_GROUP": "STANDARD",
>       "RESPONSIBILITY_DESCRIPTION": "updated",
>       "RESPONSIBILITY_START_DATE": "29-SEP-2021",
>       "RESPONSIBILITY_END_DATE": "29-SEP-2024"
>     },
>     {
>       "RESP_APP": "PA",
>       "RESP_KEY": "PROJECT_BILLING_SUPER_USER",
>       "RESPONSIBILITY_SECURITY_GROUP": "STANDARD",
>       "RESPONSIBILITY_DESCRIPTION": "responded",
>       "RESPONSIBILITY_START_DATE": "15-JUL-2021",
>       "RESPONSIBILITY_END_DATE": "13-SEP-2024"
>     }
>   ]
> }' \
> "https://localhost:8443/openidm/system/ebs/__ACCOUNT__/1017315"
> {
>   "_id": "1017315",
>   "PASSWORD_DATE": "12-Jun-22",
>   "LAST_UPDATE_LOGIN": 1015131,
>   "__ENABLE__": false,
>   "PASSWORD_ACCESSES_LEFT": 2,
>   "__NAME__": "STUBBS",
>   "END_DATE": "23-Jan-24",
>   "DESCRIPTION": "EBSBARUSER",
>   "EMAIL_ADDRESS": "STUBBS.SON@example.com",
>   "LAST_LOGON_DATE": "23-Dec-21",
>   "RESPONSIBILITY": [
>     {
>       "RESP_KEY": "PROJECT_BILLING_SUPER_USER",
>       "RESPONSIBILITY_SECURITY_GROUP": "STANDARD",
>       "RESP_APP": "PA",
>       "RESPONSIBILITY_DESCRIPTION": "responded",
>       "RESPONSIBILITY_START_DATE": "15-Jul-21",
>       "RESPONSIBILITY_END_DATE": "13-Sep-24"
>     },
>     {
>       "RESP_KEY": "CS_KB_SYSTEM_ADMIN",
>       "RESPONSIBILITY_SECURITY_GROUP": "STANDARD",
>       "RESP_APP": "CS",
>       "RESPONSIBILITY_DESCRIPTION": "updated",
>       "RESPONSIBILITY_START_DATE": "29-Sep-21",
>       "RESPONSIBILITY_END_DATE": "29-Sep-24"
>     },
>     {
>       "RESP_KEY": "IBE_CUSTOMER",
>       "RESPONSIBILITY_SECURITY_GROUP": "STANDARD",
>       "RESP_APP": "IBE",
>       "RESPONSIBILITY_DESCRIPTION": "updated",
>       "RESPONSIBILITY_START_DATE": "29-Sep-21",
>       "RESPONSIBILITY_END_DATE": "29-Sep-24"
>     }
>   ],
>   "PASSWORD_LIFESPAN_DAYS": 2,
>   "START_DATE": "15-Jan-24",
>   "LAST_UPDATE_DATE": "17-May-24",
>   "PASSWORD_LIFESPAN_ACCESSES": 3,
>   "USER_ID": "1017315",
>   "SESSION_NUMBER": 3,
>   "FAX": "56"
> }
> ```

> **Collapse: Remove responsibilities from a user**
>
> |   |                                                                                 |
> | - | ------------------------------------------------------------------------------- |
> |   | When you remove a responsibility the `END_DATE` is updated to the current date. |
>
> ```
> curl \
> --header "X-OpenIDM-Username: openidm-admin" \
> --header "X-OpenIDM-Password: openidm-admin" \
> --header "Content-Type: application/json" \
> --header "if-Match:*" \
> --request PUT \
> --data '{
>   "__NAME__": "STUBBS",
>   "__PASSWORD__": "Test@231",
>   "EMAIL_ADDRESS": "STUBBS.SON@example.com",
>   "SESSION_NUMBER": "3",
>   "FAX": "56",
>   "START_DATE": "15-Jan-24",
>   "END_DATE": "23-Jan-24",
>   "LAST_LOGON_DATE": "23-DEC-2021",
>   "PASSWORD_DATE": "12-JUN-2022",
>   "PASSWORD_ACCESSES_LEFT": "2",
>   "PASSWORD_LIFESPAN_ACCESSES": "3",
>   "DESCRIPTION": "EBSBARUSER",
>   "PASSWORD_LIFESPAN_DAYS": "2",
>   "RESPONSIBILITY": [
>     {
>       "RESP_APP": "IBE",
>       "RESP_KEY": "IBE_CUSTOMER",
>       "RESPONSIBILITY_SECURITY_GROUP": "STANDARD",
>       "RESPONSIBILITY_DESCRIPTION": "updated",
>       "RESPONSIBILITY_START_DATE": "29-SEP-2021",
>       "RESPONSIBILITY_END_DATE": "29-SEP-2024"
>     },
>     {
>       "RESP_APP": "CS",
>       "RESP_KEY": "CS_KB_SYSTEM_ADMIN",
>       "RESPONSIBILITY_SECURITY_GROUP": "STANDARD",
>       "RESPONSIBILITY_DESCRIPTION": "updated",
>       "RESPONSIBILITY_START_DATE": "29-SEP-2021",
>       "RESPONSIBILITY_END_DATE": "29-SEP-2024"
>     }
>   ]
> }' \
> "https://localhost:8443/openidm/system/ebs/__ACCOUNT__/1017315"
> {
>   "_id": "1017315",
>   "PASSWORD_DATE": "12-Jun-22",
>   "LAST_UPDATE_LOGIN": 1015131,
>   "__ENABLE__": false,
>   "PASSWORD_ACCESSES_LEFT": 2,
>   "__NAME__": "STUBBS",
>   "END_DATE": "23-Jan-24",
>   "DESCRIPTION": "EBSBARUSER",
>   "EMAIL_ADDRESS": "STUBBS.SON@example.com",
>   "LAST_LOGON_DATE": "23-Dec-21",
>   "RESPONSIBILITY": [
>     {
>       "RESP_KEY": "PROJECT_BILLING_SUPER_USER",
>       "RESPONSIBILITY_SECURITY_GROUP": "STANDARD",
>       "RESP_APP": "PA",
>       "RESPONSIBILITY_DESCRIPTION": "",
>       "RESPONSIBILITY_START_DATE": "15-Jul-21",
>       "RESPONSIBILITY_END_DATE": "17-May-24"
>     },
>     {
>       "RESP_KEY": "CS_KB_SYSTEM_ADMIN",
>       "RESPONSIBILITY_SECURITY_GROUP": "STANDARD",
>       "RESP_APP": "CS",
>       "RESPONSIBILITY_DESCRIPTION": "updated",
>       "RESPONSIBILITY_START_DATE": "29-Sep-21",
>       "RESPONSIBILITY_END_DATE": "29-Sep-24"
>     },
>     {
>       "RESP_KEY": "IBE_CUSTOMER",
>       "RESPONSIBILITY_SECURITY_GROUP": "STANDARD",
>       "RESP_APP": "IBE",
>       "RESPONSIBILITY_DESCRIPTION": "updated",
>       "RESPONSIBILITY_START_DATE": "29-Sep-21",
>       "RESPONSIBILITY_END_DATE": "29-Sep-24"
>     }
>   ],
>   "PASSWORD_LIFESPAN_DAYS": 2,
>   "START_DATE": "15-Jan-24",
>   "LAST_UPDATE_DATE": "17-May-24",
>   "PASSWORD_LIFESPAN_ACCESSES": 3,
>   "USER_ID": "1017315",
>   "SESSION_NUMBER": 3,
>   "FAX": "56"
> }
> ```

> **Collapse: Query all responsibilities**
>
> The following example queries all user responsibilities by their IDs:
>
> ```
> curl \
> --header "X-OpenIDM-Username: openidm-admin" \
> --header "X-OpenIDM-Password: openidm-admin" \
> --header "Content-Type: application/json" \
> --request GET \
> "https://localhost:8443/openidm/system/ebs/RESPONSIBILITY?_queryId=query-all-ids"
> {
>   "result": [
>     {
>       "_id": "21766"
>     },
>     {
>       "_id": "21765"
>     },
>     {
>       "_id": "21764"
>     },
>     ...
>   ],
>   "resultCount": 5104,
>   "pagedResultsCookie": null,
>   "totalPagedResultsPolicy": "NONE",
>   "totalPagedResults": -1,
>   "remainingPagedResults": -1
> }
> ```

> **Collapse: Query a single responsibility**
>
> The following example queries a single user responsibility (`50832`):
>
> ```
> curl \
> --header "X-OpenIDM-Username: openidm-admin" \
> --header "X-OpenIDM-Password: openidm-admin" \
> --header "Content-Type: application/json" \
> --request GET \
> "https://localhost:8443/openidm/system/ebs/RESPONSIBILITY?_queryFilter=_id%20eq%20%2250832%22"
> {
>   "result": [
>     {
>       "_id": "50832",
>       "LAST_UPDATE_LOGIN": 0,
>       "ZD_SYNC": "SYNCED",
>       "RESPONSIBILITY_KEY": "CHEF CULINAIR",
>       "ZD_EDITION_NAME": "SET1",
>       "DATA_GROUP_ID": "0",
>       "DATA_GROUP_APPLICATION_ID": "20021",
>       "MENU_ID": "1000542",
>       "WEB_HOST_NAME": "`",
>       "START_DATE": "10-Feb-98",
>       "CREATION_DATE": "10-Feb-98",
>       "LAST_UPDATE_DATE": "10-Feb-98",
>       "VERSION": "4",
>       "APPLICATION_ID": "20021",
>       "RESPONSIBILITY_ID": "50832",
>       "LAST_UPDATED_BY": 2,
>       "__NAME__": "CHEF CULINAIR",
>       "CREATED_BY": 0,
>       "RESPONSIBILITY_NAME": "Chef"
>     }
>   ],
>   "resultCount": 1,
>   "pagedResultsCookie": null,
>   "totalPagedResultsPolicy": "NONE",
>   "totalPagedResults": -1,
>   "remainingPagedResults": -1
> }
> ```

## OpenICF Interfaces Implemented by the Oracle EBS Connector

The Oracle EBS Connector implements the following OpenICF interfaces. For additional details, see [ICF interfaces](interfaces.html):

* Create

  Creates an object and its `uid`.

* Delete

  Deletes an object, referenced by its `uid`.

* Schema

  Describes the object types, operations, and options that the connector supports.

* Script on Connector

  Enables an application to run a script in the context of the connector.

  Any script that runs on the connector has the following characteristics:

  * The script runs in the same execution environment as the connector and has access to all the classes to which the connector has access.

  * The script has access to a `connector` variable that is equivalent to an initialized instance of the connector. At a minimum, the script can access the connector configuration.

  * The script has access to any script arguments passed in by the application.

* Search

  Searches the target resource for all objects that match the specified object class and filter.

* Sync

  Polls the target resource for synchronization events, that is, native changes to objects on the target resource.

* Test

  Tests the connector configuration.

  Testing a configuration checks all elements of the environment that are referred to by the configuration are available. For example, the connector might make a physical connection to a host that is specified in the configuration to verify that it exists and that the credentials that are specified in the configuration are valid.

  This operation might need to connect to a resource, and, as such, might take some time. Do not invoke this operation too often, such as before every provisioning operation. The test operation is not intended to check that the connector is alive (that is, that its physical connection to the resource has not timed out).

  You can invoke the test operation before a connector configuration has been validated.

* Update

  Updates (modifies or replaces) objects on a target resource.

[]()

## Oracle EBS Connector Configuration

The Oracle EBS Connector has the following configurable properties:

### Configuration properties

| Property                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | Type      | Default                                | Encrypted(1) | Required(2)              |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------- | -------------------------------------- | ------------ | ------------------------ |
| `connectionProperties`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `String`  | `null`                                 |              | [icon: times, set=fas]No |
| The connection properties that will be sent to our JDBC driver when establishing new connections. Format of the string must be \[propertyName=property;]\* NOTE - The `user` and `password` properties will be passed explicitly, so they do not need to be included here.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |           |                                        |              |                          |
| `propagateInterruptState`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `boolean` | `false`                                |              | [icon: times, set=fas]No |
| Set this to true to propagate the interrupt state for a thread that has been interrupted (not clearing the interrupt state). Set it to `false` for backwards compatibility.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |           |                                        |              |                          |
| `useDisposableConnectionFacade`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `boolean` | `true`                                 |              | [icon: times, set=fas]No |
| Set this to true if you wish to put a facade on your connection so that it cannot be reused after it has been closed. This prevents a thread holding on to a reference of a connection it has already called closed on, to execute queries on it.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |           |                                        |              |                          |
| `defaultCatalog`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `String`  | `null`                                 |              | [icon: times, set=fas]No |
| The default catalog of connections created by this pool.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |           |                                        |              |                          |
| `validationInterval`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `long`    | `3000`                                 |              | [icon: times, set=fas]No |
| To avoid excess validation, run validation at most at this frequency (in milliseconds). If a connection is due for validation, but was validated within this interval, it will not be validated again.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |           |                                        |              |                          |
| `ignoreExceptionOnPreLoad`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `boolean` | `false`                                |              | [icon: times, set=fas]No |
| Flag whether ignore error of connection creation while initializing the pool. Set to true if you want to ignore error of connection creation while initializing the pool. Set to false if you want to fail the initialization of the pool by throwing exception.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |           |                                        |              |                          |
| `jmxEnabled`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `boolean` | `true`                                 |              | [icon: times, set=fas]No |
| Register the pool with JMX or not.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |           |                                        |              |                          |
| `commitOnReturn`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `boolean` | `false`                                |              | [icon: times, set=fas]No |
| If autoCommit==false then the pool can complete the transaction by calling commit on the connection as it is returned to the pool If rollbackOnReturn==true then this attribute is ignored.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |           |                                        |              |                          |
| `logAbandoned`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `boolean` | `false`                                |              | [icon: times, set=fas]No |
| Flag to log stack traces for application code which abandoned a Connection. Logging of abandoned Connections adds overhead for every Connection borrow because a stack trace has to be generated.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |           |                                        |              |                          |
| `maxIdle`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `int`     | `100`                                  |              | [icon: times, set=fas]No |
| The maximum number of connections that should be kept in the pool at all times. Idle connections are checked periodically (if enabled) and connections that have been idle for longer than minEvictableIdleTimeMillis are released. The default value is derived from `maxActive`. (Also see `testWhileIdle`).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |           |                                        |              |                          |
| `testWhileIdle`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `boolean` | `false`                                |              | [icon: times, set=fas]No |
| The indication of whether objects will be validated by the idle object evictor (if any). If an object fails to validate, it will be dropped from the pool. NOTE - for a true value to have any effect, the validationQuery parameter must be set to a non-null string. This property has to be set in order for the pool cleaner/test thread is to run (also see `timeBetweenEvictionRunsMillis`).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |           |                                        |              |                          |
| `removeAbandoned`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `boolean` | `false`                                |              | [icon: times, set=fas]No |
| Flag to remove abandoned connections if they exceed the removeAbandonedTimeout. If set to true a connection is considered abandoned and eligible for removal if it has been in use longer than the removeAbandonedTimeout Setting this to true can recover db connections from applications that fail to close a connection. See also `logAbandoned`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |           |                                        |              |                          |
| `abandonWhenPercentageFull`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | `int`     | `0`                                    |              | [icon: times, set=fas]No |
| Connections that have been abandoned (timed out) wont get closed and reported up unless the number of connections in use are above the percentage defined by abandonWhenPercentageFull. The value should be between 0-100. A value of `0` implies that connections are eligible for closure as soon as removeAbandonedTimeout has been reached.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |           |                                        |              |                          |
| `minIdle`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `int`     | `10`                                   |              | [icon: times, set=fas]No |
| The minimum number of established connections that should be kept in the pool at all times. The connection pool can shrink below this number if validation queries fail. The default value is derived from `initialSize`. (Also see `testWhileIdle`).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |           |                                        |              |                          |
| `defaultReadOnly`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `Boolean` | `null`                                 |              | [icon: times, set=fas]No |
| The default read-only state of connections created by this pool. If not set then the setReadOnly method will not be called. (Some drivers don't support read only mode, ex: Informix).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |           |                                        |              |                          |
| `maxWait`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `int`     | `30000`                                |              | [icon: times, set=fas]No |
| The maximum number of milliseconds that the pool will wait (when there are no available connections) for a connection to be returned before throwing an exception.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |           |                                        |              |                          |
| `logValidationErrors`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `boolean` | `false`                                |              | [icon: times, set=fas]No |
| Set this to true to log errors during the validation phase to the log file. If set to true, errors will be logged as SEVERE. Set it to `false` for backwards compatibility.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |           |                                        |              |                          |
| `driverClassName`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `String`  | `null`                                 |              | [icon: times, set=fas]No |
| The fully qualified Java class name of the JDBC driver to be used. The driver has to be accessible from the same classloader as tomcat-jdbc.jar.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |           |                                        |              |                          |
| `name`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `String`  | `Tomcat Connection Pool[5-1878583031]` |              | [icon: times, set=fas]No |
| Returns the name of the connection pool. By default, a JVM unique random name is assigned.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |           |                                        |              |                          |
| `useStatementFacade`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `boolean` | `true`                                 |              | [icon: times, set=fas]No |
| Returns true if this connection pool is configured to wrap statements in order to enable equals() and hashCode() methods to be called on the closed statements if any statement proxy is set.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |           |                                        |              |                          |
| `initSQL`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `String`  | `null`                                 |              | [icon: times, set=fas]No |
| A custom query to be run when a connection is first created.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |           |                                        |              |                          |
| `validationQueryTimeout`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `int`     | `-1`                                   |              | [icon: times, set=fas]No |
| The timeout in seconds before a connection validation queries fail. This works by calling java.test\_sample.Statement.setQueryTimeout(seconds) on the statement that executes the validationQuery. The pool itself doesn't time out the query, it is still up to the JDBC driver to enforce query timeouts. A value less than or equal to zero will disable this feature.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |           |                                        |              |                          |
| `validationQuery`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `String`  | `select 1 from dual`                   |              | [icon: times, set=fas]No |
| The SQL query that will be used to validate connections from this pool before returning them to the caller. If specified, this query does not have to return any data, it just can't throw a SQLException. Example values are `SELECT 1`(mysql), `select 1 from dual`(oracle), `SELECT 1`(MS Sql Server).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |           |                                        |              |                          |
| `rollbackOnReturn`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `boolean` | `false`                                |              | [icon: times, set=fas]No |
| If autoCommit==false then the pool can terminate the transaction by calling rollback on the connection as it is returned to the pool.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |           |                                        |              |                          |
| `alternateUsernameAllowed`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `boolean` | `false`                                |              | [icon: times, set=fas]No |
| By default, the jdbc-pool will ignore the DataSource.getConnection(username,password) call, and simply return a previously pooled connection under the globally configured properties username and password, for performance reasons. The pool can however be configured to allow use of different credentials each time a connection is requested. To enable the functionality described in the DataSource.getConnection(username,password) call, simply set the property alternateUsernameAllowed to true. Should you request a connection with the credentials user1/password1 and the connection was previously connected using different user2/password2, the connection will be closed, and reopened with the requested credentials. This way, the pool size is still managed on a global level, and not on a per schema level.                                                                        |           |                                        |              |                          |
| `validatorClassName`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `String`  | `null`                                 |              | [icon: times, set=fas]No |
| The name of a class which implements the org.apache.tomcat.jdbc.pool.Validator interface and provides a no-arg constructor (may be implicit). If specified, the class will be used to create a Validator instance which is then used instead of any validation query to validate connections. An example value is `com.mycompany.project.SimpleValidator`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |           |                                        |              |                          |
| `suspectTimeout`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `int`     | `0`                                    |              | [icon: times, set=fas]No |
| Timeout value in seconds. Similar to the removeAbandonedTimeout value but instead of treating the connection as abandoned, and potentially closing the connection, this simply logs the warning if logAbandoned is set to true. If this value is equal or less than 0, no suspect checking will be performed. Suspect checking only takes place if the timeout value is larger than 0 and the connection was not abandoned or if abandon check is disabled. If a connection is suspect a WARN message gets logged and a JMX notification gets sent once.                                                                                                                                                                                                                                                                                                                                                     |           |                                        |              |                          |
| `useEquals`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | `boolean` | `true`                                 |              | [icon: times, set=fas]No |
| Set to true if you wish the ProxyConnection class to use String.equals and set to false when you wish to use == when comparing method names. This property does not apply to added interceptors as those are configured individually.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |           |                                        |              |                          |
| `removeAbandonedTimeout`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `int`     | `60`                                   |              | [icon: times, set=fas]No |
| Timeout in seconds before an abandoned(in use) connection can be removed. The value should be set to the longest running query your applications might have.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |           |                                        |              |                          |
| `defaultAutoCommit`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `Boolean` | `null`                                 |              | [icon: times, set=fas]No |
| The default auto-commit state of connections created by this pool. If not set, default is JDBC driver default (If not set then the setAutoCommit method will not be called).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |           |                                        |              |                          |
| `testOnConnect`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `boolean` | `false`                                |              | [icon: times, set=fas]No |
| Returns true if we should run the validation query when connecting to the database for the first time on a connection. Normally this is always set to false, unless one wants to use the validationQuery as an init query.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |           |                                        |              |                          |
| `jdbcInterceptors`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `String`  | `null`                                 |              | [icon: times, set=fas]No |
| A semicolon separated list of classnames extending org.apache.tomcat.jdbc.pool.JdbcInterceptor class. See Configuring JDBC interceptors below for more detailed description of syntaz and examples. These interceptors will be inserted as an interceptor into the chain of operations on a java.test\_sample.Connection object.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |           |                                        |              |                          |
| `initialSize`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `int`     | `10`                                   |              | [icon: times, set=fas]No |
| The initial number of connections that are created when the pool is started.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |           |                                        |              |                          |
| `defaultTransactionIsolation`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `int`     | `-1`                                   |              | [icon: times, set=fas]No |
| The default TransactionIsolation state of connections created by this pool. One of the following: `NONE`, `READ_COMMITTED`, `READ_UNCOMMITTED`, `REPEATABLE_READ`, `SERIALIZABLE`. If not set, the method will not be called, and it defaults to the JDBC driver.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |           |                                        |              |                          |
| `numTestsPerEvictionRun`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `int`     | `0`                                    |              | [icon: times, set=fas]No |
| Property not used in tomcat-jdbc-pool.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |           |                                        |              |                          |
| `url`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `String`  | `null`                                 |              | [icon: times, set=fas]No |
| The URL used to connect to the database.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |           |                                        |              |                          |
| `testOnBorrow`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `boolean` | `true`                                 |              | [icon: times, set=fas]No |
| The indication of whether objects will be validated before being borrowed from the pool. If the object fails to validate, it will be dropped from the pool, and we will attempt to borrow another. NOTE - for a true value to have any effect, the validationQuery parameter must be set to a non-null string. In order to have a more efficient validation, see `validationInterval`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |           |                                        |              |                          |
| `fairQueue`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | `boolean` | `true`                                 |              | [icon: times, set=fas]No |
| Set to true if you wish that calls to getConnection should be treated fairly in a true FIFO fashion. This uses the org.apache.tomcat.jdbc.pool.FairBlockingQueue implementation for the list of the idle connections. This flag is required when you want to use asynchronous connection retrieval. Setting this flag ensures that threads receive connections in the order they arrive. During performance tests, there is a very large difference in how locks and lock waiting is implemented. When fairQueue=true there is a decision making process based on what operating system the system is running. If the system is running on Linux (property os.name=Linux. To disable this Linux specific behavior and still use the fair queue, simply add the property org.apache.tomcat.jdbc.pool.FairBlockingQueue.ignoreOS=true to your system properties before the connection pool classes are loaded. |           |                                        |              |                          |
| `accessToUnderlyingConnectionAllowed`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `boolean` | `true`                                 |              | [icon: times, set=fas]No |
| Property not used. Access can be achieved by calling unwrap on the pooled connection. see javax.test\_sample.DataSource interface, or call getConnection through reflection or cast the object as javax.test\_sample.PooledConnection.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |           |                                        |              |                          |
| `maxAge`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `long`    | `0`                                    |              | [icon: times, set=fas]No |
| Time in milliseconds to keep this connection. When a connection is returned to the pool, the pool will check to see if the now - time-when-connected > maxAge has been reached, and if so, it closes the connection rather than returning it to the pool. A value of `0` implies that connections will be left open and no age check will be done upon returning the connection to the pool.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |           |                                        |              |                          |
| `minEvictableIdleTimeMillis`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `int`     | `60000`                                |              | [icon: times, set=fas]No |
| The minimum amount of time an object may sit idle in the pool before it is eligible for eviction.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |           |                                        |              |                          |
| `timeBetweenEvictionRunsMillis`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `int`     | `5000`                                 |              | [icon: times, set=fas]No |
| The number of milliseconds to sleep between runs of the idle connection validation/cleaner thread. This value should not be set under 1 second. It dictates how often we check for idle, abandoned connections, and how often we validate idle connections.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |           |                                        |              |                          |
| `testOnReturn`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `boolean` | `false`                                |              | [icon: times, set=fas]No |
| The indication of whether objects will be validated before being returned to the pool. NOTE - for a true value to have any effect, the validationQuery parameter must be set to a non-null string.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |           |                                        |              |                          |
| `useLock`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `boolean` | `false`                                |              | [icon: times, set=fas]No |
| Return true if a lock should be used when operations are performed on the connection object. Should be set to false unless you plan to have a background thread of your own doing idle and abandon checking such as JMX clients. If the pool sweeper is enabled, then the lock will automatically be used regardless of this setting.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |           |                                        |              |                          |
| `maxActive`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | `int`     | `100`                                  |              | [icon: times, set=fas]No |
| The maximum number of active connections that can be allocated from this pool at the same time.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |           |                                        |              |                          |
| `username`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `String`  | `null`                                 |              | [icon: times, set=fas]No |
| The connection username to be passed to our JDBC driver to establish a connection. Note that method DataSource.getConnection(username,password) by default will not use credentials passed into the method, but will use the ones configured here. See alternateUsernameAllowed property for more details.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |           |                                        |              |                          |

(1) Whether the property value is considered confidential, and is therefore encrypted in IDM.

(2) A list of operations in this column indicates that the property is required for those operations.

### Basic Configuration Properties

| Property                                                                                                | Type      | Default | Encrypted(1)             | Required(2)               |
| ------------------------------------------------------------------------------------------------------- | --------- | ------- | ------------------------ | ------------------------- |
| `password`                                                                                              | `String`  | `null`  | [icon: lock, set=fas]Yes | [icon: check, set=fas]Yes |
| Oracle EBS login password to authenticate the user.                                                     |           |         |                          |                           |
| `pageSize`                                                                                              | `int`     | `50`    |                          | [icon: times, set=fas]No  |
| Page size of search.                                                                                    |           |         |                          |                           |
| `activeUsersOnly`                                                                                       | `boolean` | `false` |                          | [icon: times, set=fas]No  |
| Flag to indicate if the connector should return only the active users, when querying, or all the users. |           |         |                          |                           |

(1) Whether the property value is considered confidential, and is therefore encrypted in IDM.

(2) A list of operations in this column indicates that the property is required for those operations.
