[[appendix.application-properties.data]]
== Data Properties
[cols="4,3,3", options="header"]
|===
|Name|Description|Default Value

|[[application-properties.data.spring.cassandra.compression]]xref:#application-properties.data.spring.cassandra.compression[`+spring.cassandra.compression+`]
|+++Compression supported by the Cassandra binary protocol.+++
|`+none+`

|[[application-properties.data.spring.cassandra.config]]xref:#application-properties.data.spring.cassandra.config[`+spring.cassandra.config+`]
|+++Location of the configuration file to use.+++
|

|[[application-properties.data.spring.cassandra.connection.connect-timeout]]xref:#application-properties.data.spring.cassandra.connection.connect-timeout[`+spring.cassandra.connection.connect-timeout+`]
|+++Timeout to use when establishing driver connections.+++
|`+5s+`

|[[application-properties.data.spring.cassandra.connection.init-query-timeout]]xref:#application-properties.data.spring.cassandra.connection.init-query-timeout[`+spring.cassandra.connection.init-query-timeout+`]
|+++Timeout to use for internal queries that run as part of the initialization process, just after a connection is opened.+++
|`+5s+`

|[[application-properties.data.spring.cassandra.contact-points]]xref:#application-properties.data.spring.cassandra.contact-points[`+spring.cassandra.contact-points+`]
|+++Cluster node addresses in the form 'host:port', or a simple 'host' to use the configured port.+++
|`+[127.0.0.1:9042]+`

|[[application-properties.data.spring.cassandra.controlconnection.timeout]]xref:#application-properties.data.spring.cassandra.controlconnection.timeout[`+spring.cassandra.controlconnection.timeout+`]
|+++Timeout to use for control queries.+++
|`+5s+`

|[[application-properties.data.spring.cassandra.keyspace-name]]xref:#application-properties.data.spring.cassandra.keyspace-name[`+spring.cassandra.keyspace-name+`]
|+++Keyspace name to use.+++
|

|[[application-properties.data.spring.cassandra.local-datacenter]]xref:#application-properties.data.spring.cassandra.local-datacenter[`+spring.cassandra.local-datacenter+`]
|+++Datacenter that is considered "local". Contact points should be from this datacenter.+++
|

|[[application-properties.data.spring.cassandra.password]]xref:#application-properties.data.spring.cassandra.password[`+spring.cassandra.password+`]
|+++Login password of the server.+++
|

|[[application-properties.data.spring.cassandra.pool.heartbeat-interval]]xref:#application-properties.data.spring.cassandra.pool.heartbeat-interval[`+spring.cassandra.pool.heartbeat-interval+`]
|+++Heartbeat interval after which a message is sent on an idle connection to make sure it's still alive.+++
|`+30s+`

|[[application-properties.data.spring.cassandra.pool.idle-timeout]]xref:#application-properties.data.spring.cassandra.pool.idle-timeout[`+spring.cassandra.pool.idle-timeout+`]
|+++Idle timeout before an idle connection is removed.+++
|`+5s+`

|[[application-properties.data.spring.cassandra.port]]xref:#application-properties.data.spring.cassandra.port[`+spring.cassandra.port+`]
|+++Port to use if a contact point does not specify one.+++
|`+9042+`

|[[application-properties.data.spring.cassandra.request.consistency]]xref:#application-properties.data.spring.cassandra.request.consistency[`+spring.cassandra.request.consistency+`]
|+++Queries consistency level.+++
|

|[[application-properties.data.spring.cassandra.request.page-size]]xref:#application-properties.data.spring.cassandra.request.page-size[`+spring.cassandra.request.page-size+`]
|+++How many rows will be retrieved simultaneously in a single network round-trip.+++
|`+5000+`

|[[application-properties.data.spring.cassandra.request.serial-consistency]]xref:#application-properties.data.spring.cassandra.request.serial-consistency[`+spring.cassandra.request.serial-consistency+`]
|+++Queries serial consistency level.+++
|

|[[application-properties.data.spring.cassandra.request.throttler.drain-interval]]xref:#application-properties.data.spring.cassandra.request.throttler.drain-interval[`+spring.cassandra.request.throttler.drain-interval+`]
|+++How often the throttler attempts to dequeue requests. Set this high enough that each attempt will process multiple entries in the queue, but not delay requests too much.+++
|

|[[application-properties.data.spring.cassandra.request.throttler.max-concurrent-requests]]xref:#application-properties.data.spring.cassandra.request.throttler.max-concurrent-requests[`+spring.cassandra.request.throttler.max-concurrent-requests+`]
|+++Maximum number of requests that are allowed to execute in parallel.+++
|

|[[application-properties.data.spring.cassandra.request.throttler.max-queue-size]]xref:#application-properties.data.spring.cassandra.request.throttler.max-queue-size[`+spring.cassandra.request.throttler.max-queue-size+`]
|+++Maximum number of requests that can be enqueued when the throttling threshold is exceeded.+++
|

|[[application-properties.data.spring.cassandra.request.throttler.max-requests-per-second]]xref:#application-properties.data.spring.cassandra.request.throttler.max-requests-per-second[`+spring.cassandra.request.throttler.max-requests-per-second+`]
|+++Maximum allowed request rate.+++
|

|[[application-properties.data.spring.cassandra.request.throttler.type]]xref:#application-properties.data.spring.cassandra.request.throttler.type[`+spring.cassandra.request.throttler.type+`]
|+++Request throttling type.+++
|`+none+`

|[[application-properties.data.spring.cassandra.request.timeout]]xref:#application-properties.data.spring.cassandra.request.timeout[`+spring.cassandra.request.timeout+`]
|+++How long the driver waits for a request to complete.+++
|`+2s+`

|[[application-properties.data.spring.cassandra.schema-action]]xref:#application-properties.data.spring.cassandra.schema-action[`+spring.cassandra.schema-action+`]
|+++Schema action to take at startup.+++
|`+none+`

|[[application-properties.data.spring.cassandra.session-name]]xref:#application-properties.data.spring.cassandra.session-name[`+spring.cassandra.session-name+`]
|+++Name of the Cassandra session.+++
|

|[[application-properties.data.spring.cassandra.ssl.bundle]]xref:#application-properties.data.spring.cassandra.ssl.bundle[`+spring.cassandra.ssl.bundle+`]
|+++SSL bundle name.+++
|

|[[application-properties.data.spring.cassandra.ssl.enabled]]xref:#application-properties.data.spring.cassandra.ssl.enabled[`+spring.cassandra.ssl.enabled+`]
|+++Whether to enable SSL support.+++
|

|[[application-properties.data.spring.cassandra.username]]xref:#application-properties.data.spring.cassandra.username[`+spring.cassandra.username+`]
|+++Login user of the server.+++
|

|[[application-properties.data.spring.couchbase.connection-string]]xref:#application-properties.data.spring.couchbase.connection-string[`+spring.couchbase.connection-string+`]
|+++Connection string used to locate the Couchbase cluster.+++
|

|[[application-properties.data.spring.couchbase.env.io.idle-http-connection-timeout]]xref:#application-properties.data.spring.couchbase.env.io.idle-http-connection-timeout[`+spring.couchbase.env.io.idle-http-connection-timeout+`]
|+++Length of time an HTTP connection may remain idle before it is closed and removed from the pool.+++
|`+1s+`

|[[application-properties.data.spring.couchbase.env.io.max-endpoints]]xref:#application-properties.data.spring.couchbase.env.io.max-endpoints[`+spring.couchbase.env.io.max-endpoints+`]
|+++Maximum number of sockets per node.+++
|`+12+`

|[[application-properties.data.spring.couchbase.env.io.min-endpoints]]xref:#application-properties.data.spring.couchbase.env.io.min-endpoints[`+spring.couchbase.env.io.min-endpoints+`]
|+++Minimum number of sockets per node.+++
|`+1+`

|[[application-properties.data.spring.couchbase.env.ssl.bundle]]xref:#application-properties.data.spring.couchbase.env.ssl.bundle[`+spring.couchbase.env.ssl.bundle+`]
|+++SSL bundle name.+++
|

|[[application-properties.data.spring.couchbase.env.ssl.enabled]]xref:#application-properties.data.spring.couchbase.env.ssl.enabled[`+spring.couchbase.env.ssl.enabled+`]
|+++Whether to enable SSL support. Enabled automatically if a "bundle" is provided unless specified otherwise.+++
|

|[[application-properties.data.spring.couchbase.env.timeouts.analytics]]xref:#application-properties.data.spring.couchbase.env.timeouts.analytics[`+spring.couchbase.env.timeouts.analytics+`]
|+++Timeout for the analytics service.+++
|`+75s+`

