Configuration settings

Configures the general policy for when check-points should occur. The default policy is the 'periodic' check-point policy, as specified by the 'dbms.checkpoint.interval.tx' and 'dbms.checkpoint.interval.time' settings. The Neo4j Enterprise Edition provides two alternative policies: The first is the 'continuous' check-point policy, which will ignore those settings and run the check-point process all the time. The second is the 'volumetric' check-point policy, which makes a best-effort at check-pointing often enough so that the database doesn’t get too far behind on deleting old transaction logs in accordance with the 'dbms.tx_log.rotation.retention_policy' setting.

dbms.checkpoint, one of [PERIODIC, CONTINUOUS, VOLUME, VOLUMETRIC]

Configures the time interval between check-points. The database will not check-point more often than this (unless check pointing is triggered by a different event), but might check-point less often than this interval, if performing a check-point takes longer time than the configured interval. A check-point is a point in the transaction logs, which recovery would start from. Longer check-point intervals typically mean that recovery will take longer to complete in case of a crash. On the other hand, a longer check-point interval can also reduce the I/O load that the database places on the system, as each check-point implies a flushing and forcing of all the store files.

dbms.checkpoint.interval.time, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

Configures the transaction interval between check-points. The database will not check-point more often than this (unless check pointing is triggered by a different event), but might check-point less often than this interval, if performing a check-point takes longer time than the configured interval. A check-point is a point in the transaction logs, which recovery would start from. Longer check-point intervals typically mean that recovery will take longer to complete in case of a crash. On the other hand, a longer check-point interval can also reduce the I/O load that the database places on the system, as each check-point implies a flushing and forcing of all the store files. The default is '100000' for a check-point every 100000 transactions.

dbms.checkpoint.interval.tx, an integer which is minimum 1

Configures the volume of transacton logs between check-points. The database will not check-point more often than this (unless check pointing is triggered by a different event), but might check-point less often than this interval, if performing a check-point takes longer time than the configured interval. A check-point is a point in the transaction logs, which recovery would start from. Longer check-point intervals typically mean that recovery will take longer to complete in case of a crash. On the other hand, a longer check-point interval can also reduce the I/O load that the database places on the system, as each check-point implies a flushing and forcing of all the store files.

dbms.checkpoint.interval.volume, a byte size (valid multipliers are B, KiB, KB, K, kB, kb, k, MiB, MB, M, mB, mb, m, GiB, GB, G, gB, gb, g, TiB, TB, PiB, PB, EiB, EB) which is minimum 1.00KiB

Limit the number of IOs the background checkpoint process will consume per second. This setting is advisory, is ignored in Neo4j Community Edition, and is followed to best effort in Enterprise Edition. An IO is in this case a 8 KiB (mostly sequential) write. Limiting the write IO in this way will leave more bandwidth in the IO subsystem to service random-read IOs, which is important for the response time of queries when the database cannot fit entirely in memory. The only drawback of this setting is that longer checkpoint times may lead to slightly longer recovery times in case of a database or system crash. A lower number means lower IO pressure, and consequently longer checkpoint times. Set this to -1 to disable the IOPS limit and remove the limitation entirely; this will let the checkpointer flush data as fast as the hardware will go. Removing the setting, or commenting it out, will set the default value of 600.

dbms.checkpoint.iops.limit, an integer

The catch up protocol times out if the given duration elapses with no network activity. Every message received by the client from the server extends the time out duration.

causal_clustering.catch_up_client_inactivity_timeout, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

The maximum batch size when catching up (in unit of entries)

causal_clustering.catchup_batch_size, an integer

Configure if the dbms.routing.getRoutingTable() procedure should include followers as read endpoints or return only read replicas. Note: if there are no read replicas in the cluster, followers are returned as read end points regardless the value of this setting. Defaults to true so that followers are available for read-only queries in a typical heterogeneous setup.

causal_clustering.cluster_allow_reads_on_followers, a boolean

Configure if the dbms.routing.getRoutingTable() procedure should include the leader as read endpoint or return only read replicas/followers. Note: leader is returned as read endpoint if no other member is present all.

causal_clustering.cluster_allow_reads_on_leader, a boolean

The time allowed for a database on a Neo4j server to either join a cluster or form a new cluster with the other Neo4j Core Servers provided by causal_clustering.initial_discovery_members.

causal_clustering.cluster_binding_timeout, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

Time between scanning the cluster to refresh current server’s view of topology.

causal_clustering.cluster_topology_refresh, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s) which is minimum 1s

Limits amount of global threads for applying commands.

causal_clustering.command_applier_parallelism, an integer which is minimum 1

Comma separated list of groups to be used by the connect-randomly-to-server-group selection strategy. The connect-randomly-to-server-group strategy is used if the list of strategies (causal_clustering.upstream_selection_strategy) includes the value connect-randomly-to-server-group.

causal_clustering.connect_randomly_to_server_group, a ',' separated list with elements of type 'a string identifying a Server Group'.

Deletes the old store (on cores and replicas) before performing a store copy (instead of deleting it after).

causal_clustering.delete_store_before_store_copy, a boolean

Advertised cluster member discovery management communication.

causal_clustering.discovery_advertised_address, a socket address in the format 'hostname:port', 'hostname' or ':port'. If missing port or hostname it is acquired from dbms.default_advertised_address

Host and port to bind the cluster member discovery management communication.

causal_clustering.discovery_listen_address, a socket address in the format 'hostname:port', 'hostname' or ':port'. If missing port or hostname it is acquired from dbms.default_listen_address

Configure the discovery type used for cluster name resolution.

causal_clustering.discovery_type, one of [DNS, LIST, SRV, K8S] which depends on dbms.mode. If dbms.mode one of [CORE, READ_REPLICA] then it may require different settings depending on the discovery type: DNS requires [causal_clustering.initial_discovery_members], LIST requires [causal_clustering.initial_discovery_members], SRV requires [causal_clustering.initial_discovery_members], K8S requires [causal_clustering.kubernetes.label_selector, causal_clustering.kubernetes.service_port_name] otherwise it depends on dbms.mode. If dbms.mode one of [SINGLE] then it depends on dbms.clustering.enable. If dbms.clustering.enable is true then it may require different settings depending on the discovery type: DNS requires [causal_clustering.initial_discovery_members], LIST requires [causal_clustering.initial_discovery_members], SRV requires [causal_clustering.initial_discovery_members], K8S requires [causal_clustering.kubernetes.label_selector, causal_clustering.kubernetes.service_port_name] otherwise it is unconstrained. otherwise it is unconstrained..

