DataSource.java

package org.wildfly.swarm.config.datasources;

import org.wildfly.apigen.invocation.Address;
import org.wildfly.apigen.invocation.Binding;
import java.util.List;
import org.wildfly.apigen.invocation.Subresource;
import org.wildfly.swarm.config.datasources.ConnectionProperties;
/**
 * A JDBC data-source configuration
 */
@Address("/subsystem=datasources/data-source=*")
public class DataSource {

	private Integer allocationRetry;
	private Long allocationRetryWaitMillis;
	private Boolean allowMultipleUsers;
	private Boolean backgroundValidation;
	private Long backgroundValidationMillis;
	private Long blockingTimeoutWaitMillis;
	private String capacityDecrementerClass;
	private String capacityIncrementerClass;
	private String checkValidConnectionSql;
	private Boolean connectable;
	private String connectionListenerClass;
	private String connectionProperties;
	private String connectionUrl;
	private String datasourceClass;
	private String driverClass;
	private String driverName;
	private Boolean enabled;
	private String exceptionSorterClassName;
	private String flushStrategy;
	private Long idleTimeoutMinutes;
	private Integer initialPoolSize;
	private String jndiName;
	private Boolean jta;
	private Integer maxPoolSize;
	private Integer minPoolSize;
	private String newConnectionSql;
	private String password;
	private Boolean poolPrefill;
	private Boolean poolUseStrictMin;
	private Long preparedStatementsCacheSize;
	private Long queryTimeout;
	private String reauthPluginClassName;
	private String securityDomain;
	private Boolean setTxQueryTimeout;
	private Boolean sharePreparedStatements;
	private Boolean spy;
	private String staleConnectionCheckerClassName;
	private Boolean statisticsEnabled;
	private String trackStatements;
	private Boolean tracking;
	private String transactionIsolation;
	private String urlDelimiter;
	private String urlSelectorStrategyClassName;
	private Boolean useCcm;
	private Boolean useFastFail;
	private Boolean useJavaContext;
	private Long useTryLock;
	private String userName;
	private String validConnectionCheckerClassName;
	private Boolean validateOnMatch;
	private List<ConnectionProperties> connectionPropertiess;

	/**
	 * The allocation retry element indicates the number of times that allocating a connection should be tried before throwing an exception
	 */
	@Binding(detypedName = "allocation-retry")
	public Integer getAllocationRetry() {
		return allocationRetry;
	}

	/**
	 * The allocation retry element indicates the number of times that allocating a connection should be tried before throwing an exception
	 */
	public void setAllocationRetry(Integer allocationRetry) {
		this.allocationRetry = allocationRetry;
	}

	/**
	 * The allocation retry wait millis element specifies the amount of time, in milliseconds, to wait between retrying to allocate a connection
	 */
	@Binding(detypedName = "allocation-retry-wait-millis")
	public Long getAllocationRetryWaitMillis() {
		return allocationRetryWaitMillis;
	}

	/**
	 * The allocation retry wait millis element specifies the amount of time, in milliseconds, to wait between retrying to allocate a connection
	 */
	public void setAllocationRetryWaitMillis(Long allocationRetryWaitMillis) {
		this.allocationRetryWaitMillis = allocationRetryWaitMillis;
	}

	/**
	 * Specifies if multiple users will access the datasource through the getConnection(user, password) method and hence if the internal pool type should account for that
	 */
	@Binding(detypedName = "allow-multiple-users")
	public Boolean getAllowMultipleUsers() {
		return allowMultipleUsers;
	}

	/**
	 * Specifies if multiple users will access the datasource through the getConnection(user, password) method and hence if the internal pool type should account for that
	 */
	public void setAllowMultipleUsers(Boolean allowMultipleUsers) {
		this.allowMultipleUsers = allowMultipleUsers;
	}

	/**
	 * An element to specify that connections should be validated on a background thread versus being validated prior to use. Changing this value can be done only on disabled datasource,  requires a server restart otherwise.
	 */
	@Binding(detypedName = "background-validation")
	public Boolean getBackgroundValidation() {
		return backgroundValidation;
	}