|[[application-properties.data.spring.couchbase.env.timeouts.connect]]xref:#application-properties.data.spring.couchbase.env.timeouts.connect[`+spring.couchbase.env.timeouts.connect+`]
|+++Bucket connect timeout.+++
|`+10s+`

|[[application-properties.data.spring.couchbase.env.timeouts.disconnect]]xref:#application-properties.data.spring.couchbase.env.timeouts.disconnect[`+spring.couchbase.env.timeouts.disconnect+`]
|+++Bucket disconnect timeout.+++
|`+10s+`

|[[application-properties.data.spring.couchbase.env.timeouts.key-value]]xref:#application-properties.data.spring.couchbase.env.timeouts.key-value[`+spring.couchbase.env.timeouts.key-value+`]
|+++Timeout for operations on a specific key-value.+++
|`+2500ms+`

|[[application-properties.data.spring.couchbase.env.timeouts.key-value-durable]]xref:#application-properties.data.spring.couchbase.env.timeouts.key-value-durable[`+spring.couchbase.env.timeouts.key-value-durable+`]
|+++Timeout for operations on a specific key-value with a durability level.+++
|`+10s+`

|[[application-properties.data.spring.couchbase.env.timeouts.management]]xref:#application-properties.data.spring.couchbase.env.timeouts.management[`+spring.couchbase.env.timeouts.management+`]
|+++Timeout for the management operations.+++
|`+75s+`

|[[application-properties.data.spring.couchbase.env.timeouts.query]]xref:#application-properties.data.spring.couchbase.env.timeouts.query[`+spring.couchbase.env.timeouts.query+`]
|+++N1QL query operations timeout.+++
|`+75s+`

|[[application-properties.data.spring.couchbase.env.timeouts.search]]xref:#application-properties.data.spring.couchbase.env.timeouts.search[`+spring.couchbase.env.timeouts.search+`]
|+++Timeout for the search service.+++
|`+75s+`

|[[application-properties.data.spring.couchbase.env.timeouts.view]]xref:#application-properties.data.spring.couchbase.env.timeouts.view[`+spring.couchbase.env.timeouts.view+`]
|+++Regular and geospatial view operations timeout.+++
|`+75s+`

|[[application-properties.data.spring.couchbase.password]]xref:#application-properties.data.spring.couchbase.password[`+spring.couchbase.password+`]
|+++Cluster password.+++
|

|[[application-properties.data.spring.couchbase.username]]xref:#application-properties.data.spring.couchbase.username[`+spring.couchbase.username+`]
|+++Cluster username.+++
|

|[[application-properties.data.spring.dao.exceptiontranslation.enabled]]xref:#application-properties.data.spring.dao.exceptiontranslation.enabled[`+spring.dao.exceptiontranslation.enabled+`]
|+++Whether to enable the PersistenceExceptionTranslationPostProcessor.+++
|`+true+`

|[[application-properties.data.spring.data.cassandra.repositories.type]]xref:#application-properties.data.spring.data.cassandra.repositories.type[`+spring.data.cassandra.repositories.type+`]
|+++Type of Cassandra repositories to enable.+++
|`+auto+`

|[[application-properties.data.spring.data.couchbase.auto-index]]xref:#application-properties.data.spring.data.couchbase.auto-index[`+spring.data.couchbase.auto-index+`]
|+++Automatically create views and indexes. Use the meta-data provided by "@ViewIndexed", "@N1qlPrimaryIndexed" and "@N1qlSecondaryIndexed".+++
|`+false+`

|[[application-properties.data.spring.data.couchbase.bucket-name]]xref:#application-properties.data.spring.data.couchbase.bucket-name[`+spring.data.couchbase.bucket-name+`]
|+++Name of the bucket to connect to.+++
|

|[[application-properties.data.spring.data.couchbase.field-naming-strategy]]xref:#application-properties.data.spring.data.couchbase.field-naming-strategy[`+spring.data.couchbase.field-naming-strategy+`]
|+++Fully qualified name of the FieldNamingStrategy to use.+++
|

|[[application-properties.data.spring.data.couchbase.repositories.type]]xref:#application-properties.data.spring.data.couchbase.repositories.type[`+spring.data.couchbase.repositories.type+`]
|+++Type of Couchbase repositories to enable.+++
|`+auto+`

|[[application-properties.data.spring.data.couchbase.scope-name]]xref:#application-properties.data.spring.data.couchbase.scope-name[`+spring.data.couchbase.scope-name+`]
|+++Name of the scope used for all collection access.+++
|

|[[application-properties.data.spring.data.couchbase.type-key]]xref:#application-properties.data.spring.data.couchbase.type-key[`+spring.data.couchbase.type-key+`]
|+++Name of the field that stores the type information for complex types when using "MappingCouchbaseConverter".+++
|`+_class+`

|[[application-properties.data.spring.data.elasticsearch.repositories.enabled]]xref:#application-properties.data.spring.data.elasticsearch.repositories.enabled[`+spring.data.elasticsearch.repositories.enabled+`]
|+++Whether to enable Elasticsearch repositories.+++
|`+true+`

|[[application-properties.data.spring.data.jdbc.dialect]]xref:#application-properties.data.spring.data.jdbc.dialect[`+spring.data.jdbc.dialect+`]
|+++Dialect to use. By default, the dialect is determined by inspecting the database connection.+++
|

|[[application-properties.data.spring.data.jdbc.repositories.enabled]]xref:#application-properties.data.spring.data.jdbc.repositories.enabled[`+spring.data.jdbc.repositories.enabled+`]
|+++Whether to enable JDBC repositories.+++
|`+true+`

|[[application-properties.data.spring.data.jpa.repositories.bootstrap-mode]]xref:#application-properties.data.spring.data.jpa.repositories.bootstrap-mode[`+spring.data.jpa.repositories.bootstrap-mode+`]
|+++Bootstrap mode for JPA repositories.+++
|`+default+`

|[[application-properties.data.spring.data.jpa.repositories.enabled]]xref:#application-properties.data.spring.data.jpa.repositories.enabled[`+spring.data.jpa.repositories.enabled+`]
|+++Whether to enable JPA repositories.+++
|`+true+`

|[[application-properties.data.spring.data.ldap.repositories.enabled]]xref:#application-properties.data.spring.data.ldap.repositories.enabled[`+spring.data.ldap.repositories.enabled+`]
|+++Whether to enable LDAP repositories.+++
|`+true+`

|[[application-properties.data.spring.data.mongodb.additional-hosts]]xref:#application-properties.data.spring.data.mongodb.additional-hosts[`+spring.data.mongodb.additional-hosts+`]
|+++Additional server hosts. Cannot be set with URI or if 'host' is not specified. Additional hosts will use the default mongo port of 27017. If you want to use a different port you can use the "host:port" syntax.+++
|

|[[application-properties.data.spring.data.mongodb.authentication-database]]xref:#application-properties.data.spring.data.mongodb.authentication-database[`+spring.data.mongodb.authentication-database+`]
|+++Authentication database name.+++
|

|[[application-properties.data.spring.data.mongodb.auto-index-creation]]xref:#application-properties.data.spring.data.mongodb.auto-index-creation[`+spring.data.mongodb.auto-index-creation+`]
|+++Whether to enable auto-index creation.+++
|

|[[application-properties.data.spring.data.mongodb.database]]xref:#application-properties.data.spring.data.mongodb.database[`+spring.data.mongodb.database+`]
|+++Database name. Overrides database in URI.+++
|

|[[application-properties.data.spring.data.mongodb.field-naming-strategy]]xref:#application-properties.data.spring.data.mongodb.field-naming-strategy[`+spring.data.mongodb.field-naming-strategy+`]
|+++Fully qualified name of the FieldNamingStrategy to use.+++
|

|[[application-properties.data.spring.data.mongodb.gridfs.bucket]]xref:#application-properties.data.spring.data.mongodb.gridfs.bucket[`+spring.data.mongodb.gridfs.bucket+`]
|+++GridFS bucket name.+++
|

|[[application-properties.data.spring.data.mongodb.gridfs.database]]xref:#application-properties.data.spring.data.mongodb.gridfs.database[`+spring.data.mongodb.gridfs.database+`]
|+++GridFS database name.+++
|

|[[application-properties.data.spring.data.mongodb.host]]xref:#application-properties.data.spring.data.mongodb.host[`+spring.data.mongodb.host+`]
|+++Mongo server host. Cannot be set with URI.+++
|

|[[application-properties.data.spring.data.mongodb.password]]xref:#application-properties.data.spring.data.mongodb.password[`+spring.data.mongodb.password+`]
|+++Login password of the mongo server. Cannot be set with URI.+++
|

|[[application-properties.data.spring.data.mongodb.port]]xref:#application-properties.data.spring.data.mongodb.port[`+spring.data.mongodb.port+`]
|+++Mongo server port. Cannot be set with URI.+++
|