The rate at which leader elections happen. Note that due to election conflicts it might take several attempts to find a leader. The window should be significantly larger than typical communication delays to make conflicts unlikely.

causal_clustering.election_failure_detection_window, a duration-range <min-max> (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

Enable pre-voting extension to the Raft protocol (this is breaking and must match between the core cluster members)

causal_clustering.enable_pre_voting, a boolean

The maximum file size before the global session tracker state file is rotated (in unit of entries)

causal_clustering.global_session_tracker_state_size, an integer

Time out for protocol negotiation handshake. This configuration is applicable to: Raft (communication between CORE instances only), Catchup (communication between any instances: CORE → CORE, RR → CORE, RR → RR, CORE → RR, including RR → SINGLE in a replica-only cluster). Backup (communication between any instance and a backup client that lives in the neo4j-admin command, such as BackupClient → SINGLE, BackupClient → CORE, BackupClient → RR).

causal_clustering.handshake_timeout, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

The maximum number of bytes in the in-flight cache. This parameter limits the amount of memory that can be consumed by cache. If the bytes limit is reached, cache size will be limited even if max_entries is not exceeded.

causal_clustering.in_flight_cache.max_bytes, a byte size (valid multipliers are B, KiB, KB, K, kB, kb, k, MiB, MB, M, mB, mb, m, GiB, GB, G, gB, gb, g, TiB, TB, PiB, PB, EiB, EB)

The maximum number of entries in the in-flight cache. Increasing size will require more memory but might improve performance in high load situations.

causal_clustering.in_flight_cache.max_entries, an integer

Type of in-flight cache. CONSECUTIVE should be used for production instances, NONE will disable cache which might be useful in specific support cases. UNBOUNDED is for internal use only.

causal_clustering.in_flight_cache.type, one of [NONE, CONSECUTIVE, UNBOUNDED]

A comma-separated list of other members of the cluster to join.

causal_clustering.initial_discovery_members, a ',' separated list with elements of type 'a socket address in the format 'hostname:port', 'hostname' or ':port''.

Maximum amount of lag accepted for a new follower to join the Raft group.

causal_clustering.join_catch_up_max_lag, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

Time out for a new member to catch up.

causal_clustering.join_catch_up_timeout, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

Address for Kubernetes API.

causal_clustering.kubernetes.address, a socket address in the format 'hostname:port', 'hostname' or ':port'

File location of CA certificate for Kubernetes API.

causal_clustering.kubernetes.ca_crt, a path

Kubernetes cluster domain.

causal_clustering.kubernetes.cluster_domain, a string

LabelSelector for Kubernetes API.

causal_clustering.kubernetes.label_selector, a string

File location of namespace for Kubernetes API.

causal_clustering.kubernetes.namespace, a path

Service port name for discovery for Kubernetes API.

causal_clustering.kubernetes.service_port_name, a string

File location of token for Kubernetes API.

causal_clustering.kubernetes.token, a path

The maximum file size before the storage file is rotated (in unit of entries)

causal_clustering.last_applied_state_size, an integer

This setting is moved and enhanced into causal_clustering.leader_failure_detection_window and causal_clustering.election_failure_detection_window.

causal_clustering.leader_election_timeout, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

The time window within which the loss of the leader is detected and the first re-election attempt is held.The window should be significantly larger than typical communication delays to make conflicts unlikely.

causal_clustering.leader_failure_detection_window, a duration-range <min-max> (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

Which strategy to use when transferring database leaderships around a cluster. This can be one of equal_balancing or no_balancing. equal_balancing automatically ensures that each Core server holds the leader role for an equal number of databases.no_balancing prevents any automatic balancing of the leader role.Note that if a leadership_priority_group is specified for a given database, the value of this setting will be ignored for that database.

causal_clustering.leadership_balancing, one of [NO_BALANCING, EQUAL_BALANCING]

The name of a server_group whose members should be prioritized as leaders. This does not guarantee that members of this group will be leader at all times, but the cluster will attempt to transfer leadership to such a member when possible. If a database is specified using causal_clustering.leadership_priority_group.<database> the specified priority group will apply to that database only. If no database is specified that group will be the default and apply to all databases which have no priority group explicitly set. Using this setting will disable leadership balancing.

causal_clustering.leadership_priority_group, a string identifying a Server Group

The load balancing plugin to use.

causal_clustering.load_balancing.plugin, a string which depends on dbms.mode. If dbms.mode one of [CORE] then it specified load balancer plugin exist. otherwise it is unconstrained.

Enables shuffling of the returned load balancing result.

causal_clustering.load_balancing.shuffle, a boolean

The maximum lag allowed before log shipping pauses (in unit of entries)

causal_clustering.log_shipping_max_lag, an integer

Retry time for log shipping to followers after a stall.

causal_clustering.log_shipping_retry_timeout, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

The maximum number of TCP channels between two nodes to operate the raft protocol. Each database gets allocated one channel, but a single channel can be used by more than one database.

causal_clustering.max_raft_channels, an integer

The level of middleware logging.

causal_clustering.middleware.logging.level, one of [DEBUG, INFO, WARN, ERROR, NONE]

Minimum number of Core machines initially required to form a cluster. The cluster will form when at least this many Core members have discovered each other.

causal_clustering.minimum_core_cluster_size_at_formation, an integer which is minimum 2

The minimum size of the dynamically adjusted voting set (which only core members may be a part of). Adjustments to the voting set happen automatically as the availability of core members changes, due to explicit operations such as starting or stopping a member, or unintended issues such as network partitions. Note that this dynamic scaling of the voting set is generally desirable as under some circumstances it can increase the number of instance failures which may be tolerated. A majority of the voting set must be available before voting in or out members.

causal_clustering.minimum_core_cluster_size_at_runtime, an integer which is minimum 2 and depends on dbms.mode. If dbms.mode one of [CORE] then it must be set less than or equal to value of 'causal_clustering.minimum_core_cluster_size_at_formation' otherwise it is unconstrained.

Enable multi-data center features. Requires appropriate licensing.

causal_clustering.multi_dc_license, a boolean

Catchup protocol implementation versions that this instance will allow in negotiation as a comma-separated list. Order is not relevant: the greatest value will be preferred. An empty list will allow all supported versions. Example value: "1.1, 1.2, 2.1, 2.2"

causal_clustering.protocol_implementations.catchup, a ',' separated list with elements of type 'an application protocol version'.

Network compression algorithms that this instance will allow in negotiation as a comma-separated list. Listed in descending order of preference for incoming connections. An empty list implies no compression. For outgoing connections this merely specifies the allowed set of algorithms and the preference of the remote peer will be used for making the decision. Allowable values: [Gzip, Snappy, Snappy_validating, LZ4, LZ4_high_compression, LZ_validating, LZ4_high_compression_validating]

causal_clustering.protocol_implementations.compression, a ',' separated list with elements of type 'a string'.

Raft protocol implementation versions that this instance will allow in negotiation as a comma-separated list. Order is not relevant: the greatest value will be preferred. An empty list will allow all supported versions. Example value: "1.0, 1.3, 2.0, 2.1"

causal_clustering.protocol_implementations.raft, a ',' separated list with elements of type 'an application protocol version'.

Interval of pulling updates from cores.

causal_clustering.pull_interval, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

Advertised hostname/IP address and port for the RAFT server.

causal_clustering.raft_advertised_address, a socket address in the format 'hostname:port', 'hostname' or ':port'. If missing port or hostname it is acquired from dbms.default_advertised_address

Limits amount of global threads shared by raft groups for handling bathing of messages and timeout events.

causal_clustering.raft_handler_parallelism, an integer which is minimum 1

Largest batch processed by RAFT in bytes.

causal_clustering.raft_in_queue_max_batch_bytes, a byte size (valid multipliers are B, KiB, KB, K, kB, kb, k, MiB, MB, M, mB, mb, m, GiB, GB, G, gB, gb, g, TiB, TB, PiB, PB, EiB, EB)

Maximum number of bytes in the RAFT in-queue.

causal_clustering.raft_in_queue_max_bytes, a byte size (valid multipliers are B, KiB, KB, K, kB, kb, k, MiB, MB, M, mB, mb, m, GiB, GB, G, gB, gb, g, TiB, TB, PiB, PB, EiB, EB)

Network interface and port for the RAFT server to listen on.

causal_clustering.raft_listen_address, a socket address in the format 'hostname:port', 'hostname' or ':port'. If missing port or hostname it is acquired from dbms.default_listen_address

The maximum number of entries in the raft log entry prefetch buffer.

causal_clustering.raft_log_entry_prefetch_buffer.max_entries, an integer

RAFT log implementation.

causal_clustering.raft_log_implementation, a string

RAFT log pruning strategy that determines which logs are to be pruned. Neo4j only prunes log entries up to the last applied index, which guarantees that logs are only marked for pruning once the transactions within are safely copied over to the local transaction logs and safely committed by a majority of cluster members. Possible values are a byte size or a number of transactions (e.g., 200K txs).

causal_clustering.raft_log_prune_strategy, a string

RAFT log pruning frequency.

causal_clustering.raft_log_pruning_frequency, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

RAFT log reader pool size.

causal_clustering.raft_log_reader_pool_size, an integer

RAFT log rotation size.

causal_clustering.raft_log_rotation_size, a byte size (valid multipliers are B, KiB, KB, K, kB, kb, k, MiB, MB, M, mB, mb, m, GiB, GB, G, gB, gb, g, TiB, TB, PiB, PB, EiB, EB) which is minimum 1.00KiB

The maximum file size before the membership state file is rotated (in unit of entries)

causal_clustering.raft_membership_state_size, an integer

The maximum file size before the term state file is rotated (in unit of entries)

causal_clustering.raft_term_state_size, an integer

The maximum file size before the vote state file is rotated (in unit of entries)

causal_clustering.raft_vote_state_size, an integer

Deprecated, use dbms.databases.default_to_read_only

causal_clustering.refuse_to_be_leader, a boolean

dbms.databases.default_to_read_only

The maximum file size before the replicated lease state file is rotated (in unit of entries)

causal_clustering.replicated_lease_state_size, an integer

The duration for which the replicator will await a new leader.

causal_clustering.replication_leader_await_timeout, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

The initial timeout until replication is retried. The timeout will increase exponentially.

causal_clustering.replication_retry_timeout_base, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

The upper limit for the exponentially incremented retry timeout.

causal_clustering.replication_retry_timeout_limit, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

A list of group names for the server used when configuring load balancing and replication policies.

causal_clustering.server_groups, a ',' separated list with elements of type 'a string identifying a Server Group'.

The maximum number of operations to be batched during applications of operations in the state machines.

causal_clustering.state_machine_apply_max_batch_size, an integer

The number of operations to be processed before the state machines flush to disk.

causal_clustering.state_machine_flush_window_size, an integer

Sampling window for throughput estimate reported in the status endpoint.

causal_clustering.status_throughput_window, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s) which is in the range 1s to 5m

Store copy chunk size.

causal_clustering.store_copy_chunk_size, an integer which is in the range 4096 to 1048576

Maximum retry time per request during store copy. Regular store files and indexes are downloaded in separate requests during store copy. This configures the maximum time failed requests are allowed to resend.

causal_clustering.store_copy_max_retry_time_per_request, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

Limits amount of global threads for store copy.

causal_clustering.store_copy_parallelism, an integer which is minimum 1

Advertised hostname/IP address and port for the transaction shipping server.

causal_clustering.transaction_advertised_address, a socket address in the format 'hostname:port', 'hostname' or ':port'. If missing port or hostname it is acquired from dbms.default_advertised_address.

Network interface and port for the transaction shipping server to listen on. Please note that it is also possible to run the backup client against this port so always limit access to it via the firewall and configure an ssl policy.

causal_clustering.transaction_listen_address, a socket address in the format 'hostname:port', 'hostname' or ':port'. If missing port or hostname it is acquired from dbms.default_listen_address

Throttle limit for logging unknown cluster member address.

causal_clustering.unknown_address_logging_throttle, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

An ordered list in descending preference of the strategy which read replicas use to choose the upstream server from which to pull transactional updates.

causal_clustering.upstream_selection_strategy, a ',' separated list with elements of type 'a string'.

Configuration of a user-defined upstream selection strategy. The user-defined strategy is used if the list of strategies (causal_clustering.upstream_selection_strategy) includes the value user_defined.

causal_clustering.user_defined_upstream_strategy, a string

Name of the Fabric database. Only one Fabric database is currently supported per Neo4j instance.

fabric.database.name, A valid database name containing only alphabetic characters, numbers, dots and dashes with a length between 3 and 63 characters, starting with an alphabetic character but not with the name 'system'

Determines which driver API will be used. ASYNC must be used when the remote instance is 3.5.

fabric.driver.api, one of [RX, ASYNC]

Socket connection timeout. A timeout of zero is treated as an infinite timeout and will be bound by the timeout configured on the operating system level.

fabric.driver.connection.connect_timeout, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

Pooled connections older than this threshold will be closed and removed from the pool. Setting this option to a low value will cause a high connection churn and might result in a performance hit. It is recommended to set maximum lifetime to a slightly smaller value than the one configured in network equipment (load balancer, proxy, firewall, etc. can also limit maximum connection lifetime). Zero and negative values result in lifetime not being checked.

fabric.driver.connection.max_lifetime, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

Maximum amount of time spent attempting to acquire a connection from the connection pool. This timeout only kicks in when all existing connections are being used and no new connections can be created because maximum connection pool size has been reached. Error is raised when connection can’t be acquired within configured time. Negative values are allowed and result in unlimited acquisition timeout. Value of 0 is allowed and results in no timeout and immediate failure when connection is unavailable.

fabric.driver.connection.pool.acquisition_timeout, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

Pooled connections that have been idle in the pool for longer than this timeout will be tested before they are used again, to ensure they are still alive. If this option is set too low, an additional network call will be incurred when acquiring a connection, which causes a performance hit. If this is set high, no longer live connections might be used which might lead to errors. Hence, this parameter tunes a balance between the likelihood of experiencing connection problems and performance Normally, this parameter should not need tuning. Value 0 means connections will always be tested for validity.

fabric.driver.connection.pool.idle_test, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

Maximum total number of connections to be managed by a connection pool. The limit is enforced for a combination of a host and user. Negative values are allowed and result in unlimited pool. Value of 0 is not allowed.

fabric.driver.connection.pool.max_size, an integer

Sets level for driver internal logging.

fabric.driver.logging.level, one of [DEBUG, INFO, WARN, ERROR, NONE]

Name of the database associated to the Fabric graph.

fabric.graph.<graph ID>.database, a string

Determines which driver API will be used. ASYNC must be used when the remote instance is 3.5 This setting can be used as a graph-specific override of the global setting 'fabric.driver.api'

fabric.graph.<graph ID>.driver.api, one of [RX, ASYNC]

Socket connection timeout. A timeout of zero is treated as an infinite timeout and will be bound by the timeout configured on the operating system level. This setting can be used as a graph-specific override of the global setting 'fabric.driver.connection.connect_timeout'

fabric.graph.<graph ID>.driver.connection.connect_timeout, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

Pooled connections older than this threshold will be closed and removed from the pool. Setting this option to a low value will cause a high connection churn and might result in a performance hit. It is recommended to set maximum lifetime to a slightly smaller value than the one configured in network equipment (load balancer, proxy, firewall, etc. can also limit maximum connection lifetime). Zero and negative values result in lifetime not being checked. This setting can be used as a graph-specific override of the global setting 'fabric.driver.connection.max_lifetime'

fabric.graph.<graph ID>.driver.connection.max_lifetime, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

Maximum amount of time spent attempting to acquire a connection from the connection pool. This timeout only kicks in when all existing connections are being used and no new connections can be created because maximum connection pool size has been reached. Error is raised when connection can’t be acquired within configured time. Negative values are allowed and result in unlimited acquisition timeout. Value of 0 is allowed and results in no timeout and immediate failure when connection is unavailable. This setting can be used as a graph-specific override of the global setting 'fabric.driver.connection.pool.acquisition_timeout'

fabric.graph.<graph ID>.driver.connection.pool.acquisition_timeout, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

Pooled connections that have been idle in the pool for longer than this timeout will be tested before they are used again, to ensure they are still alive. If this option is set too low, an additional network call will be incurred when acquiring a connection, which causes a performance hit. If this is set high, no longer live connections might be used which might lead to errors. Hence, this parameter tunes a balance between the likelihood of experiencing connection problems and performance Normally, this parameter should not need tuning. Value 0 means connections will always be tested for validity. This setting can be used as a graph-specific override of the global setting 'fabric.driver.connection.pool.idle_test'

fabric.graph.<graph ID>.driver.connection.pool.idle_test, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

Maximum total number of connections to be managed by a connection pool. The limit is enforced for a combination of a host and user. Negative values are allowed and result in unlimited pool. Value of 0 is not allowed. This setting can be used as a graph-specific override of the global setting 'fabric.driver.connection.pool.max_size'

fabric.graph.<graph ID>.driver.connection.pool.max_size, an integer

Enables logging of leaked driver session.

fabric.graph.<graph ID>.driver.logging.leaked_sessions, a boolean

Sets level for driver internal logging. This setting can be used as a graph-specific override of the global setting 'fabric.driver.logging.level'

fabric.graph.<graph ID>.driver.logging.level, one of [DEBUG, INFO, WARN, ERROR, NONE]

SSL for Fabric drivers is configured using 'fabric' SSL policy.This setting can be used to instruct the driver not to use SSL even though 'fabric' SSL policy is configured.The driver will use SSL if 'fabric' SSL policy is configured and this setting is set to 'true'

fabric.graph.<graph ID>.driver.ssl_enabled, a boolean

Name assigned to the Fabric graph. The name can be used in Fabric queries.

fabric.graph.<graph ID>.name, A valid graph name. Containing only alphabetic characters, numbers, dots and dashes, with a length between 3 and 63 characters. It should be starting with an alphabetic character. The name 'graph' is reserved.

URI of the Neo4j DBMS hosting the database associated to the Fabric graph. Example: neo4j://somewhere:7687 A comma separated list of URIs is acceptable. This is useful when the Fabric graph is hosted on a cluster and more that one bootstrap address needs to be provided in order to avoid a single point of failure. The provided addresses will be considered as an initial source of a routing table. Example: neo4j://core-1:1111,neo4j://core-2:2222.

fabric.graph.<graph ID>.uri, a ',' separated list with elements of type 'a URI'.

A comma-separated list of Fabric instances that form a routing group. A driver will route transactions to available routing group members. A Fabric instance is represented by its Bolt connector address.

fabric.routing.servers, a ',' separated list with elements of type 'a socket address in the format 'hostname:port', 'hostname' or ':port''.

The time to live (TTL) of a routing table for fabric routing group.

fabric.routing.ttl, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

Number of records in prefetching buffer that will trigger prefetching again. This is strongly related to fabric.stream.buffer.size

fabric.stream.buffer.low_watermark, an integer which is minimum 0

Maximal size of a buffer used for pre-fetching result records of remote queries. To compensate for latency to remote databases, the Fabric execution engine pre-fetches records needed for local executions. This limit is enforced per fabric query. If a fabric query uses multiple remote stream at the same time, this setting represents the maximal number of pre-fetched records counted together for all such remote streams.

fabric.stream.buffer.size, an integer which is minimum 1

Maximal concurrency within Fabric queries. Limits the number of iterations of each subquery that are executed concurrently. Higher concurrency may consume more memory and network resources simultaneously, while lower concurrency may force sequential execution, requiring more time.

fabric.stream.concurrency, an integer which is minimum 1

Default hostname or IP address the server uses to advertise itself.

dbms.default_advertised_address, a socket address in the format 'hostname:port', 'hostname' or ':port' which has no specified port

Default network interface to listen for incoming connections. To listen for connections on all interfaces, use "0.0.0.0".

dbms.default_listen_address, a socket address in the format 'hostname:port', 'hostname' or ':port' which has no specified port

Defines the set of modules loaded into the Neo4j web server. Options include TRANSACTIONAL_ENDPOINTS, BROWSER, UNMANAGED_EXTENSIONS and ENTERPRISE_MANAGEMENT_ENDPOINTS (if applicable).

dbms.http_enabled_modules, a ',' separated set with elements of type 'one of [TRANSACTIONAL_ENDPOINTS, UNMANAGED_EXTENSIONS, BROWSER, ENTERPRISE_MANAGEMENT_ENDPOINTS]'.

The advertised address for the intra-cluster routing connector.

dbms.routing.advertised_address, a socket address in the format 'hostname:port', 'hostname' or ':port'. If missing port or hostname it is acquired from dbms.default_advertised_address

Always use client side routing (regardless of the default router) for neo4j:// protocol connections to these domains. A comma-separated list of domains. Wildcards (*) are supported.

dbms.routing.client_side.enforce_for_domains, a ',' separated set with elements of type 'a string'.

Routing strategy for neo4j:// protocol connections. Default is CLIENT, using client-side routing, with server-side routing as a fallback (if enabled). When set to SERVER, client-side routing is short-circuited, and requests will rely on server-side routing (which must be enabled for proper operation, i.e. dbms.routing.enabled=true). Can be overridden by dbms.routing.client_side.enforce_for_domains.

dbms.routing.default_router, one of [SERVER, CLIENT]

Determines which driver API will be used. ASYNC must be used when the remote instance is 3.5, but is only retained for backwards-compatibility reasons. RX should be used in all other cases.

dbms.routing.driver.api, one of [RX, ASYNC]

Socket connection timeout. A timeout of zero is treated as an infinite timeout and will be bound by the timeout configured on the operating system level.

dbms.routing.driver.connection.connect_timeout, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

Pooled connections older than this threshold will be closed and removed from the pool. Setting this option to a low value will cause a high connection churn and might result in a performance hit. It is recommended to set maximum lifetime to a slightly smaller value than the one configured in network equipment (load balancer, proxy, firewall, etc. can also limit maximum connection lifetime). Zero and negative values result in lifetime not being checked.

dbms.routing.driver.connection.max_lifetime, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

Maximum amount of time spent attempting to acquire a connection from the connection pool. This timeout only kicks in when all existing connections are being used and no new connections can be created because maximum connection pool size has been reached. Error is raised when connection can’t be acquired within configured time. Negative values are allowed and result in unlimited acquisition timeout. Value of 0 is allowed and results in no timeout and immediate failure when connection is unavailable.

dbms.routing.driver.connection.pool.acquisition_timeout, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

Pooled connections that have been idle in the pool for longer than this timeout will be tested before they are used again, to ensure they are still alive. If this option is set too low, an additional network call will be incurred when acquiring a connection, which causes a performance hit. If this is set high, no longer live connections might be used which might lead to errors. Hence, this parameter tunes a balance between the likelihood of experiencing connection problems and performance Normally, this parameter should not need tuning. Value 0 means connections will always be tested for validity.

dbms.routing.driver.connection.pool.idle_test, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

Maximum total number of connections to be managed by a connection pool. The limit is enforced for a combination of a host and user. Negative values are allowed and result in unlimited pool. Value of 0 is not allowed.

dbms.routing.driver.connection.pool.max_size, an integer

Sets level for driver internal logging.

dbms.routing.driver.logging.level, one of [DEBUG, INFO, WARN, ERROR, NONE]

Enable server-side routing in clusters using an additional bolt connector. When configured, this allows requests to be forwarded from one cluster member to another, if the requests can’t be satisfied by the first member (e.g. write requests received by a non-leader).

dbms.routing.enabled, a boolean

The address the routing connector should bind to.

dbms.routing.listen_address, a socket address in the format 'hostname:port', 'hostname' or ':port'. If missing port or hostname it is acquired from dbms.default_listen_address

How long callers should cache the response of the routing procedure dbms.routing.getRoutingTable()

dbms.routing_ttl, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s) which is minimum 1s