	/**
	 * An element to specify that connections should be validated on a background thread versus being validated prior to use. Changing this value can be done only on disabled datasource,  requires a server restart otherwise.
	 */
	public void setBackgroundValidation(Boolean backgroundValidation) {
		this.backgroundValidation = backgroundValidation;
	}

	/**
	 * The background-validation-millis element specifies the amount of time, in milliseconds, that background validation will run. Changing this value can be done only on disabled datasource,  requires a server restart otherwise
	 */
	@Binding(detypedName = "background-validation-millis")
	public Long getBackgroundValidationMillis() {
		return backgroundValidationMillis;
	}

	/**
	 * The background-validation-millis element specifies the amount of time, in milliseconds, that background validation will run. Changing this value can be done only on disabled datasource,  requires a server restart otherwise
	 */
	public void setBackgroundValidationMillis(Long backgroundValidationMillis) {
		this.backgroundValidationMillis = backgroundValidationMillis;
	}

	/**
	 * The blocking-timeout-millis element specifies the maximum time, in milliseconds, to block while waiting for a connection before throwing an exception. Note that this blocks only while waiting for locking a connection, and will never throw an exception if creating a new connection takes an inordinately long time
	 */
	@Binding(detypedName = "blocking-timeout-wait-millis")
	public Long getBlockingTimeoutWaitMillis() {
		return blockingTimeoutWaitMillis;
	}

	/**
	 * The blocking-timeout-millis element specifies the maximum time, in milliseconds, to block while waiting for a connection before throwing an exception. Note that this blocks only while waiting for locking a connection, and will never throw an exception if creating a new connection takes an inordinately long time
	 */
	public void setBlockingTimeoutWaitMillis(Long blockingTimeoutWaitMillis) {
		this.blockingTimeoutWaitMillis = blockingTimeoutWaitMillis;
	}

	/**
	 * Class defining the policy for decrementing connections in the pool
	 */
	@Binding(detypedName = "capacity-decrementer-class")
	public String getCapacityDecrementerClass() {
		return capacityDecrementerClass;
	}

	/**
	 * Class defining the policy for decrementing connections in the pool
	 */
	public void setCapacityDecrementerClass(String capacityDecrementerClass) {
		this.capacityDecrementerClass = capacityDecrementerClass;
	}

	/**
	 * Class defining the policy for incrementing connections in the pool
	 */
	@Binding(detypedName = "capacity-incrementer-class")
	public String getCapacityIncrementerClass() {
		return capacityIncrementerClass;
	}

	/**
	 * Class defining the policy for incrementing connections in the pool
	 */
	public void setCapacityIncrementerClass(String capacityIncrementerClass) {
		this.capacityIncrementerClass = capacityIncrementerClass;
	}

	/**
	 * Specify an SQL statement to check validity of a pool connection. This may be called when managed connection is obtained from the pool
	 */
	@Binding(detypedName = "check-valid-connection-sql")
	public String getCheckValidConnectionSql() {
		return checkValidConnectionSql;
	}

	/**
	 * Specify an SQL statement to check validity of a pool connection. This may be called when managed connection is obtained from the pool
	 */
	public void setCheckValidConnectionSql(String checkValidConnectionSql) {
		this.checkValidConnectionSql = checkValidConnectionSql;
	}

	/**
	 * Enable the use of CMR. This feature means that a local resource can reliably participate in an XA transaction.
	 */
	@Binding(detypedName = "connectable")
	public Boolean getConnectable() {
		return connectable;
	}

	/**
	 * Enable the use of CMR. This feature means that a local resource can reliably participate in an XA transaction.
	 */
	public void setConnectable(Boolean connectable) {
		this.connectable = connectable;
	}

	/**
	 * Speciefies class name extending org.jboss.jca.adapters.jdbc.spi.listener.ConnectionListener that provides a possible to listen for connection activation and passivation in order to perform actions before the connection is returned to the application or returned to the pool.
	 */
	@Binding(detypedName = "connection-listener-class")
	public String getConnectionListenerClass() {
		return connectionListenerClass;
	}