|[[application-properties.data.spring.data.mongodb.replica-set-name]]xref:#application-properties.data.spring.data.mongodb.replica-set-name[`+spring.data.mongodb.replica-set-name+`]
|+++Required replica set name for the cluster. Cannot be set with URI.+++
|

|[[application-properties.data.spring.data.mongodb.repositories.type]]xref:#application-properties.data.spring.data.mongodb.repositories.type[`+spring.data.mongodb.repositories.type+`]
|+++Type of Mongo repositories to enable.+++
|`+auto+`

|[[application-properties.data.spring.data.mongodb.ssl.bundle]]xref:#application-properties.data.spring.data.mongodb.ssl.bundle[`+spring.data.mongodb.ssl.bundle+`]
|+++SSL bundle name.+++
|

|[[application-properties.data.spring.data.mongodb.ssl.enabled]]xref:#application-properties.data.spring.data.mongodb.ssl.enabled[`+spring.data.mongodb.ssl.enabled+`]
|+++Whether to enable SSL support. Enabled automatically if "bundle" is provided unless specified otherwise.+++
|

|[[application-properties.data.spring.data.mongodb.uri]]xref:#application-properties.data.spring.data.mongodb.uri[`+spring.data.mongodb.uri+`]
|+++Mongo database URI. Overrides host, port, username, and password.+++
|`+mongodb://localhost/test+`

|[[application-properties.data.spring.data.mongodb.username]]xref:#application-properties.data.spring.data.mongodb.username[`+spring.data.mongodb.username+`]
|+++Login user of the mongo server. Cannot be set with URI.+++
|

|[[application-properties.data.spring.data.mongodb.uuid-representation]]xref:#application-properties.data.spring.data.mongodb.uuid-representation[`+spring.data.mongodb.uuid-representation+`]
|+++Representation to use when converting a UUID to a BSON binary value.+++
|`+java-legacy+`

|[[application-properties.data.spring.data.neo4j.database]]xref:#application-properties.data.spring.data.neo4j.database[`+spring.data.neo4j.database+`]
|+++Database name to use. By default, the server decides the default database to use.+++
|

|[[application-properties.data.spring.data.neo4j.repositories.type]]xref:#application-properties.data.spring.data.neo4j.repositories.type[`+spring.data.neo4j.repositories.type+`]
|+++Type of Neo4j repositories to enable.+++
|`+auto+`

|[[application-properties.data.spring.data.r2dbc.repositories.enabled]]xref:#application-properties.data.spring.data.r2dbc.repositories.enabled[`+spring.data.r2dbc.repositories.enabled+`]
|+++Whether to enable R2DBC repositories.+++
|`+true+`

|[[application-properties.data.spring.data.redis.client-name]]xref:#application-properties.data.spring.data.redis.client-name[`+spring.data.redis.client-name+`]
|+++Client name to be set on connections with CLIENT SETNAME.+++
|

|[[application-properties.data.spring.data.redis.client-type]]xref:#application-properties.data.spring.data.redis.client-type[`+spring.data.redis.client-type+`]
|+++Type of client to use. By default, auto-detected according to the classpath.+++
|

|[[application-properties.data.spring.data.redis.cluster.max-redirects]]xref:#application-properties.data.spring.data.redis.cluster.max-redirects[`+spring.data.redis.cluster.max-redirects+`]
|+++Maximum number of redirects to follow when executing commands across the cluster.+++
|

|[[application-properties.data.spring.data.redis.cluster.nodes]]xref:#application-properties.data.spring.data.redis.cluster.nodes[`+spring.data.redis.cluster.nodes+`]
|+++Comma-separated list of "host:port" pairs to bootstrap from. This represents an "initial" list of cluster nodes and is required to have at least one entry.+++
|

|[[application-properties.data.spring.data.redis.connect-timeout]]xref:#application-properties.data.spring.data.redis.connect-timeout[`+spring.data.redis.connect-timeout+`]
|+++Connection timeout.+++
|

|[[application-properties.data.spring.data.redis.database]]xref:#application-properties.data.spring.data.redis.database[`+spring.data.redis.database+`]
|+++Database index used by the connection factory.+++
|`+0+`

|[[application-properties.data.spring.data.redis.host]]xref:#application-properties.data.spring.data.redis.host[`+spring.data.redis.host+`]
|+++Redis server host.+++
|`+localhost+`

|[[application-properties.data.spring.data.redis.jedis.pool.enabled]]xref:#application-properties.data.spring.data.redis.jedis.pool.enabled[`+spring.data.redis.jedis.pool.enabled+`]
|+++Whether to enable the pool. Enabled automatically if "commons-pool2" is available. With Jedis, pooling is implicitly enabled in sentinel mode and this setting only applies to single node setup.+++
|

|[[application-properties.data.spring.data.redis.jedis.pool.max-active]]xref:#application-properties.data.spring.data.redis.jedis.pool.max-active[`+spring.data.redis.jedis.pool.max-active+`]
|+++Maximum number of connections that can be allocated by the pool at a given time. Use a negative value for no limit.+++
|`+8+`

|[[application-properties.data.spring.data.redis.jedis.pool.max-idle]]xref:#application-properties.data.spring.data.redis.jedis.pool.max-idle[`+spring.data.redis.jedis.pool.max-idle+`]
|+++Maximum number of "idle" connections in the pool. Use a negative value to indicate an unlimited number of idle connections.+++
|`+8+`

|[[application-properties.data.spring.data.redis.jedis.pool.max-wait]]xref:#application-properties.data.spring.data.redis.jedis.pool.max-wait[`+spring.data.redis.jedis.pool.max-wait+`]
|+++Maximum amount of time a connection allocation should block before throwing an exception when the pool is exhausted. Use a negative value to block indefinitely.+++
|`+-1ms+`

|[[application-properties.data.spring.data.redis.jedis.pool.min-idle]]xref:#application-properties.data.spring.data.redis.jedis.pool.min-idle[`+spring.data.redis.jedis.pool.min-idle+`]
|+++Target for the minimum number of idle connections to maintain in the pool. This setting only has an effect if both it and time between eviction runs are positive.+++
|`+0+`

|[[application-properties.data.spring.data.redis.jedis.pool.time-between-eviction-runs]]xref:#application-properties.data.spring.data.redis.jedis.pool.time-between-eviction-runs[`+spring.data.redis.jedis.pool.time-between-eviction-runs+`]
|+++Time between runs of the idle object evictor thread. When positive, the idle object evictor thread starts, otherwise no idle object eviction is performed.+++
|

|[[application-properties.data.spring.data.redis.lettuce.cluster.refresh.adaptive]]xref:#application-properties.data.spring.data.redis.lettuce.cluster.refresh.adaptive[`+spring.data.redis.lettuce.cluster.refresh.adaptive+`]
|+++Whether adaptive topology refreshing using all available refresh triggers should be used.+++
|`+false+`

|[[application-properties.data.spring.data.redis.lettuce.cluster.refresh.dynamic-refresh-sources]]xref:#application-properties.data.spring.data.redis.lettuce.cluster.refresh.dynamic-refresh-sources[`+spring.data.redis.lettuce.cluster.refresh.dynamic-refresh-sources+`]
|+++Whether to discover and query all cluster nodes for obtaining the cluster topology. When set to false, only the initial seed nodes are used as sources for topology discovery.+++
|`+true+`

|[[application-properties.data.spring.data.redis.lettuce.cluster.refresh.period]]xref:#application-properties.data.spring.data.redis.lettuce.cluster.refresh.period[`+spring.data.redis.lettuce.cluster.refresh.period+`]
|+++Cluster topology refresh period.+++
|

|[[application-properties.data.spring.data.redis.lettuce.pool.enabled]]xref:#application-properties.data.spring.data.redis.lettuce.pool.enabled[`+spring.data.redis.lettuce.pool.enabled+`]
|+++Whether to enable the pool. Enabled automatically if "commons-pool2" is available. With Jedis, pooling is implicitly enabled in sentinel mode and this setting only applies to single node setup.+++
|

|[[application-properties.data.spring.data.redis.lettuce.pool.max-active]]xref:#application-properties.data.spring.data.redis.lettuce.pool.max-active[`+spring.data.redis.lettuce.pool.max-active+`]
|+++Maximum number of connections that can be allocated by the pool at a given time. Use a negative value for no limit.+++
|`+8+`

|[[application-properties.data.spring.data.redis.lettuce.pool.max-idle]]xref:#application-properties.data.spring.data.redis.lettuce.pool.max-idle[`+spring.data.redis.lettuce.pool.max-idle+`]
|+++Maximum number of "idle" connections in the pool. Use a negative value to indicate an unlimited number of idle connections.+++
|`+8+`