Advertised address for this connector.

dbms.connector.bolt.advertised_address, a socket address in the format 'hostname:port', 'hostname' or ':port'. If missing port or hostname it is acquired from dbms.default_advertised_address

The maximum time to wait before sending a NOOP on connections waiting for responses from active ongoing queries.The minimum value is 1 millisecond.

dbms.connector.bolt.connection_keep_alive, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s) which is minimum 1ms

The type of messages to enable keep-alive messages for (ALL, STREAMING or OFF)

dbms.connector.bolt.connection_keep_alive_for_requests, one of [ALL, STREAMING, OFF]

The total amount of probes to be missed before a connection is considered stale.The minimum for this value is 1.

dbms.connector.bolt.connection_keep_alive_probes, an integer which is minimum 1

The interval between every scheduled keep-alive check on all connections with active queries. Zero duration turns off keep-alive service.

dbms.connector.bolt.connection_keep_alive_streaming_scheduling_interval, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s) which is minimum 0s

Enable the bolt connector.

dbms.connector.bolt.enabled, a boolean

Address the connector should bind to.

dbms.connector.bolt.listen_address, a socket address in the format 'hostname:port', 'hostname' or ':port'. If missing port or hostname it is acquired from dbms.default_listen_address

Enable server OCSP stapling for bolt and http connectors.