	/**
	 * Speciefies class name extending org.jboss.jca.adapters.jdbc.spi.listener.ConnectionListener that provides a possible to listen for connection activation and passivation in order to perform actions before the connection is returned to the application or returned to the pool.
	 */
	public void setConnectionListenerClass(String connectionListenerClass) {
		this.connectionListenerClass = connectionListenerClass;
	}

	/**
	 * The connection-properties element allows you to pass in arbitrary connection properties to the Driver.connect(url, props) method
	 */
	@Binding(detypedName = "connection-properties")
	public String getConnectionProperties() {
		return connectionProperties;
	}

	/**
	 * The connection-properties element allows you to pass in arbitrary connection properties to the Driver.connect(url, props) method
	 */
	public void setConnectionProperties(String connectionProperties) {
		this.connectionProperties = connectionProperties;
	}

	/**
	 * The JDBC driver connection URL
	 */
	@Binding(detypedName = "connection-url")
	public String getConnectionUrl() {
		return connectionUrl;
	}

	/**
	 * The JDBC driver connection URL
	 */
	public void setConnectionUrl(String connectionUrl) {
		this.connectionUrl = connectionUrl;
	}

	/**
	 * The fully qualified name of the JDBC datasource class
	 */
	@Binding(detypedName = "datasource-class")
	public String getDatasourceClass() {
		return datasourceClass;
	}

	/**
	 * The fully qualified name of the JDBC datasource class
	 */
	public void setDatasourceClass(String datasourceClass) {
		this.datasourceClass = datasourceClass;
	}

	/**
	 * The fully qualified name of the JDBC driver class
	 */
	@Binding(detypedName = "driver-class")
	public String getDriverClass() {
		return driverClass;
	}

	/**
	 * The fully qualified name of the JDBC driver class
	 */
	public void setDriverClass(String driverClass) {
		this.driverClass = driverClass;
	}

	/**
	 * Defines the JDBC driver the datasource should use. It is a symbolic name matching the the name of installed driver. In case the driver is deployed as jar, the name is the name of deployment unit
	 */
	@Binding(detypedName = "driver-name")
	public String getDriverName() {
		return driverName;
	}

	/**
	 * Defines the JDBC driver the datasource should use. It is a symbolic name matching the the name of installed driver. In case the driver is deployed as jar, the name is the name of deployment unit
	 */
	public void setDriverName(String driverName) {
		this.driverName = driverName;
	}

	/**
	 * Specifies if the datasource should be enabled. Note this attribute will not be supported runtime in next versions.
	 */
	@Binding(detypedName = "enabled")
	public Boolean getEnabled() {
		return enabled;
	}

	/**
	 * Specifies if the datasource should be enabled. Note this attribute will not be supported runtime in next versions.
	 */
	public void setEnabled(Boolean enabled) {
		this.enabled = enabled;
	}

	/**
	 * An org.jboss.jca.adapters.jdbc.ExceptionSorter that provides an isExceptionFatal(SQLException) method to validate if an exception should broadcast an error
	 */
	@Binding(detypedName = "exception-sorter-class-name")
	public String getExceptionSorterClassName() {
		return exceptionSorterClassName;
	}

	/**
	 * An org.jboss.jca.adapters.jdbc.ExceptionSorter that provides an isExceptionFatal(SQLException) method to validate if an exception should broadcast an error
	 */
	public void setExceptionSorterClassName(String exceptionSorterClassName) {
		this.exceptionSorterClassName = exceptionSorterClassName;
	}

	/**
	 * Specifies how the pool should be flush in case of an error. Valid values are: FailingConnectionOnly (default), IdleConnections and EntirePool
	 */
	@Binding(detypedName = "flush-strategy")
	public String getFlushStrategy() {
		return flushStrategy;
	}