|[[application-properties.data.spring.data.redis.lettuce.pool.max-wait]]xref:#application-properties.data.spring.data.redis.lettuce.pool.max-wait[`+spring.data.redis.lettuce.pool.max-wait+`]
|+++Maximum amount of time a connection allocation should block before throwing an exception when the pool is exhausted. Use a negative value to block indefinitely.+++
|`+-1ms+`

|[[application-properties.data.spring.data.redis.lettuce.pool.min-idle]]xref:#application-properties.data.spring.data.redis.lettuce.pool.min-idle[`+spring.data.redis.lettuce.pool.min-idle+`]
|+++Target for the minimum number of idle connections to maintain in the pool. This setting only has an effect if both it and time between eviction runs are positive.+++
|`+0+`

|[[application-properties.data.spring.data.redis.lettuce.pool.time-between-eviction-runs]]xref:#application-properties.data.spring.data.redis.lettuce.pool.time-between-eviction-runs[`+spring.data.redis.lettuce.pool.time-between-eviction-runs+`]
|+++Time between runs of the idle object evictor thread. When positive, the idle object evictor thread starts, otherwise no idle object eviction is performed.+++
|

|[[application-properties.data.spring.data.redis.lettuce.shutdown-timeout]]xref:#application-properties.data.spring.data.redis.lettuce.shutdown-timeout[`+spring.data.redis.lettuce.shutdown-timeout+`]
|+++Shutdown timeout.+++
|`+100ms+`

|[[application-properties.data.spring.data.redis.password]]xref:#application-properties.data.spring.data.redis.password[`+spring.data.redis.password+`]
|+++Login password of the redis server.+++
|

|[[application-properties.data.spring.data.redis.port]]xref:#application-properties.data.spring.data.redis.port[`+spring.data.redis.port+`]
|+++Redis server port.+++
|`+6379+`

|[[application-properties.data.spring.data.redis.repositories.enabled]]xref:#application-properties.data.spring.data.redis.repositories.enabled[`+spring.data.redis.repositories.enabled+`]
|+++Whether to enable Redis repositories.+++
|`+true+`

|[[application-properties.data.spring.data.redis.sentinel.master]]xref:#application-properties.data.spring.data.redis.sentinel.master[`+spring.data.redis.sentinel.master+`]
|+++Name of the Redis server.+++
|

|[[application-properties.data.spring.data.redis.sentinel.nodes]]xref:#application-properties.data.spring.data.redis.sentinel.nodes[`+spring.data.redis.sentinel.nodes+`]
|+++Comma-separated list of "host:port" pairs.+++
|

|[[application-properties.data.spring.data.redis.sentinel.password]]xref:#application-properties.data.spring.data.redis.sentinel.password[`+spring.data.redis.sentinel.password+`]
|+++Password for authenticating with sentinel(s).+++
|

|[[application-properties.data.spring.data.redis.sentinel.username]]xref:#application-properties.data.spring.data.redis.sentinel.username[`+spring.data.redis.sentinel.username+`]
|+++Login username for authenticating with sentinel(s).+++
|

|[[application-properties.data.spring.data.redis.ssl.bundle]]xref:#application-properties.data.spring.data.redis.ssl.bundle[`+spring.data.redis.ssl.bundle+`]
|+++SSL bundle name.+++
|

|[[application-properties.data.spring.data.redis.ssl.enabled]]xref:#application-properties.data.spring.data.redis.ssl.enabled[`+spring.data.redis.ssl.enabled+`]
|+++Whether to enable SSL support. Enabled automatically if "bundle" is provided unless specified otherwise.+++
|

|[[application-properties.data.spring.data.redis.timeout]]xref:#application-properties.data.spring.data.redis.timeout[`+spring.data.redis.timeout+`]
|+++Read timeout.+++
|

|[[application-properties.data.spring.data.redis.url]]xref:#application-properties.data.spring.data.redis.url[`+spring.data.redis.url+`]
|+++Connection URL. Overrides host, port, username, and password. Example: redis://user:password@example.com:6379+++
|

|[[application-properties.data.spring.data.redis.username]]xref:#application-properties.data.spring.data.redis.username[`+spring.data.redis.username+`]
|+++Login username of the redis server.+++
|

|[[application-properties.data.spring.data.rest.base-path]]xref:#application-properties.data.spring.data.rest.base-path[`+spring.data.rest.base-path+`]
|+++Base path to be used by Spring Data REST to expose repository resources.+++
|

|[[application-properties.data.spring.data.rest.default-media-type]]xref:#application-properties.data.spring.data.rest.default-media-type[`+spring.data.rest.default-media-type+`]
|+++Content type to use as a default when none is specified.+++
|

|[[application-properties.data.spring.data.rest.default-page-size]]xref:#application-properties.data.spring.data.rest.default-page-size[`+spring.data.rest.default-page-size+`]
|+++Default size of pages.+++
|

|[[application-properties.data.spring.data.rest.detection-strategy]]xref:#application-properties.data.spring.data.rest.detection-strategy[`+spring.data.rest.detection-strategy+`]
|+++Strategy to use to determine which repositories get exposed.+++
|`+default+`

|[[application-properties.data.spring.data.rest.enable-enum-translation]]xref:#application-properties.data.spring.data.rest.enable-enum-translation[`+spring.data.rest.enable-enum-translation+`]
|+++Whether to enable enum value translation through the Spring Data REST default resource bundle.+++
|

|[[application-properties.data.spring.data.rest.limit-param-name]]xref:#application-properties.data.spring.data.rest.limit-param-name[`+spring.data.rest.limit-param-name+`]
|+++Name of the URL query string parameter that indicates how many results to return at once.+++
|

|[[application-properties.data.spring.data.rest.max-page-size]]xref:#application-properties.data.spring.data.rest.max-page-size[`+spring.data.rest.max-page-size+`]
|+++Maximum size of pages.+++
|

|[[application-properties.data.spring.data.rest.page-param-name]]xref:#application-properties.data.spring.data.rest.page-param-name[`+spring.data.rest.page-param-name+`]
|+++Name of the URL query string parameter that indicates what page to return.+++
|

|[[application-properties.data.spring.data.rest.return-body-on-create]]xref:#application-properties.data.spring.data.rest.return-body-on-create[`+spring.data.rest.return-body-on-create+`]
|+++Whether to return a response body after creating an entity.+++
|

|[[application-properties.data.spring.data.rest.return-body-on-update]]xref:#application-properties.data.spring.data.rest.return-body-on-update[`+spring.data.rest.return-body-on-update+`]
|+++Whether to return a response body after updating an entity.+++
|

|[[application-properties.data.spring.data.rest.sort-param-name]]xref:#application-properties.data.spring.data.rest.sort-param-name[`+spring.data.rest.sort-param-name+`]
|+++Name of the URL query string parameter that indicates what direction to sort results.+++
|

|[[application-properties.data.spring.data.web.pageable.default-page-size]]xref:#application-properties.data.spring.data.web.pageable.default-page-size[`+spring.data.web.pageable.default-page-size+`]
|+++Default page size.+++
|`+20+`

|[[application-properties.data.spring.data.web.pageable.max-page-size]]xref:#application-properties.data.spring.data.web.pageable.max-page-size[`+spring.data.web.pageable.max-page-size+`]
|+++Maximum page size to be accepted.+++
|`+2000+`

|[[application-properties.data.spring.data.web.pageable.one-indexed-parameters]]xref:#application-properties.data.spring.data.web.pageable.one-indexed-parameters[`+spring.data.web.pageable.one-indexed-parameters+`]
|+++Whether to expose and assume 1-based page number indexes. Defaults to "false", meaning a page number of 0 in the request equals the first page.+++
|`+false+`

|[[application-properties.data.spring.data.web.pageable.page-parameter]]xref:#application-properties.data.spring.data.web.pageable.page-parameter[`+spring.data.web.pageable.page-parameter+`]
|+++Page index parameter name.+++
|`+page+`

|[[application-properties.data.spring.data.web.pageable.prefix]]xref:#application-properties.data.spring.data.web.pageable.prefix[`+spring.data.web.pageable.prefix+`]
|+++General prefix to be prepended to the page number and page size parameters.+++
|

|[[application-properties.data.spring.data.web.pageable.qualifier-delimiter]]xref:#application-properties.data.spring.data.web.pageable.qualifier-delimiter[`+spring.data.web.pageable.qualifier-delimiter+`]
|+++Delimiter to be used between the qualifier and the actual page number and size properties.+++
|`+_+`

|[[application-properties.data.spring.data.web.pageable.size-parameter]]xref:#application-properties.data.spring.data.web.pageable.size-parameter[`+spring.data.web.pageable.size-parameter+`]
|+++Page size parameter name.+++
|`+size+`