dbms.connector.bolt.ocsp_stapling_enabled, a boolean

The maximum time an idle thread in the thread pool bound to this connector will wait for new tasks.

dbms.connector.bolt.thread_pool_keep_alive, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

The maximum number of threads allowed in the thread pool bound to this connector.

dbms.connector.bolt.thread_pool_max_size, an integer

The number of threads to keep in the thread pool bound to this connector, even if they are idle.

dbms.connector.bolt.thread_pool_min_size, an integer

Encryption level to require this connector to use.

dbms.connector.bolt.tls_level, one of [REQUIRED, OPTIONAL, DISABLED]

The maximum time to wait for the thread pool to finish processing its pending jobs and shutdown.

dbms.connector.bolt.unsupported_thread_pool_shutdown_wait_time, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

Advertised address for this connector.

dbms.connector.http.advertised_address, a socket address in the format 'hostname:port', 'hostname' or ':port'. If missing port or hostname it is acquired from dbms.default_advertised_address

Enable the http connector.

dbms.connector.http.enabled, a boolean

Address the connector should bind to.

dbms.connector.http.listen_address, a socket address in the format 'hostname:port', 'hostname' or ':port'. If missing port or hostname it is acquired from dbms.default_listen_address

Advertised address for this connector.

dbms.connector.https.advertised_address, a socket address in the format 'hostname:port', 'hostname' or ':port'. If missing port or hostname it is acquired from dbms.default_advertised_address