	/**
	 * Specifies how the pool should be flush in case of an error. Valid values are: FailingConnectionOnly (default), IdleConnections and EntirePool
	 */
	public void setFlushStrategy(String flushStrategy) {
		this.flushStrategy = flushStrategy;
	}

	/**
	 * The idle-timeout-minutes elements specifies the maximum time, in minutes, a connection may be idle before being closed. The actual maximum time depends also on the IdleRemover scan time, which is half of the smallest idle-timeout-minutes value of any pool. Changing this value can be done only on disabled datasource, requires a server restart otherwise.
	 */
	@Binding(detypedName = "idle-timeout-minutes")
	public Long getIdleTimeoutMinutes() {
		return idleTimeoutMinutes;
	}

	/**
	 * The idle-timeout-minutes elements specifies the maximum time, in minutes, a connection may be idle before being closed. The actual maximum time depends also on the IdleRemover scan time, which is half of the smallest idle-timeout-minutes value of any pool. Changing this value can be done only on disabled datasource, requires a server restart otherwise.
	 */
	public void setIdleTimeoutMinutes(Long idleTimeoutMinutes) {
		this.idleTimeoutMinutes = idleTimeoutMinutes;
	}

	/**
	 * The initial-pool-size element indicates the initial number of connections a pool should hold.
	 */
	@Binding(detypedName = "initial-pool-size")
	public Integer getInitialPoolSize() {
		return initialPoolSize;
	}

	/**
	 * The initial-pool-size element indicates the initial number of connections a pool should hold.
	 */
	public void setInitialPoolSize(Integer initialPoolSize) {
		this.initialPoolSize = initialPoolSize;
	}

	/**
	 * Specifies the JNDI name for the datasource
	 */
	@Binding(detypedName = "jndi-name")
	public String getJndiName() {
		return jndiName;
	}

	/**
	 * Specifies the JNDI name for the datasource
	 */
	public void setJndiName(String jndiName) {
		this.jndiName = jndiName;
	}

	/**
	 * Enable JTA integration
	 */
	@Binding(detypedName = "jta")
	public Boolean getJta() {
		return jta;
	}

	/**
	 * Enable JTA integration
	 */
	public void setJta(Boolean jta) {
		this.jta = jta;
	}

	/**
	 * The max-pool-size element specifies the maximum number of connections for a pool. No more connections will be created in each sub-pool
	 */
	@Binding(detypedName = "max-pool-size")
	public Integer getMaxPoolSize() {
		return maxPoolSize;
	}

	/**
	 * The max-pool-size element specifies the maximum number of connections for a pool. No more connections will be created in each sub-pool
	 */
	public void setMaxPoolSize(Integer maxPoolSize) {
		this.maxPoolSize = maxPoolSize;
	}

	/**
	 * The min-pool-size element specifies the minimum number of connections for a pool
	 */
	@Binding(detypedName = "min-pool-size")
	public Integer getMinPoolSize() {
		return minPoolSize;
	}

	/**
	 * The min-pool-size element specifies the minimum number of connections for a pool
	 */
	public void setMinPoolSize(Integer minPoolSize) {
		this.minPoolSize = minPoolSize;
	}

	/**
	 * Specifies an SQL statement to execute whenever a connection is added to the connection pool
	 */
	@Binding(detypedName = "new-connection-sql")
	public String getNewConnectionSql() {
		return newConnectionSql;
	}

	/**
	 * Specifies an SQL statement to execute whenever a connection is added to the connection pool
	 */
	public void setNewConnectionSql(String newConnectionSql) {
		this.newConnectionSql = newConnectionSql;
	}

	/**
	 * Specifies the password used when creating a new connection
	 */
	@Binding(detypedName = "password")
	public String getPassword() {
		return password;
	}

	/**
	 * Specifies the password used when creating a new connection
	 */
	public void setPassword(String password) {
		this.password = password;
	}

	/**
	 * Should the pool be prefilled. Changing this value can be done only on disabled datasource, requires a server restart otherwise.
	 */
	@Binding(detypedName = "pool-prefill")
	public Boolean getPoolPrefill() {
		return poolPrefill;
	}