|[[application-properties.data.spring.data.web.sort.sort-parameter]]xref:#application-properties.data.spring.data.web.sort.sort-parameter[`+spring.data.web.sort.sort-parameter+`]
|+++Sort parameter name.+++
|`+sort+`

|[[application-properties.data.spring.datasource.dbcp2]]xref:#application-properties.data.spring.datasource.dbcp2[`+spring.datasource.dbcp2.abandoned-usage-tracking+` +
`+spring.datasource.dbcp2.access-to-underlying-connection-allowed+` +
`+spring.datasource.dbcp2.auto-commit-on-return+` +
`+spring.datasource.dbcp2.cache-state+` +
`+spring.datasource.dbcp2.clear-statement-pool-on-return+` +
`+spring.datasource.dbcp2.connection-factory-class-name+` +
`+spring.datasource.dbcp2.connection-init-sqls+` +
`+spring.datasource.dbcp2.default-auto-commit+` +
`+spring.datasource.dbcp2.default-catalog+` +
`+spring.datasource.dbcp2.default-read-only+` +
`+spring.datasource.dbcp2.default-schema+` +
`+spring.datasource.dbcp2.default-transaction-isolation+` +
`+spring.datasource.dbcp2.disconnection-sql-codes+` +
`+spring.datasource.dbcp2.driver+` +
`+spring.datasource.dbcp2.driver-class-name+` +
`+spring.datasource.dbcp2.duration-between-eviction-runs+` +
`+spring.datasource.dbcp2.eviction-policy-class-name+` +
`+spring.datasource.dbcp2.fast-fail-validation+` +
`+spring.datasource.dbcp2.initial-size+` +
`+spring.datasource.dbcp2.jmx-name+` +
`+spring.datasource.dbcp2.lifo+` +
`+spring.datasource.dbcp2.log-abandoned+` +
`+spring.datasource.dbcp2.log-expired-connections+` +
`+spring.datasource.dbcp2.login-timeout+` +
`+spring.datasource.dbcp2.max-idle+` +
`+spring.datasource.dbcp2.max-open-prepared-statements+` +
`+spring.datasource.dbcp2.max-total+` +
`+spring.datasource.dbcp2.min-idle+` +
`+spring.datasource.dbcp2.num-tests-per-eviction-run+` +
`+spring.datasource.dbcp2.password+` +
`+spring.datasource.dbcp2.pool-prepared-statements+` +
`+spring.datasource.dbcp2.remove-abandoned-on-borrow+` +
`+spring.datasource.dbcp2.remove-abandoned-on-maintenance+` +
`+spring.datasource.dbcp2.rollback-on-return+` +
`+spring.datasource.dbcp2.test-on-borrow+` +
`+spring.datasource.dbcp2.test-on-create+` +
`+spring.datasource.dbcp2.test-on-return+` +
`+spring.datasource.dbcp2.test-while-idle+` +
`+spring.datasource.dbcp2.url+` +
`+spring.datasource.dbcp2.username+` +
`+spring.datasource.dbcp2.validation-query+` +
]
|+++Commons DBCP2 specific settings bound to an instance of DBCP2's BasicDataSource+++
|

|[[application-properties.data.spring.datasource.driver-class-name]]xref:#application-properties.data.spring.datasource.driver-class-name[`+spring.datasource.driver-class-name+`]
|+++Fully qualified name of the JDBC driver. Auto-detected based on the URL by default.+++
|

|[[application-properties.data.spring.datasource.embedded-database-connection]]xref:#application-properties.data.spring.datasource.embedded-database-connection[`+spring.datasource.embedded-database-connection+`]
|+++Connection details for an embedded database. Defaults to the most suitable embedded database that is available on the classpath.+++
|

|[[application-properties.data.spring.datasource.generate-unique-name]]xref:#application-properties.data.spring.datasource.generate-unique-name[`+spring.datasource.generate-unique-name+`]
|+++Whether to generate a random datasource name.+++
|`+true+`

|[[application-properties.data.spring.datasource.hikari]]xref:#application-properties.data.spring.datasource.hikari[`+spring.datasource.hikari.allow-pool-suspension+` +
`+spring.datasource.hikari.auto-commit+` +
`+spring.datasource.hikari.catalog+` +
`+spring.datasource.hikari.connection-init-sql+` +
`+spring.datasource.hikari.connection-test-query+` +
`+spring.datasource.hikari.connection-timeout+` +
`+spring.datasource.hikari.data-source-class-name+` +
`+spring.datasource.hikari.data-source-j-n-d-i+` +
`+spring.datasource.hikari.data-source-properties+` +
`+spring.datasource.hikari.driver-class-name+` +
`+spring.datasource.hikari.exception-override-class-name+` +
`+spring.datasource.hikari.health-check-properties+` +
`+spring.datasource.hikari.idle-timeout+` +
`+spring.datasource.hikari.initialization-fail-timeout+` +
`+spring.datasource.hikari.isolate-internal-queries+` +
`+spring.datasource.hikari.jdbc-url+` +
`+spring.datasource.hikari.keepalive-time+` +
`+spring.datasource.hikari.leak-detection-threshold+` +
`+spring.datasource.hikari.login-timeout+` +
`+spring.datasource.hikari.max-lifetime+` +
`+spring.datasource.hikari.maximum-pool-size+` +
`+spring.datasource.hikari.metrics-tracker-factory+` +
`+spring.datasource.hikari.minimum-idle+` +
`+spring.datasource.hikari.password+` +
`+spring.datasource.hikari.pool-name+` +
`+spring.datasource.hikari.read-only+` +
`+spring.datasource.hikari.register-mbeans+` +
`+spring.datasource.hikari.scheduled-executor+` +
`+spring.datasource.hikari.schema+` +
`+spring.datasource.hikari.transaction-isolation+` +
`+spring.datasource.hikari.username+` +
`+spring.datasource.hikari.validation-timeout+` +
]
|+++Hikari specific settings bound to an instance of Hikari's HikariDataSource+++
|

|[[application-properties.data.spring.datasource.jndi-name]]xref:#application-properties.data.spring.datasource.jndi-name[`+spring.datasource.jndi-name+`]
|+++JNDI location of the datasource. Class, url, username and password are ignored when set.+++
|

|[[application-properties.data.spring.datasource.name]]xref:#application-properties.data.spring.datasource.name[`+spring.datasource.name+`]
|+++Datasource name to use if "generate-unique-name" is false. Defaults to "testdb" when using an embedded database, otherwise null.+++
|

|[[application-properties.data.spring.datasource.oracleucp]]xref:#application-properties.data.spring.datasource.oracleucp[`+spring.datasource.oracleucp.abandoned-connection-timeout+` +
`+spring.datasource.oracleucp.connection-factory-class-name+` +
`+spring.datasource.oracleucp.connection-factory-properties+` +
`+spring.datasource.oracleucp.connection-harvest-max-count+` +
`+spring.datasource.oracleucp.connection-harvest-trigger-count+` +
`+spring.datasource.oracleucp.connection-labeling-high-cost+` +
`+spring.datasource.oracleucp.connection-pool-name+` +
`+spring.datasource.oracleucp.connection-properties+` +
`+spring.datasource.oracleucp.connection-repurpose-threshold+` +
`+spring.datasource.oracleucp.connection-validation-timeout+` +
`+spring.datasource.oracleucp.connection-wait-timeout+` +
`+spring.datasource.oracleucp.data-source-name+` +
`+spring.datasource.oracleucp.database-name+` +
`+spring.datasource.oracleucp.description+` +
`+spring.datasource.oracleucp.fast-connection-failover-enabled+` +
`+spring.datasource.oracleucp.high-cost-connection-reuse-threshold+` +
`+spring.datasource.oracleucp.inactive-connection-timeout+` +
`+spring.datasource.oracleucp.initial-pool-size+` +
`+spring.datasource.oracleucp.login-timeout+` +
`+spring.datasource.oracleucp.max-connection-reuse-count+` +
`+spring.datasource.oracleucp.max-connection-reuse-time+` +
`+spring.datasource.oracleucp.max-connections-per-shard+` +
`+spring.datasource.oracleucp.max-idle-time+` +
`+spring.datasource.oracleucp.max-pool-size+` +
`+spring.datasource.oracleucp.max-statements+` +
`+spring.datasource.oracleucp.min-pool-size+` +
`+spring.datasource.oracleucp.network-protocol+` +
`+spring.datasource.oracleucp.o-n-s-configuration+` +
`+spring.datasource.oracleucp.pdb-roles+` +
`+spring.datasource.oracleucp.port-number+` +
`+spring.datasource.oracleucp.property-cycle+` +
`+spring.datasource.oracleucp.query-timeout+` +
`+spring.datasource.oracleucp.read-only-instance-allowed+` +
`+spring.datasource.oracleucp.role-name+` +
`+spring.datasource.oracleucp.s-q-l-for-validate-connection+` +
`+spring.datasource.oracleucp.seconds-to-trust-idle-connection+` +
`+spring.datasource.oracleucp.server-name+` +
`+spring.datasource.oracleucp.sharding-mode+` +
`+spring.datasource.oracleucp.time-to-live-connection-timeout+` +
`+spring.datasource.oracleucp.timeout-check-interval+` +
`+spring.datasource.oracleucp.u-r-l+` +
`+spring.datasource.oracleucp.user+` +
`+spring.datasource.oracleucp.validate-connection-on-borrow+` +
]
|+++Oracle UCP specific settings bound to an instance of Oracle UCP's PoolDataSource+++
|