Enable the https connector.

dbms.connector.https.enabled, a boolean

Address the connector should bind to.

dbms.connector.https.listen_address, a socket address in the format 'hostname:port', 'hostname' or ':port'. If missing port or hostname it is acquired from dbms.default_listen_address

Set this to specify the default parser (language version).

cypher.default_language_version, one of [default, 3.5, 4.3, 4.4]

This setting is associated with performance optimization. Set this to true in situations where it is preferable to have any queries using the 'shortestPath' function terminate as soon as possible with no answer, rather than potentially running for a long time attempting to find an answer (even if there is no path to be found). For most queries, the 'shortestPath' algorithm will return the correct answer very quickly. However there are some cases where it is possible that the fast bidirectional breadth-first search algorithm will find no results even if they exist. This can happen when the predicates in the WHERE clause applied to 'shortestPath' cannot be applied to each step of the traversal, and can only be applied to the entire path. When the query planner detects these special cases, it will plan to perform an exhaustive depth-first search if the fast algorithm finds no paths. However, the exhaustive search may be orders of magnitude slower than the fast algorithm. If it is critical that queries terminate as soon as possible, it is recommended that this option be set to true, which means that Neo4j will never consider using the exhaustive search for shortestPath queries. However, please note that if no paths are found, an error will be thrown at run time, which will need to be handled by the application.