	/**
	 * Should the pool be prefilled. Changing this value can be done only on disabled datasource, requires a server restart otherwise.
	 */
	public void setPoolPrefill(Boolean poolPrefill) {
		this.poolPrefill = poolPrefill;
	}

	/**
	 * Specifies if the min-pool-size should be considered strictly
	 */
	@Binding(detypedName = "pool-use-strict-min")
	public Boolean getPoolUseStrictMin() {
		return poolUseStrictMin;
	}

	/**
	 * Specifies if the min-pool-size should be considered strictly
	 */
	public void setPoolUseStrictMin(Boolean poolUseStrictMin) {
		this.poolUseStrictMin = poolUseStrictMin;
	}

	/**
	 * The number of prepared statements per connection in an LRU cache
	 */
	@Binding(detypedName = "prepared-statements-cache-size")
	public Long getPreparedStatementsCacheSize() {
		return preparedStatementsCacheSize;
	}

	/**
	 * The number of prepared statements per connection in an LRU cache
	 */
	public void setPreparedStatementsCacheSize(Long preparedStatementsCacheSize) {
		this.preparedStatementsCacheSize = preparedStatementsCacheSize;
	}

	/**
	 * Any configured query timeout in seconds. If not provided no timeout will be set
	 */
	@Binding(detypedName = "query-timeout")
	public Long getQueryTimeout() {
		return queryTimeout;
	}

	/**
	 * Any configured query timeout in seconds. If not provided no timeout will be set
	 */
	public void setQueryTimeout(Long queryTimeout) {
		this.queryTimeout = queryTimeout;
	}

	/**
	 * The fully qualified class name of the reauthentication plugin implementation
	 */
	@Binding(detypedName = "reauth-plugin-class-name")
	public String getReauthPluginClassName() {
		return reauthPluginClassName;
	}

	/**
	 * The fully qualified class name of the reauthentication plugin implementation
	 */
	public void setReauthPluginClassName(String reauthPluginClassName) {
		this.reauthPluginClassName = reauthPluginClassName;
	}

	/**
	 * Specifies the security domain which defines the javax.security.auth.Subject that are used to distinguish connections in the pool
	 */
	@Binding(detypedName = "security-domain")
	public String getSecurityDomain() {
		return securityDomain;
	}

	/**
	 * Specifies the security domain which defines the javax.security.auth.Subject that are used to distinguish connections in the pool
	 */
	public void setSecurityDomain(String securityDomain) {
		this.securityDomain = securityDomain;
	}

	/**
	 * Whether to set the query timeout based on the time remaining until transaction timeout. Any configured query timeout will be used if there is no transaction
	 */
	@Binding(detypedName = "set-tx-query-timeout")
	public Boolean getSetTxQueryTimeout() {
		return setTxQueryTimeout;
	}

	/**
	 * Whether to set the query timeout based on the time remaining until transaction timeout. Any configured query timeout will be used if there is no transaction
	 */
	public void setSetTxQueryTimeout(Boolean setTxQueryTimeout) {
		this.setTxQueryTimeout = setTxQueryTimeout;
	}

	/**
	 * Whether to share prepared statements, i.e. whether asking for same statement twice without closing uses the same underlying prepared statement
	 */
	@Binding(detypedName = "share-prepared-statements")
	public Boolean getSharePreparedStatements() {
		return sharePreparedStatements;
	}

	/**
	 * Whether to share prepared statements, i.e. whether asking for same statement twice without closing uses the same underlying prepared statement
	 */
	public void setSharePreparedStatements(Boolean sharePreparedStatements) {
		this.sharePreparedStatements = sharePreparedStatements;
	}

	/**
	 * Enable spying of SQL statements
	 */
	@Binding(detypedName = "spy")
	public Boolean getSpy() {
		return spy;
	}

	/**
	 * Enable spying of SQL statements
	 */
	public void setSpy(Boolean spy) {
		this.spy = spy;
	}