|[[application-properties.data.spring.datasource.password]]xref:#application-properties.data.spring.datasource.password[`+spring.datasource.password+`]
|+++Login password of the database.+++
|

|[[application-properties.data.spring.datasource.tomcat]]xref:#application-properties.data.spring.datasource.tomcat[`+spring.datasource.tomcat.abandon-when-percentage-full+` +
`+spring.datasource.tomcat.access-to-underlying-connection-allowed+` +
`+spring.datasource.tomcat.alternate-username-allowed+` +
`+spring.datasource.tomcat.commit-on-return+` +
`+spring.datasource.tomcat.connection-properties+` +
`+spring.datasource.tomcat.data-source-j-n-d-i+` +
`+spring.datasource.tomcat.db-properties+` +
`+spring.datasource.tomcat.default-auto-commit+` +
`+spring.datasource.tomcat.default-catalog+` +
`+spring.datasource.tomcat.default-read-only+` +
`+spring.datasource.tomcat.default-transaction-isolation+` +
`+spring.datasource.tomcat.driver-class-name+` +
`+spring.datasource.tomcat.fair-queue+` +
`+spring.datasource.tomcat.ignore-exception-on-pre-load+` +
`+spring.datasource.tomcat.init-s-q-l+` +
`+spring.datasource.tomcat.initial-size+` +
`+spring.datasource.tomcat.jdbc-interceptors+` +
`+spring.datasource.tomcat.jmx-enabled+` +
`+spring.datasource.tomcat.log-abandoned+` +
`+spring.datasource.tomcat.log-validation-errors+` +
`+spring.datasource.tomcat.login-timeout+` +
`+spring.datasource.tomcat.max-active+` +
`+spring.datasource.tomcat.max-age+` +
`+spring.datasource.tomcat.max-idle+` +
`+spring.datasource.tomcat.max-wait+` +
`+spring.datasource.tomcat.min-evictable-idle-time-millis+` +
`+spring.datasource.tomcat.min-idle+` +
`+spring.datasource.tomcat.name+` +
`+spring.datasource.tomcat.num-tests-per-eviction-run+` +
`+spring.datasource.tomcat.password+` +
`+spring.datasource.tomcat.propagate-interrupt-state+` +
`+spring.datasource.tomcat.remove-abandoned+` +
`+spring.datasource.tomcat.remove-abandoned-timeout+` +
`+spring.datasource.tomcat.rollback-on-return+` +
`+spring.datasource.tomcat.suspect-timeout+` +
`+spring.datasource.tomcat.test-on-borrow+` +
`+spring.datasource.tomcat.test-on-connect+` +
`+spring.datasource.tomcat.test-on-return+` +
`+spring.datasource.tomcat.test-while-idle+` +
`+spring.datasource.tomcat.time-between-eviction-runs-millis+` +
`+spring.datasource.tomcat.url+` +
`+spring.datasource.tomcat.use-disposable-connection-facade+` +
`+spring.datasource.tomcat.use-equals+` +
`+spring.datasource.tomcat.use-lock+` +
`+spring.datasource.tomcat.use-statement-facade+` +
`+spring.datasource.tomcat.username+` +
`+spring.datasource.tomcat.validation-interval+` +
`+spring.datasource.tomcat.validation-query+` +
`+spring.datasource.tomcat.validation-query-timeout+` +
`+spring.datasource.tomcat.validator-class-name+` +
]
|+++Tomcat datasource specific settings bound to an instance of Tomcat JDBC's DataSource+++
|

|[[application-properties.data.spring.datasource.type]]xref:#application-properties.data.spring.datasource.type[`+spring.datasource.type+`]
|+++Fully qualified name of the connection pool implementation to use. By default, it is auto-detected from the classpath.+++
|

|[[application-properties.data.spring.datasource.url]]xref:#application-properties.data.spring.datasource.url[`+spring.datasource.url+`]
|+++JDBC URL of the database.+++
|

|[[application-properties.data.spring.datasource.username]]xref:#application-properties.data.spring.datasource.username[`+spring.datasource.username+`]
|+++Login username of the database.+++
|

|[[application-properties.data.spring.datasource.xa.data-source-class-name]]xref:#application-properties.data.spring.datasource.xa.data-source-class-name[`+spring.datasource.xa.data-source-class-name+`]
|+++XA datasource fully qualified name.+++
|

|[[application-properties.data.spring.datasource.xa.properties]]xref:#application-properties.data.spring.datasource.xa.properties[`+spring.datasource.xa.properties.*+`]
|+++Properties to pass to the XA data source.+++
|

|[[application-properties.data.spring.elasticsearch.connection-timeout]]xref:#application-properties.data.spring.elasticsearch.connection-timeout[`+spring.elasticsearch.connection-timeout+`]
|+++Connection timeout used when communicating with Elasticsearch.+++
|`+1s+`

|[[application-properties.data.spring.elasticsearch.password]]xref:#application-properties.data.spring.elasticsearch.password[`+spring.elasticsearch.password+`]
|+++Password for authentication with Elasticsearch.+++
|

|[[application-properties.data.spring.elasticsearch.path-prefix]]xref:#application-properties.data.spring.elasticsearch.path-prefix[`+spring.elasticsearch.path-prefix+`]
|+++Prefix added to the path of every request sent to Elasticsearch.+++
|

|[[application-properties.data.spring.elasticsearch.restclient.sniffer.delay-after-failure]]xref:#application-properties.data.spring.elasticsearch.restclient.sniffer.delay-after-failure[`+spring.elasticsearch.restclient.sniffer.delay-after-failure+`]
|+++Delay of a sniff execution scheduled after a failure.+++
|`+1m+`

|[[application-properties.data.spring.elasticsearch.restclient.sniffer.interval]]xref:#application-properties.data.spring.elasticsearch.restclient.sniffer.interval[`+spring.elasticsearch.restclient.sniffer.interval+`]
|+++Interval between consecutive ordinary sniff executions.+++
|`+5m+`

|[[application-properties.data.spring.elasticsearch.restclient.ssl.bundle]]xref:#application-properties.data.spring.elasticsearch.restclient.ssl.bundle[`+spring.elasticsearch.restclient.ssl.bundle+`]
|+++SSL bundle name.+++
|

|[[application-properties.data.spring.elasticsearch.socket-keep-alive]]xref:#application-properties.data.spring.elasticsearch.socket-keep-alive[`+spring.elasticsearch.socket-keep-alive+`]
|+++Whether to enable socket keep alive between client and Elasticsearch.+++
|`+false+`

|[[application-properties.data.spring.elasticsearch.socket-timeout]]xref:#application-properties.data.spring.elasticsearch.socket-timeout[`+spring.elasticsearch.socket-timeout+`]
|+++Socket timeout used when communicating with Elasticsearch.+++
|`+30s+`

|[[application-properties.data.spring.elasticsearch.uris]]xref:#application-properties.data.spring.elasticsearch.uris[`+spring.elasticsearch.uris+`]
|+++Comma-separated list of the Elasticsearch instances to use.+++
|`+[http://localhost:9200]+`

|[[application-properties.data.spring.elasticsearch.username]]xref:#application-properties.data.spring.elasticsearch.username[`+spring.elasticsearch.username+`]
|+++Username for authentication with Elasticsearch.+++
|

|[[application-properties.data.spring.h2.console.enabled]]xref:#application-properties.data.spring.h2.console.enabled[`+spring.h2.console.enabled+`]
|+++Whether to enable the console.+++
|`+false+`

|[[application-properties.data.spring.h2.console.path]]xref:#application-properties.data.spring.h2.console.path[`+spring.h2.console.path+`]
|+++Path at which the console is available.+++
|`+/h2-console+`

|[[application-properties.data.spring.h2.console.settings.trace]]xref:#application-properties.data.spring.h2.console.settings.trace[`+spring.h2.console.settings.trace+`]
|+++Whether to enable trace output.+++
|`+false+`

|[[application-properties.data.spring.h2.console.settings.web-admin-password]]xref:#application-properties.data.spring.h2.console.settings.web-admin-password[`+spring.h2.console.settings.web-admin-password+`]
|+++Password to access preferences and tools of H2 Console.+++
|