cypher.forbid_exhaustive_shortestpath, a boolean

This setting is associated with performance optimization. The shortest path algorithm does not work when the start and end nodes are the same. With this setting set to false no path will be returned when that happens. The default value of true will instead throw an exception. This can happen if you perform a shortestPath search after a cartesian product that might have the same start and end nodes for some of the rows passed to shortestPath. If it is preferable to not experience this exception, and acceptable for results to be missing for those rows, then set this to false. If you cannot accept missing results, and really want the shortestPath between two common nodes, then re-write the query using a standard Cypher variable length pattern expression followed by ordering by path length and limiting to one result.

cypher.forbid_shortestpath_common_nodes, a boolean

Set this to specify the behavior when Cypher planner or runtime hints cannot be fulfilled. If true, then non-conformance will result in an error, otherwise only a warning is generated.

cypher.hints_error, a boolean

Set this to change the behavior for Cypher create relationship when the start or end node is missing. By default this fails the query and stops execution, but by setting this flag the create operation is simply not performed and execution continues.

cypher.lenient_create_relationship, a boolean

The minimum time between possible cypher query replanning events. After this time, the graph statistics will be evaluated, and if they have changed by more than the value set by cypher.statistics_divergence_threshold, the query will be replanned. If the statistics have not changed sufficiently, the same interval will need to pass before the statistics will be evaluated again. Each time they are evaluated, the divergence threshold will be reduced slightly until it reaches 10% after 7h, so that even moderately changing databases will see query replanning after a sufficiently long time interval.

cypher.min_replan_interval, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

Set this to specify the default planner for the default language version.

cypher.planner, one of [DEFAULT, COST]

The threshold for statistics above which a plan is considered stale.

If any of the underlying statistics used to create the plan have changed more than this value, the plan will be considered stale and will be replanned. Change is calculated as abs(a-b)/max(a,b).

This means that a value of 0.75 requires the database to quadruple in size before query replanning. A value of 0 means that the query will be replanned as soon as there is any change in statistics and the replan interval has elapsed.

This interval is defined by cypher.min_replan_interval and defaults to 10s. After this interval, the divergence threshold will slowly start to decline, reaching 10% after about 7h. This will ensure that long running databases will still get query replanning on even modest changes, while not replanning frequently unless the changes are very large.

cypher.statistics_divergence_threshold, a double which is in the range 0.0 to 1.0

Allows the enabling or disabling of the file watcher service. This is an auxiliary service but should be left enabled in almost all cases.

dbms.filewatcher.enabled, a boolean

Database record format. Valid values are blank(no value, default), standard, aligned, or high_limit. Specifying a value will force new databases to that format and existing databases to migrate if dbms.allow_upgrade=true is specified. The aligned format is essentially the standard format with some minimal padding at the end of pages such that a single record will never cross a page boundary. The high_limit format is available for Enterprise Edition only. It is required if you have a graph that is larger than 34 billion nodes, 34 billion relationships, or 68 billion properties. A change of the record format is irreversible. Certain operations may suffer from a performance penalty of up to 10%, which is why this format is not switched on by default. However, if you want to change the configured record format value, you must also set dbms.allow_upgrade=true, because the setting implies a one-way store format migration.

dbms.record_format, a string

Relationship count threshold for considering a node to be dense.

dbms.relationship_grouping_threshold, an integer which is minimum 1

Specify if Neo4j should try to preallocate store files as they grow.

dbms.store.files.preallocate, a boolean

Database timezone for temporal functions. All Time and DateTime values that are created without an explicit timezone will use this configured default timezone.

db.temporal.timezone, a string describing a timezone, either described by offset (e.g. +02:00) or by name (e.g. Europe/Stockholm)

Enables or disables tracking of how much time a query spends actively executing on the CPU. Calling dbms.listQueries will display the time.
This can also be logged in the query log by using dbms.logs.query.time_logging_enabled. .

dbms.track_query_cpu_time, a boolean