	/**
	 * An org.jboss.jca.adapters.jdbc.StaleConnectionChecker that provides an isStaleConnection(SQLException) method which if it returns true will wrap the exception in an org.jboss.jca.adapters.jdbc.StaleConnectionException
	 */
	@Binding(detypedName = "stale-connection-checker-class-name")
	public String getStaleConnectionCheckerClassName() {
		return staleConnectionCheckerClassName;
	}

	/**
	 * An org.jboss.jca.adapters.jdbc.StaleConnectionChecker that provides an isStaleConnection(SQLException) method which if it returns true will wrap the exception in an org.jboss.jca.adapters.jdbc.StaleConnectionException
	 */
	public void setStaleConnectionCheckerClassName(
			String staleConnectionCheckerClassName) {
		this.staleConnectionCheckerClassName = staleConnectionCheckerClassName;
	}

	/**
	 * define if runtime statistics is enabled or not.
	 */
	@Binding(detypedName = "statistics-enabled")
	public Boolean getStatisticsEnabled() {
		return statisticsEnabled;
	}

	/**
	 * define if runtime statistics is enabled or not.
	 */
	public void setStatisticsEnabled(Boolean statisticsEnabled) {
		this.statisticsEnabled = statisticsEnabled;
	}

	/**
	 * Whether to check for unclosed statements when a connection is returned to the pool, result sets are closed, a statement is closed or return to the prepared statement cache. Valid values are: "false" - do not track statements, "true" - track statements and result sets and warn when they are not closed, "nowarn" - track statements but do not warn about them being unclosed
	 */
	@Binding(detypedName = "track-statements")
	public String getTrackStatements() {
		return trackStatements;
	}

	/**
	 * Whether to check for unclosed statements when a connection is returned to the pool, result sets are closed, a statement is closed or return to the prepared statement cache. Valid values are: "false" - do not track statements, "true" - track statements and result sets and warn when they are not closed, "nowarn" - track statements but do not warn about them being unclosed
	 */
	public void setTrackStatements(String trackStatements) {
		this.trackStatements = trackStatements;
	}

	/**
	 * Defines if IronJacamar should track connection handles across transaction boundaries
	 */
	@Binding(detypedName = "tracking")
	public Boolean getTracking() {
		return tracking;
	}

	/**
	 * Defines if IronJacamar should track connection handles across transaction boundaries
	 */
	public void setTracking(Boolean tracking) {
		this.tracking = tracking;
	}

	/**
	 * Set the java.sql.Connection transaction isolation level. Valid values are: TRANSACTION_READ_UNCOMMITTED, TRANSACTION_READ_COMMITTED, TRANSACTION_REPEATABLE_READ, TRANSACTION_SERIALIZABLE and TRANSACTION_NONE
	 */
	@Binding(detypedName = "transaction-isolation")
	public String getTransactionIsolation() {
		return transactionIsolation;
	}

	/**
	 * Set the java.sql.Connection transaction isolation level. Valid values are: TRANSACTION_READ_UNCOMMITTED, TRANSACTION_READ_COMMITTED, TRANSACTION_REPEATABLE_READ, TRANSACTION_SERIALIZABLE and TRANSACTION_NONE
	 */
	public void setTransactionIsolation(String transactionIsolation) {
		this.transactionIsolation = transactionIsolation;
	}

	/**
	 * Specifies the delimiter for URLs in connection-url for HA datasources
	 */
	@Binding(detypedName = "url-delimiter")
	public String getUrlDelimiter() {
		return urlDelimiter;
	}

	/**
	 * Specifies the delimiter for URLs in connection-url for HA datasources
	 */
	public void setUrlDelimiter(String urlDelimiter) {
		this.urlDelimiter = urlDelimiter;
	}

	/**
	 * A class that implements org.jboss.jca.adapters.jdbc.URLSelectorStrategy
	 */
	@Binding(detypedName = "url-selector-strategy-class-name")
	public String getUrlSelectorStrategyClassName() {
		return urlSelectorStrategyClassName;
	}

