Working parameters

Working parameters are the settings that tune the behavior of the application server mechanisms: connection pools, optimizer statistics, thresholds protecting against overly large or overly long queries, retry policy for conflicts and deadlocks, materialization of changes, memory-consumption measurements, form-element display, and so on. Unlike launch parameters, which are fixed for the server process, a working parameter is set through the layers listed below and can be overridden while the system is running, including for an individual user role. Most working parameters take effect as soon as the value changes; individual ones are read only while the system is starting, which is stated in the parameter's description.

The platform working parameters can be set in one of the following ways (in the order of their priorities, higher priority at the bottom):

• In Java code in the lsfusion.server.physics.admin.Settings.java file (relevant for platform forks)
• In lsfusion.properties which are typically part of the project and therefore function for all installations by default - parameter name should start with settings (e.g., settings.enableUI)
• In conf/settings.properties (for specific installations) - parameter name should start with settings
• In environment variables - the variable name is SETTINGS_<PARAMETER NAME> (e.g., SETTINGS_ENABLEUI)
• In Java startup parameters - parameter name should start with D prefix plus settings (e.g., -Dsettings.enableUI=2)
• In the database: Administration > System > Settings > Parameters. In this interface, you can set both global settings and settings for specific roles
• During the execution of an action using system actions: Service.pushSetting[STRING, STRING], Service.popSetting[STRING] (overriding the value of the property for the entire current thread).

Any parameter of the settings class can be set through the files, the environment variables and the startup parameters; a key with the settings prefix that matches no parameter is ignored, in a file or in the startup parameters, with a warning in the log at startup. Before version 7.0 only the parameters listed in the platform configuration lsfusion.xml could be set this way, and the other keys were ignored silently.

Parameters that control query execution (for example, the timeouts of the query materialization mechanism) do not take effect for already compiled queries: the execution state computed for a query — its statement timeouts and materialization steps — is cached together with the query in the compiled-query cache, so a changed parameter applies only to newly compiled queries. Constant literals are parameterized during compilation, so a query differing only in a literal reuses the already compiled query as well. When experimenting with such parameters, combine Service.pushSetting[STRING, STRING] / Service.popSetting[STRING] with dropping the caches, so that the queries are recompiled with the new values — both after the change and after restoring the previous ones: Service.dropLRUCustom[DOUBLE, BOOLEAN] (the percentage to drop and the random-drop flag), or Service.dropLRU[], which takes them from Service.dropLRUPercent[] / Service.randomDropLRU[] and does nothing while the percentage is empty.

The table below does not list every field of the settings class: the parameters of a particular mechanism are described together with that mechanism (for example, the thresholds of the selection element in the interactive view), and the internal parameters of the platform mechanisms, such as the heuristics of the query optimizer or of the cache size control, are not described at all.

	Parameter Type	Description	Default