Enables or disables tracking of how many bytes are allocated by the execution of a query. If enabled, calling dbms.listQueries will display the allocated bytes. This can also be logged in the query log by using dbms.logs.query.allocation_logging_enabled.

dbms.track_query_allocation, a boolean

Enable support for running online backups.

dbms.backup.enabled, a boolean

Strategy for incremental backup. START_TIME means that this server will send transactions until the time of when the backup started has been reached. UNBOUNDED will keep sending until all committed transactions have been sent, even if they where committed after the backup job started.

dbms.backup.incremental.strategy, one of [UNBOUNDED, START_TIME]

Network interface and port for the backup server to listen on.

dbms.backup.listen_address, a socket address in the format 'hostname:port', 'hostname' or ':port'

A strict configuration validation will prevent the database from starting up if unknown configuration options are specified in the neo4j settings namespace (such as dbms., cypher., etc).

dbms.config.strict_validation, a boolean

Whether or not any database on this instance are read_only by default. If false, individual databases may be marked as read_only using dbms.database.read_only. If true, individual databases may be marked as writable using dbms.databases.writable.

dbms.databases.default_to_read_only, a boolean

List of databases for which to prevent write queries. Databases not included in this list maybe read_only anyway depending upon the value of dbms.databases.default_to_read_only.

dbms.databases.read_only, a ',' separated set with elements of type 'A valid database name containing only alphabetic characters, numbers, dots and dashes with a length between 3 and 63 characters, starting with an alphabetic character but not with the name 'system''. which Value 'system' can’t be included in read only databases collection!

List of databases for which to allow write queries. Databases not included in this list will allow write queries anyway, unless dbms.databases.default_to_read_only is set to true.

dbms.databases.writable, a ',' separated set with elements of type 'A valid database name containing only alphabetic characters, numbers, dots and dashes with a length between 3 and 63 characters, starting with an alphabetic character but not with the name 'system''.

A list of setting name patterns (comma separated) that are allowed to be dynamically changed. The list may contain both full setting names, and partial names with the wildcard '*'. If this setting is left empty all dynamic settings updates will be blocked.

dbms.dynamic.setting.allowlist, a ',' separated list with elements of type 'a string'.

A list of setting name patterns (comma separated) that are allowed to be dynamically changed. The list may contain both full setting names, and partial names with the wildcard '*'. If this setting is left empty all dynamic settings updates will be blocked.

dbms.dynamic.setting.whitelist, a ',' separated list with elements of type 'a string'.

dbms.dynamic.setting.allowlist

Additional JVM arguments. Argument order can be significant. To use a Java commercial feature, the argument to unlock commercial features must precede the argument to enable the specific feature in the config value string.

dbms.jvm.additional, one or more jvm arguments

If there is a Database Management System Panic (an irrecoverable error) should the neo4j process shut down or continue running. Following a DbMS panic it is likely that a significant amount of functionality will be lost. Recovering full functionality will require a Neo4j restart. This feature is available in Neo4j Enterprise Edition.

dbms.panic.shutdown_on_panic, a boolean

Number of Neo4j worker threads. This setting is only valid for REST, and does not influence bolt-server. It sets the amount of worker threads for the Jetty server used by neo4j-server. This option can be tuned when you plan to execute multiple, concurrent REST requests, with the aim of getting more throughput from the database. Your OS might enforce a lower limit than the maximum value specified here.

dbms.threads.worker_count, an integer which is in the range 1 to 44738

Comma-separated list of <classname>=<mount point> for unmanaged extensions.

dbms.unmanaged_extension_classes, a ',' separated list with elements of type '<classname>=<mount point> string'.

Max number of processors used when upgrading the store. Defaults to the number of processors available to the JVM. There is a certain amount of minimum threads needed so for that reason there is no lower bound for this value. For optimal performance this value shouldn’t be greater than the number of available processors.

dbms.upgrade_max_processors, an integer which is minimum 0

Name of the Windows Service managing Neo4j when installed using neo4j install-service. Only applicable on Windows OS. Note: This must be unique for each individual installation.

dbms.windows_service_name, a string

Name of the default database (aliases are not supported).

dbms.default_database, A valid database name containing only alphabetic characters, numbers, dots and dashes with a length between 3 and 63 characters, starting with an alphabetic character but not with the name 'system'

Database timezone. Among other things, this setting influences which timezone the logs and monitoring procedures use.

dbms.db.timezone, one of [UTC, SYSTEM]

The maximum number of databases.

dbms.max_databases, a long which is minimum 2

Configure the operating mode of the database — 'SINGLE' for stand-alone operation, 'CORE' for operating as a core member of a Causal Cluster, or 'READ_REPLICA' for operating as a read replica member of a Causal Cluster. Only SINGLE mode is allowed in Community.

dbms.mode, one of [SINGLE, CORE, READ_REPLICA]

Only allow read operations from this Neo4j instance. This mode still requires write access to the directory for lock purposes.

dbms.read_only, a boolean

dbms.databases.default_to_read_only, dbms.databases.read_only, dbms.databases.writable

Enable discovery service and a catchup server to be started on an Enterprise Standalone Instance 'dbms.mode=SINGLE', and with that allow for Read Replicas to connect and pull transaction from it. When 'dbms.mode' is clustered (CORE, READ_REPLICA) this setting is not recognized.

dbms.clustering.enable, a boolean

Whether to allow a system graph upgrade to happen automatically in single instance mode (dbms.mode=SINGLE). Default is true. In clustering environments no automatic upgrade will happen (dbms.mode=CORE or dbms.mode=READ_REPLICA). If set to false, or when in a clustering environment, it is necessary to call the procedure dbms.upgrade() to complete the upgrade.

dbms.allow_single_automatic_upgrade, a boolean

Whether to allow a store upgrade in case the current version of the database starts against an older version of the store.

dbms.allow_upgrade, a boolean

Defines the maximum amount of time to wait before retrying after the dbms fails to reconcile a database to its desired state.

dbms.reconciler.max_backoff, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s) which is minimum 1m

Defines the level of parallelism employed by the reconciler. By default the parallelism equals the number of available processors or 8 (whichever is smaller). If configured as 0, the parallelism of the reconciler will be unbounded.

dbms.reconciler.max_parallelism, an integer which is minimum 0

Defines whether the dbms may retry reconciling a database to its desired state.

dbms.reconciler.may_retry, a boolean

Defines the minimum amount of time to wait before retrying after the dbms fails to reconcile a database to its desired state.

dbms.reconciler.min_backoff, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s) which is minimum 1s

Directory to hold cluster state including Raft log.