	/**
	 * A class that implements org.jboss.jca.adapters.jdbc.URLSelectorStrategy
	 */
	public void setUrlSelectorStrategyClassName(
			String urlSelectorStrategyClassName) {
		this.urlSelectorStrategyClassName = urlSelectorStrategyClassName;
	}

	/**
	 * Enable the use of a cached connection manager
	 */
	@Binding(detypedName = "use-ccm")
	public Boolean getUseCcm() {
		return useCcm;
	}

	/**
	 * Enable the use of a cached connection manager
	 */
	public void setUseCcm(Boolean useCcm) {
		this.useCcm = useCcm;
	}

	/**
	 * Whether to fail a connection allocation on the first try if it is invalid (true) or keep trying until the pool is exhausted of all potential connections (false)
	 */
	@Binding(detypedName = "use-fast-fail")
	public Boolean getUseFastFail() {
		return useFastFail;
	}

	/**
	 * Whether to fail a connection allocation on the first try if it is invalid (true) or keep trying until the pool is exhausted of all potential connections (false)
	 */
	public void setUseFastFail(Boolean useFastFail) {
		this.useFastFail = useFastFail;
	}

	/**
	 * Setting this to false will bind the datasource into global JNDI
	 */
	@Binding(detypedName = "use-java-context")
	public Boolean getUseJavaContext() {
		return useJavaContext;
	}

	/**
	 * Setting this to false will bind the datasource into global JNDI
	 */
	public void setUseJavaContext(Boolean useJavaContext) {
		this.useJavaContext = useJavaContext;
	}

	/**
	 * Any configured timeout for internal locks on the resource adapter objects in seconds
	 */
	@Binding(detypedName = "use-try-lock")
	public Long getUseTryLock() {
		return useTryLock;
	}

	/**
	 * Any configured timeout for internal locks on the resource adapter objects in seconds
	 */
	public void setUseTryLock(Long useTryLock) {
		this.useTryLock = useTryLock;
	}

	/**
	 * Specify the user name used when creating a new connection
	 */
	@Binding(detypedName = "user-name")
	public String getUserName() {
		return userName;
	}

	/**
	 * Specify the user name used when creating a new connection
	 */
	public void setUserName(String userName) {
		this.userName = userName;
	}

	/**
	 * An org.jboss.jca.adapters.jdbc.ValidConnectionChecker that provides an isValidConnection(Connection) method to validate a connection. If an exception is returned that means the connection is invalid. This overrides the check-valid-connection-sql element
	 */
	@Binding(detypedName = "valid-connection-checker-class-name")
	public String getValidConnectionCheckerClassName() {
		return validConnectionCheckerClassName;
	}

	/**
	 * An org.jboss.jca.adapters.jdbc.ValidConnectionChecker that provides an isValidConnection(Connection) method to validate a connection. If an exception is returned that means the connection is invalid. This overrides the check-valid-connection-sql element
	 */
	public void setValidConnectionCheckerClassName(
			String validConnectionCheckerClassName) {
		this.validConnectionCheckerClassName = validConnectionCheckerClassName;
	}

	/**
	 * The validate-on-match element specifies if connection validation should be done when a connection factory attempts to match a managed connection. This is typically exclusive to the use of background validation
	 */
	@Binding(detypedName = "validate-on-match")
	public Boolean getValidateOnMatch() {
		return validateOnMatch;
	}

	/**
	 * The validate-on-match element specifies if connection validation should be done when a connection factory attempts to match a managed connection. This is typically exclusive to the use of background validation
	 */
	public void setValidateOnMatch(Boolean validateOnMatch) {
		this.validateOnMatch = validateOnMatch;
	}

	@Subresource
	public List<ConnectionProperties> getConnectionPropertiess() {
		return connectionPropertiess;
	}

	public void setConnectionPropertiess(
			List<ConnectionProperties> connectionPropertiess) {
		this.connectionPropertiess = connectionPropertiess;
	}

	public DataSource() {
		this.connectionPropertiess = new java.util.ArrayList<>();
	}
}