|[[application-properties.data.spring.h2.console.settings.web-allow-others]]xref:#application-properties.data.spring.h2.console.settings.web-allow-others[`+spring.h2.console.settings.web-allow-others+`]
|+++Whether to enable remote access.+++
|`+false+`

|[[application-properties.data.spring.jdbc.template.fetch-size]]xref:#application-properties.data.spring.jdbc.template.fetch-size[`+spring.jdbc.template.fetch-size+`]
|+++Number of rows that should be fetched from the database when more rows are needed. Use -1 to use the JDBC driver's default configuration.+++
|`+-1+`

|[[application-properties.data.spring.jdbc.template.max-rows]]xref:#application-properties.data.spring.jdbc.template.max-rows[`+spring.jdbc.template.max-rows+`]
|+++Maximum number of rows. Use -1 to use the JDBC driver's default configuration.+++
|`+-1+`

|[[application-properties.data.spring.jdbc.template.query-timeout]]xref:#application-properties.data.spring.jdbc.template.query-timeout[`+spring.jdbc.template.query-timeout+`]
|+++Query timeout. Default is to use the JDBC driver's default configuration. If a duration suffix is not specified, seconds will be used.+++
|

|[[application-properties.data.spring.jooq.sql-dialect]]xref:#application-properties.data.spring.jooq.sql-dialect[`+spring.jooq.sql-dialect+`]
|+++SQL dialect to use. Auto-detected by default.+++
|

|[[application-properties.data.spring.jpa.database]]xref:#application-properties.data.spring.jpa.database[`+spring.jpa.database+`]
|+++Target database to operate on, auto-detected by default. Can be alternatively set using the "databasePlatform" property.+++
|

|[[application-properties.data.spring.jpa.database-platform]]xref:#application-properties.data.spring.jpa.database-platform[`+spring.jpa.database-platform+`]
|+++Name of the target database to operate on, auto-detected by default. Can be alternatively set using the "Database" enum.+++
|

|[[application-properties.data.spring.jpa.defer-datasource-initialization]]xref:#application-properties.data.spring.jpa.defer-datasource-initialization[`+spring.jpa.defer-datasource-initialization+`]
|+++Whether to defer DataSource initialization until after any EntityManagerFactory beans have been created and initialized.+++
|`+false+`

|[[application-properties.data.spring.jpa.generate-ddl]]xref:#application-properties.data.spring.jpa.generate-ddl[`+spring.jpa.generate-ddl+`]
|+++Whether to initialize the schema on startup.+++
|`+false+`

|[[application-properties.data.spring.jpa.hibernate.ddl-auto]]xref:#application-properties.data.spring.jpa.hibernate.ddl-auto[`+spring.jpa.hibernate.ddl-auto+`]
|+++DDL mode. This is actually a shortcut for the "hibernate.hbm2ddl.auto" property. Defaults to "create-drop" when using an embedded database and no schema manager was detected. Otherwise, defaults to "none".+++
|

|[[application-properties.data.spring.jpa.hibernate.naming.implicit-strategy]]xref:#application-properties.data.spring.jpa.hibernate.naming.implicit-strategy[`+spring.jpa.hibernate.naming.implicit-strategy+`]
|+++Fully qualified name of the implicit naming strategy.+++
|

|[[application-properties.data.spring.jpa.hibernate.naming.physical-strategy]]xref:#application-properties.data.spring.jpa.hibernate.naming.physical-strategy[`+spring.jpa.hibernate.naming.physical-strategy+`]
|+++Fully qualified name of the physical naming strategy.+++
|

|[[application-properties.data.spring.jpa.mapping-resources]]xref:#application-properties.data.spring.jpa.mapping-resources[`+spring.jpa.mapping-resources+`]
|+++Mapping resources (equivalent to "mapping-file" entries in persistence.xml).+++
|

|[[application-properties.data.spring.jpa.open-in-view]]xref:#application-properties.data.spring.jpa.open-in-view[`+spring.jpa.open-in-view+`]
|+++Register OpenEntityManagerInViewInterceptor. Binds a JPA EntityManager to the thread for the entire processing of the request.+++
|`+true+`

|[[application-properties.data.spring.jpa.properties]]xref:#application-properties.data.spring.jpa.properties[`+spring.jpa.properties.*+`]
|+++Additional native properties to set on the JPA provider.+++
|

|[[application-properties.data.spring.jpa.show-sql]]xref:#application-properties.data.spring.jpa.show-sql[`+spring.jpa.show-sql+`]
|+++Whether to enable logging of SQL statements.+++
|`+false+`

|[[application-properties.data.spring.ldap.anonymous-read-only]]xref:#application-properties.data.spring.ldap.anonymous-read-only[`+spring.ldap.anonymous-read-only+`]
|+++Whether read-only operations should use an anonymous environment. Disabled by default unless a username is set.+++
|

|[[application-properties.data.spring.ldap.base]]xref:#application-properties.data.spring.ldap.base[`+spring.ldap.base+`]
|+++Base suffix from which all operations should originate.+++
|

|[[application-properties.data.spring.ldap.base-environment]]xref:#application-properties.data.spring.ldap.base-environment[`+spring.ldap.base-environment.*+`]
|+++LDAP specification settings.+++
|

|[[application-properties.data.spring.ldap.embedded.base-dn]]xref:#application-properties.data.spring.ldap.embedded.base-dn[`+spring.ldap.embedded.base-dn+`]
|+++List of base DNs.+++
|

|[[application-properties.data.spring.ldap.embedded.credential.password]]xref:#application-properties.data.spring.ldap.embedded.credential.password[`+spring.ldap.embedded.credential.password+`]
|+++Embedded LDAP password.+++
|

|[[application-properties.data.spring.ldap.embedded.credential.username]]xref:#application-properties.data.spring.ldap.embedded.credential.username[`+spring.ldap.embedded.credential.username+`]
|+++Embedded LDAP username.+++
|

|[[application-properties.data.spring.ldap.embedded.ldif]]xref:#application-properties.data.spring.ldap.embedded.ldif[`+spring.ldap.embedded.ldif+`]
|+++Schema (LDIF) script resource reference.+++
|`+classpath:schema.ldif+`

|[[application-properties.data.spring.ldap.embedded.port]]xref:#application-properties.data.spring.ldap.embedded.port[`+spring.ldap.embedded.port+`]
|+++Embedded LDAP port.+++
|`+0+`

|[[application-properties.data.spring.ldap.embedded.validation.enabled]]xref:#application-properties.data.spring.ldap.embedded.validation.enabled[`+spring.ldap.embedded.validation.enabled+`]
|+++Whether to enable LDAP schema validation.+++
|`+true+`

|[[application-properties.data.spring.ldap.embedded.validation.schema]]xref:#application-properties.data.spring.ldap.embedded.validation.schema[`+spring.ldap.embedded.validation.schema+`]
|+++Path to the custom schema.+++
|

|[[application-properties.data.spring.ldap.password]]xref:#application-properties.data.spring.ldap.password[`+spring.ldap.password+`]
|+++Login password of the server.+++
|

|[[application-properties.data.spring.ldap.template.ignore-name-not-found-exception]]xref:#application-properties.data.spring.ldap.template.ignore-name-not-found-exception[`+spring.ldap.template.ignore-name-not-found-exception+`]
|+++Whether NameNotFoundException should be ignored in searches through the LdapTemplate.+++
|`+false+`

|[[application-properties.data.spring.ldap.template.ignore-partial-result-exception]]xref:#application-properties.data.spring.ldap.template.ignore-partial-result-exception[`+spring.ldap.template.ignore-partial-result-exception+`]
|+++Whether PartialResultException should be ignored in searches through the LdapTemplate.+++
|`+false+`

|[[application-properties.data.spring.ldap.template.ignore-size-limit-exceeded-exception]]xref:#application-properties.data.spring.ldap.template.ignore-size-limit-exceeded-exception[`+spring.ldap.template.ignore-size-limit-exceeded-exception+`]
|+++Whether SizeLimitExceededException should be ignored in searches through the LdapTemplate.+++
|`+true+`

|[[application-properties.data.spring.ldap.urls]]xref:#application-properties.data.spring.ldap.urls[`+spring.ldap.urls+`]
|+++LDAP URLs of the server.+++
|

|[[application-properties.data.spring.ldap.username]]xref:#application-properties.data.spring.ldap.username[`+spring.ldap.username+`]
|+++Login username of the server.+++
|

|[[application-properties.data.spring.neo4j.authentication.kerberos-ticket]]xref:#application-properties.data.spring.neo4j.authentication.kerberos-ticket[`+spring.neo4j.authentication.kerberos-ticket+`]
|+++Kerberos ticket for connecting to the database. Mutual exclusive with a given username.+++
|