enableUI	byte	Determines user interface access, including form api 2 - Allow anonymous access 1 - Allow authenticated access only 0 - Do not allow access In development mode 2 is always used and the value set for the parameter is ignored. That mode turns itself on when the server is started with the plugin connected and -Dlsfusion.server.devmode is not set explicitly. Besides the navigator and the form api, the value is also checked for interactive actions invoked through the program interface, on top of enableAPI. A value of 2 additionally offers anonymous entry on the web client's login page.	1
enableAPI	byte	Determines access to the program interface excluding form api 2 - Allow anonymous access 1 - Allow authenticated access only 0 - Disable access by default. At this value, external requests are still allowed for @@noauth actions, for authenticated requests to @@api actions, and for authenticated users who have access to the System.interpreter navigator form. In development mode 2 is always used and the value set for the parameter is ignored. That mode turns itself on when the server is started with the plugin connected and -Dlsfusion.server.devmode is not set explicitly. Whatever the value, the check is skipped for a request carrying a valid signature. The value is read with the override for the user role applied. Besides the check at action level it is read before authentication when interpreter requests are handled: an anonymous request gets through only at 2, while 0 and 1 both return a demand to authenticate.	0
freeConnections	int	Maximum number of connections in the connection pool on the application server	12
enableCloseThreadLocalSqlInNativeThreads	boolean	Whether to close a database connection that stayed bound to a thread the platform did not create - a thread of the remote call pool, of the web server, of a timer. The platform does not control such threads and does not know when they end, so by default the connection is closed as soon as the top-level call in that thread finishes, and the next call opens it again. A value of false leaves the connection hanging in the thread until its next use; turning it off is worth doing only for diagnostics	true
statDegree	int	The base used to estimate the number of records (statistics) by all optimizers. With that, optimizers consider any number of records equal to the specified base to a certain degree (for example, if the number of records is really 1000 and the base is 5, then the optimizer considers the number of records equal to 5 to the 4th degree). Thus, the larger the base, the less accurate the statistics become, which means the compilation time, the size of the caches and generated requests are reduced, but this can significantly increase the likelihood of errors when building the correct query plan.	5
authTokenExpiration	int	Authentication token expiration time in minutes.	60*24 (1 day)
oauthAccessTokenExpiration oauthRefreshTokenExpiration oauthAuthCodeExpiration	int int int	Lifetimes (in minutes) of the access token, the refresh token and the authorization code issued by the built-in OAuth authorization server; used while the properties of the same names in the Authentication module (Authentication.oauthAccessTokenExpiration[] and so on, set in the authentication settings form) are NULL.	60 60*24*30 (30 days) 10
reserveIDStep	int	The number of IDs that the application server immediately reserves for optimization when performing single object adding operations (with asynchronous input, single NEW, etc.)	50
queryLengthTimeout	int	Parameters of the query materialization mechanism. queryLengthTimeout defines the minimum query length for which the mechanism is enabled	1000
defaultTypeExecuteEnvironment	int	The query execution environment applied to a user for whom it is not chosen explicitly by the execEnv[User] property (see Service). 2 is materialization: a query that failed or did not fit into its timeout gradually materializes its subqueries on a retry; 1 turns nested loops off for the session; 0 means no adjustment. Any other value silently means 0. The parameter does not apply to queries shorter than queryLengthTimeout - those run with no adjustment in any case	2
useRequestTimeout	boolean	Enables the mechanism for repeated remote calls if these calls take too long. It is necessary for resolving situations when a call is made on the server, but the response is lost due to network problems. The latter usually happens when the application server is running in a virtualized environment. Thus, in this case, it is recommended to enable this setting and disable it in the opposite case.	true
deleteFromInsteadOfTruncateForTempTablesInTransactionThreshold	int	The number of rows below which a temporary table given back inside a transaction is emptied with DELETE rather than TRUNCATE, which inside a transaction holds an exclusive lock on it until the commit. The rows the earlier emptyings of that table left dead count towards the same threshold, since nothing reclaims them until its storage is reset. 0 restores TRUNCATE	100000
useGlobalTempTablePool	boolean	Hand a session table out of a pool the whole server node shares, instead of creating a temporary one. Creating a table takes a lock that suppresses the fast path of the lock manager for the whole PostgreSQL cluster until the transaction ends; a pooled table is created once for the node rather than once for every connection that needs that shape. A request that finds nothing suitable falls back to an ordinary temporary table. PostgreSQL only. On by default in a development or a test run	false
globalTempTablePoolTablespace	string	The tablespace the node pool creates its tables in. Empty means the database default. A pooled table is an ordinary permanent relation, so temp_tablespaces does not apply to it - an installation that keeps temporary tables on a separate tablespace has to name it here, and it must be one that survives a restart. PostgreSQL only	``
globalTempTablePoolMaxTables	int	The tables one node may hold in that pool at once, over all their shapes. Past it a request falls back to an ordinary temporary table	2000
logTempTables	boolean	Logs every operation on a session (temporary) table - its creation, its emptying with DELETE or TRUNCATE, its dropping, its ANALYZE, and whether the pool had one to reuse - into logs/temptable.log, marking the ones that happened inside a transaction, and adds one summary line per transaction. Meant for diagnosing how many of those a transaction takes, since on PostgreSQL the ones inside a transaction hold their locks until the commit	false
checkSessionCount	boolean	Check that a session table given out of the pool really is empty, and that the accounting of session tables on the application server is internally consistent. The emptiness check runs a SELECT COUNT(*) on every table taken from the pool, so the parameter cannot be kept on in production. A mismatch is written to the assertion log, and with the -ea launch option it also aborts the execution; only under -ea is each count additionally compared with the real number of rows in the database. Turning the accounting off with disableRegisterChanges makes the comparison of the counts vacuous, since it then weighs two values the platform maintains itself	false
disableRegisterChanges	boolean	Turns off the accounting of changes: the counts of session tables on a connection and the count of changed rows of permanent tables. Neither count is needed by the data itself but by the decisions made about it, so turning it off quietly stops two mechanisms: the restart of connections overloaded with session tables (see periodRestartConnections), and the automatic recalculation of a table's statistics once enough of its rows have changed (see updateStatisticsLimit). The optimizer then works on stale statistics	false
tempTablesTimeThreshold tempTablesCountThreshold	int int	Determine the minimum lifespan threshold (in seconds) of a temporary table and the number of tables per connection, upon exceeding which these temporary tables are cleared/deleted in the routine mode. The minimum lifespan threshold for the table should be commensurate with the standard using time of the temporary table. The smaller these thresholds, the lower the resource consumption by the database server, but the higher the likelihood of "cache rotation"	240 40
queryRowCountPessLimit queryRowCountOptDivider	int int	Parameters of the protection mechanism against too large queries. queryRowCountPessLimit - minimum number of records for which this protection is activated, queryRowCountOptDivider - the threshold at which the application server throws an error (is set as part of all memory available for the application server, e.g., if the parameter value is 50 and the memory capacity is 100GB, then the threshold is 100GB/50=2GB).	1000 50
queryLengthLimit	int	Parameters of the protection mechanism against too long queries. queryLengthLimit - the length of the request upon exceeding which the application server throws an error.	2000000
remoteLogTime	int	Runtime threshold (in milliseconds) at which the remote call is written to the corresponding log (server-remote)	3000
explainThreshold explainJavaStack explainCompile	int boolean boolean	Output parameters of query execution plan logs explainThreshold - runtime threshold (in milliseconds) at which SQL request is written to the corresponding log (explain). Used only if Service.explainAnalyzeMode[User] is enabled for the user. explainJavaStack - determines whether the Java stack should also be logged in addition to the LSF stack. explainCompile - outputs to a special log (explaincompile) information about the compilation of the query (proposed plans, pushing conditions into subqueries, etc.).	100 false false
startServerAnyWay	boolean	Start the server, even if there are errors in the index structure or metadata synchronization	false
dryRun	boolean	Stops the server startup right after the logic (modules, classes, properties, actions) is compiled and checked, before the database connection is established. Useful for validating .lsf changes without a live database	false
batchScriptErrors	boolean	Keeps checking a module after a semantic error is found, so that one run reports more than just the first one. As many errors are reported as the check can still make sense of after the failure, not necessarily everything wrong with the module. dryRun always turns this mode on. Read at startup	false
disablePrereadCaches maxPrereadCachesTime	boolean long	Warming up the caches at startup. At the default value true the warm-up is off: the property graph and the caches of individual properties are not computed at startup but lazily, on first use - the server starts faster, but the first requests pay for it. A value of false turns the warm-up on and makes the startup longer. maxPrereadCachesTime is a time threshold (in milliseconds) above which the warm-up of an individual property is written to the system log; properties that stay within the threshold are not logged. Both are read at startup, and neither has any effect if the server is started with -Dlsfusion.server.lightstart	true 10000
disablePrereadSecurityPolicies	boolean	Turns off reading the security policies of all roles at startup. They are read by default, so the first login of a user of each role does not pay for it; a value of true moves the read to the first use of the role - the startup is faster, but the database read lands inside a user request. Read at startup, and has no effect if the server is started with -Dlsfusion.server.lightstart	false
noTransSyncDB	boolean	Run the synchronization of the database structure at startup outside a transaction, as separate automatically committed statements. By default the whole synchronization - creating and changing tables, fields and indexes, applying the migration file - runs as one transaction and is rolled back as a whole if it fails. A value of true removes that guarantee: a failed synchronization leaves the structure half changed. Read at startup, and also when a database slave node is attached	false
singleInstance	boolean	Whether only one running desktop client is allowed on the user's computer. The value is substituted into the jnlp file that the server serves when the client is installed through Java Web Start, so a change applies to the next jnlp file downloaded, while an already running client keeps the value it started with. With true a repeated launch switches to the already open client instead of starting a second process. Outside a Java Web Start launch, and in the web client, the parameter has no effect. For historical reasons it can also be set without the settings prefix, under the key jnlp.singleInstance	false
maxScriptErrorsPerModule	int	How many errors are reported for one module when batchScriptErrors is on. Once that many are reported, the module stops being checked	10
checkUniqueEvent	boolean	Abort building the logic if more than one calculated event is defined for one property. Without this check the second such statement silently replaces the first one, with no message and no log entry. Read while the logic is being built, so it takes effect only after a server restart	false
checkAlwaysNull	boolean	Whether to report the declarations in which a property cannot take any value at all, that is when its possible results have no common ancestor. By default such a declaration is a semantic error and the server does not start. A value of false removes the message only: the class inference still runs while parsing, so the startup does not get any faster, and the same check for constraints is not turned off at all. Read while the logic is being built	true
useISOTimeFormatsInIntegration	boolean	Write date and time values as ISO 8601 strings in text integration formats (JSON, XML, CSV). When the parameter is off, the formats of the current locale are used	true
removeJoinCutBackwardCompatibility	boolean	Restores the pre-7.0 predicate push down behavior: the joins depending on the push target are cut from the pushed condition wholesale instead of keeping them with the depending arguments virtualized. Use as a quick fallback if after migrating to 7.0 some queries fail with the incorrect set operation error or get slower plans (see issue #1699)	false
keyExprCompareJoinBackwardCompatibility	boolean	Restores the pre-7.0 interval comparison handling in predicate push down planning (no key compare joins and the hanging interval key protections they replaced). Together with removeJoinCutBackwardCompatibility fully restores the pre-7.0 push down planning	false
allowNestedTransaction	boolean	Allows another session to work on an sql session that is already in a transaction: its reads and changes join that transaction instead of failing (they see its uncommitted data and disappear with its rollback, and an apply there has no atomicity of its own - its commit is physically nothing). Can be enabled for a single stack with pushSetting / popSetting when this is intended (see issue #1726)	false
allowUserInteractionInTransaction	boolean	Allows a user interaction inside a transaction: a dialog, a message or an input request raised under APPLY is only logged instead of failing (the transaction and its locks are held for the user think time). Can be enabled for a single stack with pushSetting / popSetting when such an interaction is intended (see issue #1726)	false
prefixIndexIntervalBackwardCompatibility	boolean	Restores taking interval conditions into account only for the first field of an index (an interval on a field standing later in a composite index is ignored). Read at startup	false
noOrderTopSplit	boolean	Restores the planning of queries with a limited number of rows as it was before version 7.0: the query condition is not split into mutually exclusive branches in each of which the ordering expression is a plain field again, and the cost is not estimated per branch. The split is what matters when the ordering expression stops being a field, for example while the session holds an unsaved change of the ordered property; without it the plan degenerates into a full scan of the table at that moment. In exchange, turning it off saves compilation time. Queries already compiled keep their previous plan	false
removeClassesFallback	boolean	Restores the handling of object deletion as it was before the fix in which the class removal was deferred to a child class covering all the object's previous classes. The deferral broke the order of events: events and materializations got their turn earlier, and the classes in the database were left inconsistent. It also brings back the absence of filtering of the dependencies no longer needed while changes are applied step by step: the two cannot be separated	false
noExecuteLocalEventsOnFormShowFallback	boolean	Restores the behaviour in which local events are not executed before a form is opened in the interactive view. Executing them before the opening aligns the previous values in the global context with the previous values in the form being opened; turning it off removes that alignment but saves executing the local events on every form opening	false
disableActionsIfReadonly	boolean	Restores the look of actions of version 5: an action the form shows as available for reading only is displayed as unavailable. The parameter is passed to the client when the navigator connects, so it applies after a new login, and it affects only the actions in a panel, not those in the cells of a table. The desktop client receives the value but does not use it	false
cssBackwardCompatibilityLevel	double	Restores the previous CSS class names of the web client: the old name, written in camel case, is put on the element alongside the new one. The value is the platform version from which the old names are needed. One compatibility level is declared in the client at the moment, version 5, so any value above zero and no greater than 5.9999 works, in practice 5, while 6 and above add nothing any more. -1 turns the mechanism off. Needed by applications whose own styles refer to the old names. Passed to the client when the navigator connects	-1
conflictSleepThreshold conflictSleepTimeDegree	int double	Parameters for resolving repeated update conflicts. The same mechanism serves deadlocks as well when the DBMS does not support controlling their priority (see deadLockThreshold): conflictSleepThreshold - the number of failed attempts already made on reaching which the mechanism is enabled; attempts are counted separately for each conflict and the current one is not among them. At 3 the pause appears on the fourth conflict in a row. conflictSleepTimeDegree - the time base (in seconds) raised to a power to get how long the thread is stopped. The exponent is the number of attempts above the threshold plus a random addition between 0 and 1. With base 2 and threshold 3, the fourth conflict in a row pauses for 1 to 2 seconds, the fifth for 2 to 4, and so on.	3 2
timeoutNanosPerRow	long	The average time to process one row, in microseconds despite the name of the parameter: the estimated time in milliseconds comes from multiplying the estimated number of rows by this value and dividing by 1000, and the estimate cannot be less than timeoutMinMillis. If this estimated time is exceeded, the platform tries to materialize some subqueries (or somehow change this request to a more pessimistic one) and run the query again. Reducing this parameter value may lead to more frequent materializations and additional repeated executions of the query in general, increasing it may lead to the use of incorrect plans (in the first place, nested loops on joining large tables), for example, in cases when the SQL server evaluates the subquery statistics incorrectly. The same estimate decides whether to explain a query before it runs (see explainNoAnalyzeThreshold).	20
deadLockThreshold	int	Parameters for resolving repeated deadlocks. deadLockThreshold - the number of unsuccessful attempts (when a deadlock occurred) after which the mechanism should be enabled.	0
periodRestartConnections percentRestartConnections	int double	Parameters of the connection restarting mechanism. periodRestartConnections - determines how often (a period in seconds) this mechanism is launched. percentRestartConnections - determines the percentage of connections with the maximum scoring that will be restarted. The fractional remainder of the computed number carries over to the next run. Both parameters also take part in computing the scoring itself, by setting the normal lifetime of a connection.	60 1
closeConfirmedDelay closeNotConfirmedDelay	int int	Delays (in milliseconds) of the final closing of a form after its closure has been initiated on the server. closeConfirmedDelay - the time given to the client to finish processing the form once it has confirmed the closure (this saves a round trip request when closing the form). closeNotConfirmedDelay - the time after which the form is closed anyway if no confirmation has come from the client.	5000 300000
defaultCompareForStringContains defaultCompareSearchInsteadOfContains	boolean boolean	The comparison type offered by default in a custom filter on a string property. Search or contains is offered instead of equality - for case-insensitive strings that is always so, and defaultCompareForStringContains extends that behaviour to all string properties, whatever their case sensitivity. Which of the two it is, is decided by defaultCompareSearchInsteadOfContains: true - full-text search, false - a plain substring match. Neither applies to a property whose comparison type is set explicitly	false true
limitHintIncrementComplexity limitComplexityGrowthCoeff limitHintIncrementStat limitHintIncrementValueComplexity limitApplyHintIncrementComplexity limitApplyHintIncrementStat	int double long int int long	Parameters for managing the complexity of changes (materialization of property changes when the complexity of incremental calculations becomes too large): limitHintIncrementComplexity - complexity threshold (defined as the approximate number of executed operators). When exceeded, property changes are materialized into a temporary table. This threshold must be exceeded either by the condition that defines the object collections for which the property has changed, or directly by the value of this property (for the value it is additionally verified that the increase in complexity compared to the calculation without changes exceeds limitComplexityGrowthCoeff) limitHintIncrementStat - the threshold of the estimated number of object collections for which the property changes, upon exceeding which the changes will not materialize (to avoid materialization of too large amount of data). First the maximum is taken of this value and of the largest number of records among the change tables of the properties this one depends on, and it is that maximum which is multiplied by the square of the ratio of the change complexity to limitHintIncrementComplexity (the greater the complexity, the less harm in the additional effort for maintaining a large amount of data). The cost of the change is additionally checked for not exceeding the resulting threshold multiplied by limitHintIncrementCostCoeff; a change that is known to be empty is materialized without either check. limitHintIncrementValueComplexity - if one of the property parameters is a known constant value, its changes will not be materialized by default. At the same time, complexity can increase very quickly, so there is an additional threshold in the platform, upon exceeding which changes will be materialized even in this case (with a constant parameter). However, if a property is marked with a special COMPLEX option or depends on such a property, its changes having a constant value as one of the parameters will never be materialized. limitApplyHintIncrementComplexity, limitApplyHintIncrementStat - parameters similar to the upper ones without the Apply prefix, used for the whole time the session is inside the changes applying (APPLY) transaction, including the handling of global events. They do not extend to local events, which run outside the transaction and use the base thresholds Upon increasing all of the above parameters, the compiler and the optimizer will have more information (possibly redundant) for building more efficient plans, but will also consume more of the processor time/memory (often significantly, therefore it is not recommended to set them too large). All the thresholds listed are additionally multiplied by the common limitIncrementCoeff coefficient. Besides materializing, exceeding the complexity threshold in expressions computed through a join of a property moves the computation into a separate query with no parameter values known in advance.	50 1.5 200 1000 100 1000
disableExperimentalFeatures	boolean	Coarsens the analysis of pre-read values: a property that has such a pre-read at all counts as using it for any set of changes, without looking into the particular set. That is safer, but common subexpressions are reused less often and the queries get heavier. The parameter's second effect, skipping the check of dangling interval keys, shows only with keyExprCompareJoinBackwardCompatibility enabled. It takes full effect after the caches are dropped	false
excessThreadAllocatedBytes excessInterruptCount threadAllocatedMemoryPeriod	long int int	Parameters of the excessive memory consumption preventing mechanism on the application server: excessThreadAllocatedBytes - the number of bytes upon exceeding which the thread is considered as consuming too much memory excessInterruptCount - the number of consecutive measurements during which the thread consumes too much memory. When exceeded, the thread will be interrupted threadAllocatedMemoryPeriod - period (in seconds) that determines how often memory consumption by threads is measured	5368709120L (5GB) 4 180 (3 minutes)
useSavePointsThreshold savePointCountForExceptions updateSavePointsMinMultiplier updateSavePointsMaxMultiplier	int int double double	Parameters of the mechanism for using savepoints in transactions (used to avoid restarting the entire transaction, for example, in the subquery materialization mechanism): useSavePointsThreshold - the number of simultaneous savepoints on the application server. The higher, the less likely transactions will be restarted, but the more likely some DBMSs (for example, Postgres) will initiate global locks (LWLock in Postgres). This parameter is adaptive and can change depending on the actual need to use savepoints (since the savepoint mechanism is turned on only after a certain number of transaction restarts). savePointCountForExceptions - the number of transaction restarts, upon exceeding which the savepoint mechanism is enabled (-1 - fully disable). updateSavePointsMaxMultiplier, updateSavePointsMinMultiplier - the minimum and maximum coefficients that can be set by the server when adaptively determining the number of simultaneous savepoints on the application server (for example, by default these coefficients are 0.8 and 3.0, i.e. the minimum targeted number of simultaneous savepoints is 5*0.8=4, the maximum is 5*3=15)	5 -1 0.8 3.0
changeBooleanOnSingleClick	boolean	Determines whether an event of changing a property of a logical type on the form is triggered by a single (true) or double (false) mouse click	not set (the client decides by the kind of the click)
changeActionOnSingleClick	boolean	Determines whether the action call event on the form is triggered by a single (true) or double (false) mouse click	true
defaultImagePathRankingThreshold defaultAutoImageRankingThreshold defaultNavigatorImageRankingThreshold defaultNavigatorImage defaultContainerImageRankingThreshold defaultContainerImage defaultPropertyImageRankingThreshold defaultPropertyImage	float float float boolean float boolean float boolean	Parameters of the icon assignment mechanism: the first one for icons set by a file path, the rest for automatic assignment	0.0f 0.0f 0.1f true 0.6f false 0.8f false
maxStickyLeft	double	The share of the table width that the columns pinned to the left (the STICKY property option) may occupy in the web client; the columns that do not fit into it are not pinned.	0.33
useShowIfInReports	boolean	When a report is built, removes from the template the text fields placed directly in a band whose property has a SHOWIF field declared in the template that is NULL in the first row of the report, together with the strip they occupy.	true
contentWordWrap highlightDuplicateValue userFiltersManualApplyMode suppressOnFocusChange	boolean boolean boolean boolean	Default values of the appearance settings text wrapping, highlighting of duplicates, manual filter applying and starting editing on focus (user interface) for the users who have not set them.	false false false false
newConnectionAttempts	int	How many times opening a new database connection is retried after a failure before the error is raised to the caller	3
disablePoolConnections	boolean	Disables the pool of database connections: a connection given back is closed instead of being kept for reuse (the pool holds up to freeConnections free connections per database node). Meant for diagnostics	false
disablePoolPreparedStatements queryPrepareLength queryPrepareRunTime	boolean int int	Parameters of the pool of prepared statements. A statement whose text is longer than queryPrepareLength characters and whose execution took longer than queryPrepareRunTime milliseconds is kept prepared on its connection and reused; disablePoolPreparedStatements turns the pool off	true 1000 40
checkCurrentDate checkCurrentDataDateTime	int int	Periods (in seconds) of the system tasks that update Time.currentDate[] when the day changes and the Time.currentDateTimeSnapshot[] / Time.currentZDateTimeSnapshot[] snapshots	30 1800
updateFormCountPeriod updateUserLastActivity updatePingInfo	int int int	Periods (in seconds) of the system tasks that write the client activity collected in memory into the database: how many times each form was opened, the last activity time of each connection, and the ping statistics of each computer	30 30 3600
notificationCleanupPeriod	int	How long (in seconds) the server keeps a notification for a client that has not fetched it yet (a NEWEXECUTOR CLIENT call, an external UI redirect, and so on), on top of the call's own delay or period; a periodic call renews the term on every firing. The expired ones are dropped by a task with the same period	600
flushAsyncValuesCaches	int	The period (in seconds) of the task that applies the deferred invalidation: of the value completion caches and of the properties whose cache invalidation is declared deferred. Until the task has run, a read can for a short while return the previous value	1
flushPendingTransactionCleanersThreshold	int	Period (in seconds) of the task that releases the temporary tables a session no longer needs when their release had to be postponed because the session's connection was in a transaction at the time	10
schedulerLogFlushInterval	int	Period (in seconds) with which the messages a running scheduler task writes to its log are flushed to the database	5
periodProcessDump	int	Period (in seconds) of the task that writes the list of the running SQL and Java processes (what the process monitor shows) to logs/processdump.log	60
periodBalanceConnections percentBalanceConnections	int double	Parameters of the balancing of connections between the database nodes (see database scaling): every periodBalanceConnections seconds percentBalanceConnections percent of the connections (at least one), starting with the ones on the most loaded node that hold the fewest temporary table rows, are moved to the least loaded node	5 1
readSQLServerCpuTimePeriod	int	Period (in seconds) with which the CPU load of every database node is read over SNMP (snmpPort[DBServer]) and the load estimate that picks the node for a new connection is recalculated (see the weights below)	5
baseConnWeight extraConnWeight lagSensitivity lagScale masterPenalty	double double double double double	Weights of the load estimate of a database node; a new connection goes to the node with the lowest estimate. The estimate is the CPU load (0..1) plus (baseConnWeight + extraConnWeight × CPU load) × the node's share of all connections, plus for a replica lagSensitivity × lag / (lagScale + lag), where lag is the replication lag in seconds (so at a lag of lagScale seconds this term is half of lagSensitivity), plus masterPenalty for the master	0.3 0.9 2.0 2.0 0.1
tempStatisticsTarget	int	default_statistics_target used for the ANALYZE of a temporary table (PostgreSQL); 0 keeps the server setting	10
deleteFromInsteadOfTruncateForTempTablesThreshold deleteFromInsteadOfTruncateForTempTablesUnknown	int boolean	The counterparts of deleteFromInsteadOfTruncateForTempTablesInTransactionThreshold outside a transaction: the number of rows (the ones the earlier emptyings left dead included) below which a temporary table is emptied with DELETE rather than TRUNCATE, 0 always uses TRUNCATE; the flag chooses DELETE for a table whose row count is not known, inside a transaction as well	0 false
applyAutoAttemptCountLimit dialogTransactionTimeout	int int	What happens when an apply transaction is cancelled by a statement timeout. Without a user (a scheduler task, an external call) the apply is repeated up to applyAutoAttemptCountLimit times and then cancelled. With a user a dialog offers to repeat it, to repeat it without a timeout or to cancel it, and dialogTransactionTimeout is how long (in milliseconds) the dialog waits for the answer before cancelling	3 5000
tooMuchRetryAttempts tooMuchAttempts	int int	How many times an apply is repeated after a transient error before the error is raised: tooMuchRetryAttempts for the errors of a prepared statement invalidated by a schema change (re-preparing it fixes them), tooMuchAttempts for a unique constraint violation that may be a race between sessions	3 15
trueSerializableAttempts	int	In the transaction-isolation-level mode (see disableTILMode[] in System_Service) an apply starts at the SERIALIZABLE level and stays there for trueSerializableAttempts retries after update conflicts; the retries after that run at REPEATABLE READ. 0 never uses SERIALIZABLE	0
timeoutStart timeoutDegree timeoutMinMillis	int int long	Parameters of the statement timeouts of the query materialization mechanism (see queryLengthTimeout, timeoutNanosPerRow). A query that timed out is retried alternately with and without volatile statistics, starting from a timeout of timeoutStart seconds that is multiplied by timeoutDegree on every second retry. timeoutMinMillis is the lower bound (in milliseconds) of the execution time estimated from timeoutNanosPerRow	3 5 100
maxThreadAllocatedBytes cacheMissesStatsLimit	long int	Thresholds of the periodic memory measurement (see threadAllocatedMemoryPeriod) above which a thread is written to logs/allocatedbytes.log together with its cache statistics: the bytes it allocated over the period and its cache misses over the period	500048576 (~500MB) 10000
updateStatisticsLimit	int	Number of rows changed in a temporary table after which its statistics are recalculated; they are also recalculated, whatever the number, when the change moves the table's row count into another order of magnitude (see statDegree)	300
majorStatChangeDegree updateStatsDropLRUThreshold	int int	majorStatChangeDegree is the factor, as a power of statDegree (25 with the defaults), used by the statistics update task twice: a table's statistics are refreshed once the rows added since the last refresh exceed its row count estimate by that factor (or the rows removed exceed the estimate itself), and a refresh that changes the estimate of a table or class by that factor counts as a major change. Once the major changes accumulated since the last drop exceed updateStatsDropLRUThreshold, the caches (LRU) are dropped, since the plans in them were built on the old statistics	2 1
disableSyncStatProps	boolean	Do not compute the statistics (the estimated number of values) of every property when the reflection objects (Reflection.Property) are synchronized with the database at startup; the default statistics is written instead. Read at startup	false
maxNumericPrecision maxNumericScale	int int	The precision and scale of a NUMERIC declared without them, and the upper bounds for the declared ones	127 32
useMaxDivisionLength	boolean	The result of dividing NUMERIC values gets maxNumericScale fraction digits (the dividend is cast to that type before the division). When off the scale is the sum of the dividend's scale and the divisor's integer digits, the behaviour of earlier versions	true
safeCastIntType	int	How a value that may not fit is cast to an integer type: 0 - a PL/pgSQL function that catches the cast error and returns NULL (affected by a PostgreSQL 13 bug when the statement is cancelled), 1 - an SQL function that returns NULL when the value is outside the range of the type, 2 - a plain cast in arithmetic, the DBMS error is raised when the value does not fit (a cast from a string keeps the function)	1
updateSavePointsPeriod updateSavePointsResultPeriod updateSavePointsCoeff	int int double	The adaptation of useSavePointsThreshold: every updateSavePointsPeriod seconds the server checks whether the savepoints needed at the moment fit the current threshold, and every updateSavePointsResultPeriod seconds it divides the threshold multiplier by updateSavePointsCoeff when they fitted in more than 80% of the checks, or multiplies it by updateSavePointsCoeff when in less than 60% (staying within updateSavePointsMinMultiplier and updateSavePointsMaxMultiplier)	30 1800 1.3
isClustered	boolean	The server is one of several application servers working on the same database. Disables the server-local caches that assume the server is the only one changing the data: the cache of asynchronous input values and the tracking of removed objects that lets a session skip class checks	false
restrictLongValuesInStat	boolean	Caps the row counts written into the reflection statistics (Reflection.quantity[Property], table and class row counts) at 2147483647, the way version 6 stored them. Keep it on while anything in the application still expects an INTEGER there	true
noDisablingNestedLoop lastStepCoeff subQueriesSplit subQueriesRowsThreshold subQueriesRowsMax subQueriesRowCountCoeff subQueriesParentCoeff subQueriesPessQueryCoeff	boolean int int int int int int int	Parameters of the query materialization mechanism (see timeoutNanosPerRow). A query that did not finish within its timeout is run again with some of its subqueries materialized into temporary tables, one step at a time, each step materializing more; the last step turns nested loop joins off in the DBMS (enable_nestloop) instead. noDisablingNestedLoop - do not take that last step: the step before it runs without a timeout instead lastStepCoeff - used in two places only: when the last step fails, the timeouts of the last two steps are multiplied by it and the query is retried, and after a success the mechanism returns to an earlier, cheaper step when the total time of the current one, materialization included, exceeded the timeout of that earlier step by this factor subQueriesSplit - how many parts a step splits the query into: the subqueries picked for materialization are the ones whose size in nested subqueries is closest to the size of the query divided by this number subQueriesRowsThreshold, subQueriesRowsMax - the estimated result size (rows) below which the size of a subquery does not influence the choice, and above which a subquery is not materialized unless the whole query is estimated even larger subQueriesRowCountCoeff, subQueriesParentCoeff, subQueriesPessQueryCoeff - weights in the choice: the estimated size of a subquery counts against it with subQueriesRowCountCoeff, every place the subquery is used from (each of them would run it again) counts for it with subQueriesParentCoeff, and a subquery that has a pessimistic execution variant is put off by the factor subQueriesPessQueryCoeff, so that the optimistic ones are materialized first	true 5 4 1000 100000 2 2 2
LRURangeDefaultCoeff LRURangeMinCoeff LRURangeMaxCoeff targetLRURangePercent criticalLRURangePercent targetLRUAdjustIncCoeff targetLRUAdjustDecCoeff criticalLRUAdjustCoeff stableLRUMinCount unstableLRUMaxCount disableLRUCollectionUsageThreshold memGCCollectionThresholdCooldown	double double double long long double double double long long boolean int	Parameters of the tuner of the server caches (LRU). An entry of a cache lives for the base time of that cache multiplied by a common multiplier, and the tuner moves the multiplier by the memory that the old generation of the Java heap still holds after a garbage collection, so that the caches take what memory is free and no more. The old generation is divided by four levels: critical, at 100 - criticalLRURangePercent percent of it, and below it, criticalLRURangePercent and then targetLRURangePercent apart, the upper, middle and lower bounds of the target range (85, 70, 60 and 50 percent with the defaults). LRURangeDefaultCoeff, LRURangeMinCoeff, LRURangeMaxCoeff - the initial multiplier (1.0 gives the most common caches an hour) and the limits past which it is not moved any further (a step that starts inside a limit may still end beyond it) targetLRURangePercent, targetLRUAdjustIncCoeff, targetLRUAdjustDecCoeff - the tuner checks the memory every second; once it has stayed the same for more than stableLRUMinCount seconds after a change (or has kept changing for more than unstableLRUMaxCount seconds), a value above the upper bound of the target range divides the multiplier by 1 + targetLRURangePercent/100 × targetLRUAdjustDecCoeff, a value below the lower bound multiplies it by 1 + targetLRURangePercent/100 × targetLRUAdjustIncCoeff criticalLRURangePercent, criticalLRUAdjustCoeff, memGCCollectionThresholdCooldown - when a collection leaves the memory above the critical level, the share of every cache that brings it back to the middle of the target range is dropped at once and the multiplier is divided by 1 + that share × criticalLRUAdjustCoeff; such a reaction happens at most once per memGCCollectionThresholdCooldown seconds disableLRUCollectionUsageThreshold - watch the memory as it is at any moment instead of the memory after a collection (the mode the tuner also falls back to when the JVM does not report the latter); in this mode the critical reaction has no cooldown and repeats, with the same drop and division, until the memory is back below the critical level	1.0 0.1 5.0 10 15 1.0 2.0 1.0 40 80 false 90
queryLengthAverageMax queryTimeAverageMax queryExecuteDegree timeStartedAverageMaxCoeff timeStartedDegree maxUsedTempRowsAverageMax maxUsedTempRowsDegree usedTempRowsAverageMax usedTempRowsDegree lastTempTablesActivityAverageMax	int int int double double int double int double int	The score of the connection restarting mechanism (see periodRestartConnections, percentRestartConnections): on every run the connections with the highest score are restarted: the connection is replaced by a new one, the temporary tables the session still uses move to it with their rows, the rest and the prepared statements go. The ...AverageMax parameters are the normal magnitudes, the ...Degree ones the powers the ratios to them are raised to; the temporary tables of a connection are measured by the total number of rows they hold. The score of a connection adds up for every statement it executed, its length in characters and its time in milliseconds divided by queryLengthAverageMax and queryTimeAverageMax, each to the power queryExecuteDegree its age divided by the normal lifetime of a connection, to the power timeStartedDegree; the normal lifetime is periodRestartConnections × 100 / percentRestartConnections seconds (the time it takes the mechanism to go round all connections) multiplied by timeStartedAverageMaxCoeff the largest number of temporary table rows it held at once divided by maxUsedTempRowsAverageMax, to the power maxUsedTempRowsDegree and subtracts the temporary table rows it holds now divided by usedTempRowsAverageMax, to the power usedTempRowsDegree, less the milliseconds since it last touched a temporary table divided by lastTempTablesActivityAverageMax, to the power timeStartedDegree (a connection that holds many temporary table rows and uses them is spared, one that holds them idle is not); this part is not allowed to go below zero	10000 10000 2 1.25 8 5000 2 500 4 180000
disableCombineFilters	boolean	Do not combine the filters active on an object group of an interactive form - the permanent ones, the user-added ones and the view ones - into a single cached condition, and compute and cache each of them separately instead. The rows the form shows are the same either way	false
asyncValuesLongCacheThreshold	int	The length of the typed text starting from which the results of the value completion of a property are cached in the longer-lived of the two caches; shorter, more general and therefore more often repeated queries go to the other one	4

info

In addition to the system parameters, the platform also has launch parameters which are set a little differently and are relevant mainly for startup (initialization) processes of various components of the platform and access to these components.