dbms.directories.cluster_state, a path. If relative it is resolved from dbms.directories.data

Path of the data directory. You must not configure more than one Neo4j installation to use the same data directory.

dbms.directories.data, a path. If relative it is resolved from dbms.directories.neo4j_home

Root location where Neo4j will store database dumps optionally produced when dropping said databases.

dbms.directories.dumps.root, a path. If relative it is resolved from dbms.directories.data

Sets the root directory for file URLs used with the Cypher LOAD CSV clause. This should be set to a directory relative to the Neo4j installation path, restricting access to only those files within that directory and its subdirectories. For example the value "import" will only enable access to files within the 'import' folder. Removing this setting will disable the security feature, allowing all files in the local system to be imported. Setting this to an empty field will allow access to all files within the Neo4j installation folder.

dbms.directories.import, a path. If relative it is resolved from dbms.directories.neo4j_home

Path of the lib directory.

dbms.directories.lib, a path. If relative it is resolved from dbms.directories.neo4j_home

Path of the licenses directory.

dbms.directories.licenses, a path. If relative it is resolved from dbms.directories.neo4j_home

Path of the logs directory.

dbms.directories.logs, a path. If relative it is resolved from dbms.directories.neo4j_home

The target location of the CSV files: a path to a directory wherein a CSV file per reported field will be written.

dbms.directories.metrics, a path. If relative it is resolved from dbms.directories.neo4j_home

Root relative to which directory settings are resolved.

dbms.directories.neo4j_home, a path which is absolute

Location of the database plugin directory. Compiled Java JAR files that contain database procedures will be loaded if they are placed in this directory.

dbms.directories.plugins, a path. If relative it is resolved from dbms.directories.neo4j_home

Path of the run directory. This directory holds Neo4j’s runtime state, such as a pidfile when it is running in the background. The pidfile is created when starting neo4j and removed when stopping it. It may be placed on an in-memory filesystem such as tmpfs.

dbms.directories.run, a path. If relative it is resolved from dbms.directories.neo4j_home

Root location where Neo4j will store scripts for configured databases.

dbms.directories.script.root, a path. If relative it is resolved from dbms.directories.data

Root location where Neo4j will store transaction logs for configured databases.

dbms.directories.transaction.logs.root, a path. If relative it is resolved from dbms.directories.data

The size of the internal buffer in bytes used by LOAD CSV. If the csv file contains huge fields this value may have to be increased.

dbms.import.csv.buffer_size, a long which is minimum 1

Selects whether to conform to the standard https://tools.ietf.org/html/rfc4180 for interpreting escaped quotation characters in CSV files loaded using LOAD CSV. Setting this to false will use the standard, interpreting repeated quotes '""' as a single in-lined quote, while true will use the legacy convention originally supported in Neo4j 3.0 and 3.1, allowing a backslash to include quotes in-lined in fields.

dbms.import.csv.legacy_quote_escaping, a boolean

Index provider to use for newly created schema indexes. An index provider may store different value types in separate physical indexes. native-btree-1.0: All value types and arrays of all value types, even composite keys, are stored in one native index. lucene+native-3.0: Like native-btree-1.0 but single property strings are stored in Lucene. A native index has faster updates, less heap and CPU usage compared to a Lucene index. A native index has some limitations around key size and slower execution of CONTAINS and ENDS WITH string index queries, compared to a Lucene index. Deprecated: Which index provider to use will be a fully internal concern.

dbms.index.default_schema_provider, a string

The name of the analyzer that the fulltext indexes should use by default.

dbms.index.fulltext.default_analyzer, a string

Whether or not fulltext indexes should be eventually consistent by default or not.

dbms.index.fulltext.eventually_consistent, a boolean

The eventually_consistent mode of the fulltext indexes works by queueing up index updates to be applied later in a background thread. This newBuilder sets an upper bound on how many index updates are allowed to be in this queue at any one point in time. When it is reached, the commit process will slow down and wait for the index update applier thread to make some more room in the queue.

dbms.index.fulltext.eventually_consistent_index_update_queue_max_length, an integer which is in the range 1 to 50000000

Enable or disable background index sampling.

dbms.index_sampling.background_enabled, a boolean

Index sampling chunk size limit.

dbms.index_sampling.sample_size_limit, an integer which is in the range 1048576 to 2147483647

Percentage of index updates of total index size required before sampling of a given index is triggered.

dbms.index_sampling.update_percentage, an integer which is minimum 0

The maximum number of open Lucene index searchers.

dbms.index_searcher_cache_size, an integer which is minimum 1

Log format to use for debug log.

dbms.logs.debug.format, one of [PLAIN, JSON]. If unset the value is inherited from dbms.logs.default_format

Debug log level threshold.

dbms.logs.debug.level, one of [DEBUG, INFO, WARN, ERROR, NONE]

Path to the debug log file.

dbms.logs.debug.path, a path. If relative it is resolved from dbms.directories.logs

Minimum time interval after last rotation of the debug log before it may be rotated again.

dbms.logs.debug.rotation.delay, a duration (Valid units are: ns, μs, ms, s, m, h and d; default unit is s)

Maximum number of history files for the debug log.

dbms.logs.debug.rotation.keep_number, an integer which is minimum 1

Threshold for rotation of the debug log.

dbms.logs.debug.rotation.size, a byte size (valid multipliers are B, KiB, KB, K, kB, kb, k, MiB, MB, M, mB, mb, m, GiB, GB, G, gB, gb, g, TiB, TB, PiB, PB, EiB, EB) which is in the range 0B to 8388608.00TiB

Default log format. Will apply to all logs unless overridden.

dbms.logs.default_format, one of [PLAIN, JSON]

Enable GC Logging.

dbms.logs.gc.enabled, a boolean

GC Logging Options.

dbms.logs.gc.options, a string

Number of GC logs to keep.

dbms.logs.gc.rotation.keep_number, an integer

Size of each GC log that is kept.

dbms.logs.gc.rotation.size, a byte size (valid multipliers are B, KiB, KB, K, kB, kb, k, MiB, MB, M, mB, mb, m, GiB, GB, G, gB, gb, g, TiB, TB, PiB, PB, EiB, EB)

Enable HTTP request logging.

dbms.logs.http.enabled, a boolean

Log format to use for http logs.

dbms.logs.http.format, one of [PLAIN, JSON]. If unset the value is inherited from dbms.logs.default_format

Path to HTTP request log.

dbms.logs.http.path, a path. If relative it is resolved from dbms.directories.logs