|[[application-properties.data.spring.neo4j.authentication.password]]xref:#application-properties.data.spring.neo4j.authentication.password[`+spring.neo4j.authentication.password+`]
|+++Login password of the server.+++
|

|[[application-properties.data.spring.neo4j.authentication.realm]]xref:#application-properties.data.spring.neo4j.authentication.realm[`+spring.neo4j.authentication.realm+`]
|+++Realm to connect to.+++
|

|[[application-properties.data.spring.neo4j.authentication.username]]xref:#application-properties.data.spring.neo4j.authentication.username[`+spring.neo4j.authentication.username+`]
|+++Login user of the server.+++
|

|[[application-properties.data.spring.neo4j.connection-timeout]]xref:#application-properties.data.spring.neo4j.connection-timeout[`+spring.neo4j.connection-timeout+`]
|+++Timeout for borrowing connections from the pool.+++
|`+30s+`

|[[application-properties.data.spring.neo4j.max-transaction-retry-time]]xref:#application-properties.data.spring.neo4j.max-transaction-retry-time[`+spring.neo4j.max-transaction-retry-time+`]
|+++Maximum time transactions are allowed to retry.+++
|`+30s+`

|[[application-properties.data.spring.neo4j.pool.connection-acquisition-timeout]]xref:#application-properties.data.spring.neo4j.pool.connection-acquisition-timeout[`+spring.neo4j.pool.connection-acquisition-timeout+`]
|+++Acquisition of new connections will be attempted for at most configured timeout.+++
|`+60s+`

|[[application-properties.data.spring.neo4j.pool.idle-time-before-connection-test]]xref:#application-properties.data.spring.neo4j.pool.idle-time-before-connection-test[`+spring.neo4j.pool.idle-time-before-connection-test+`]
|+++Pooled connections that have been idle in the pool for longer than this threshold will be tested before they are used again.+++
|

|[[application-properties.data.spring.neo4j.pool.log-leaked-sessions]]xref:#application-properties.data.spring.neo4j.pool.log-leaked-sessions[`+spring.neo4j.pool.log-leaked-sessions+`]
|+++Whether to log leaked sessions.+++
|`+false+`

|[[application-properties.data.spring.neo4j.pool.max-connection-lifetime]]xref:#application-properties.data.spring.neo4j.pool.max-connection-lifetime[`+spring.neo4j.pool.max-connection-lifetime+`]
|+++Pooled connections older than this threshold will be closed and removed from the pool.+++
|`+1h+`

|[[application-properties.data.spring.neo4j.pool.max-connection-pool-size]]xref:#application-properties.data.spring.neo4j.pool.max-connection-pool-size[`+spring.neo4j.pool.max-connection-pool-size+`]
|+++Maximum amount of connections in the connection pool towards a single database.+++
|`+100+`

|[[application-properties.data.spring.neo4j.pool.metrics-enabled]]xref:#application-properties.data.spring.neo4j.pool.metrics-enabled[`+spring.neo4j.pool.metrics-enabled+`]
|+++Whether to enable metrics.+++
|`+false+`

|[[application-properties.data.spring.neo4j.security.cert-file]]xref:#application-properties.data.spring.neo4j.security.cert-file[`+spring.neo4j.security.cert-file+`]
|+++Path to the file that holds the trusted certificates.+++
|

|[[application-properties.data.spring.neo4j.security.encrypted]]xref:#application-properties.data.spring.neo4j.security.encrypted[`+spring.neo4j.security.encrypted+`]
|+++Whether the driver should use encrypted traffic.+++
|`+false+`

|[[application-properties.data.spring.neo4j.security.hostname-verification-enabled]]xref:#application-properties.data.spring.neo4j.security.hostname-verification-enabled[`+spring.neo4j.security.hostname-verification-enabled+`]
|+++Whether hostname verification is required.+++
|`+true+`

|[[application-properties.data.spring.neo4j.security.trust-strategy]]xref:#application-properties.data.spring.neo4j.security.trust-strategy[`+spring.neo4j.security.trust-strategy+`]
|+++Trust strategy to use.+++
|`+trust-system-ca-signed-certificates+`

|[[application-properties.data.spring.neo4j.uri]]xref:#application-properties.data.spring.neo4j.uri[`+spring.neo4j.uri+`]
|+++URI used by the driver.+++
|`+bolt://localhost:7687+`

|[[application-properties.data.spring.r2dbc.generate-unique-name]]xref:#application-properties.data.spring.r2dbc.generate-unique-name[`+spring.r2dbc.generate-unique-name+`]
|+++Whether to generate a random database name. Ignore any configured name when enabled.+++
|`+false+`

|[[application-properties.data.spring.r2dbc.name]]xref:#application-properties.data.spring.r2dbc.name[`+spring.r2dbc.name+`]
|+++Database name. Set if no name is specified in the url. Default to "testdb" when using an embedded database.+++
|

|[[application-properties.data.spring.r2dbc.password]]xref:#application-properties.data.spring.r2dbc.password[`+spring.r2dbc.password+`]
|+++Login password of the database. Set if no password is specified in the url.+++
|

|[[application-properties.data.spring.r2dbc.pool.enabled]]xref:#application-properties.data.spring.r2dbc.pool.enabled[`+spring.r2dbc.pool.enabled+`]
|+++Whether pooling is enabled. Requires r2dbc-pool.+++
|`+true+`

|[[application-properties.data.spring.r2dbc.pool.initial-size]]xref:#application-properties.data.spring.r2dbc.pool.initial-size[`+spring.r2dbc.pool.initial-size+`]
|+++Initial connection pool size.+++
|`+10+`

|[[application-properties.data.spring.r2dbc.pool.max-acquire-time]]xref:#application-properties.data.spring.r2dbc.pool.max-acquire-time[`+spring.r2dbc.pool.max-acquire-time+`]
|+++Maximum time to acquire a connection from the pool. By default, wait indefinitely.+++
|

|[[application-properties.data.spring.r2dbc.pool.max-create-connection-time]]xref:#application-properties.data.spring.r2dbc.pool.max-create-connection-time[`+spring.r2dbc.pool.max-create-connection-time+`]
|+++Maximum time to wait to create a new connection. By default, wait indefinitely.+++
|

|[[application-properties.data.spring.r2dbc.pool.max-idle-time]]xref:#application-properties.data.spring.r2dbc.pool.max-idle-time[`+spring.r2dbc.pool.max-idle-time+`]
|+++Maximum amount of time that a connection is allowed to sit idle in the pool.+++
|`+30m+`

|[[application-properties.data.spring.r2dbc.pool.max-life-time]]xref:#application-properties.data.spring.r2dbc.pool.max-life-time[`+spring.r2dbc.pool.max-life-time+`]
|+++Maximum lifetime of a connection in the pool. By default, connections have an infinite lifetime.+++
|

|[[application-properties.data.spring.r2dbc.pool.max-size]]xref:#application-properties.data.spring.r2dbc.pool.max-size[`+spring.r2dbc.pool.max-size+`]
|+++Maximal connection pool size.+++
|`+10+`

|[[application-properties.data.spring.r2dbc.pool.max-validation-time]]xref:#application-properties.data.spring.r2dbc.pool.max-validation-time[`+spring.r2dbc.pool.max-validation-time+`]
|+++Maximum time to validate a connection from the pool. By default, wait indefinitely.+++
|

|[[application-properties.data.spring.r2dbc.pool.min-idle]]xref:#application-properties.data.spring.r2dbc.pool.min-idle[`+spring.r2dbc.pool.min-idle+`]
|+++Minimal number of idle connections.+++
|`+0+`

|[[application-properties.data.spring.r2dbc.pool.validation-depth]]xref:#application-properties.data.spring.r2dbc.pool.validation-depth[`+spring.r2dbc.pool.validation-depth+`]
|+++Validation depth.+++
|`+local+`

|[[application-properties.data.spring.r2dbc.pool.validation-query]]xref:#application-properties.data.spring.r2dbc.pool.validation-query[`+spring.r2dbc.pool.validation-query+`]
|+++Validation query.+++
|

|[[application-properties.data.spring.r2dbc.properties]]xref:#application-properties.data.spring.r2dbc.properties[`+spring.r2dbc.properties.*+`]
|+++Additional R2DBC options.+++
|

|[[application-properties.data.spring.r2dbc.url]]xref:#application-properties.data.spring.r2dbc.url[`+spring.r2dbc.url+`]
|+++R2DBC URL of the database. database name, username, password and pooling options specified in the url take precedence over individual options.+++
|

|[[application-properties.data.spring.r2dbc.username]]xref:#application-properties.data.spring.r2dbc.username[`+spring.r2dbc.username+`]
|+++Login username of the database. Set if no username is specified in the url.+++
|

|===
