SqlEngineConfiguration (SQL Processor, Core Module 3.1.1 API)

java.lang.Object
- org.sqlproc.engine.config.SqlEngineConfiguration

```
public class SqlEngineConfiguration
extends Object
```
The dynamic configuration of the SQL Processor.
The primary goal of this configuration is the eager initialization of the selected SQL Engines. The overall configuration can be also persisted using the sql-processor-spring. The configuration can be dynamically changed using the JMX interface SqlDefaultFactoryMXBean.
For more info please see the Tutorials.

Author:

Vladimir Hudec

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

class SqlEngineConfiguration.NameValue
The simple container.

Nested Classes
Modifier and Type	Class and Description
`class`	`SqlEngineConfiguration.NameValue` The simple container.

Field Summary

Fields
Modifier and Type	Field and Description
`private Integer`	`asyncInitThreads` The number of threads used for asynchronous initialization.
`private ConcurrentHashMap<String,AtomicInteger>`	`crudEngines` The container of initialized CRUD Engines' names (static or dynamic ones) together with the number of their usage.
`private Set<String>`	`dontProcessingCacheEngines` Negative list of engines, for which the processing cache can be used.
`private Set<String>`	`doProcessingCacheEngines` Positive list of engines, for which the processing cache can be used.
`private ConcurrentHashMap<String,String>`	`dynamicCrudEngines` The container of initialized dynamic CRUD Engines' names together with their SQL statement.
`private ConcurrentHashMap<String,String>`	`dynamicProcedureEngines` The container of initialized dynamic Procedure Engines' names together with their SQL statement.
`private ConcurrentHashMap<String,String>`	`dynamicQueryEngines` The container of initialized dynamic Query Engines' names together with their SQL statement.
`private Boolean`	`initClearUsage` After the engines instantiations the users should be cleared.
`private Boolean`	`initInUsageOrder` The most frequently used engines should be initialized preferentially.
`private Integer`	`initTreshold` The engines, which usage is at least this number should be initialized directly.
`private Boolean`	`lazyInit` This flag indicates to speed up the initialization process.
`(package private) org.slf4j.Logger`	`logger` The internal slf4j logger.
`private ConcurrentHashMap<String,AtomicInteger>`	`procedureEngines` The container of initialized Procedure Engines' names (static or dynamic ones) together with the number of their usage.
`private ConcurrentHashMap<String,AtomicInteger>`	`queryEngines` The container of initialized Query Engines' names (static or dynamic ones) together with the number of their usage.
`private SqlEngineConfigurationStore`	`store` The store to persist this configuration;
`private Boolean`	`useProcessingCache` The processing cache can be used for `SqlProcessResult` instances.

Constructor Summary

Constructors
Constructor and Description
`SqlEngineConfiguration()` The default constructor.
`SqlEngineConfiguration(SqlEngineConfigurationStore store)` The constructor takes data from the persisted state in external file.
`SqlEngineConfiguration(String directory, String fileName)` The constructor takes data from the persisted state in external file.

Method Summary

Methods
Modifier and Type	Method and Description
`int`	`addCrudEngine(String name)` Adds the CRUD Engine to the container of initialized engines.
`int`	`addDynamicCrudEngine(String name, String sqlStatement)` Adds the dynamic CRUD Engine to the container of initialized engines.
`int`	`addDynamicProcedureEngine(String name, String sqlStatement)` Adds the dynamic Procedure Engine to the container of initialized engines.
`int`	`addDynamicQueryEngine(String name, String sqlStatement)` Adds the dynamic Query Engine to the container of initialized engines.
`protected int`	`addEngine(String name, ConcurrentHashMap<String,AtomicInteger> engines)` Adds the SQL Engine to the container of initialized engines.
`int`	`addProcedureEngine(String name)` Adds the Procedure Engine to the container of initialized engines.
`int`	`addQueryEngine(String name)` Adds the Query Engine to the container of initialized engines.
`void`	`clear()` Reset the state of the dynamic configuration instance.
`void`	`clearUsage()` Reset the engines' usage counters.
`Integer`	`getAsyncInitThreads()` Returns the number of threads used for asynchronous initialization
`ConcurrentHashMap<String,AtomicInteger>`	`getCrudEngines()` Returns the container of initialized CRUD Engines' names (static or dynamic ones) together with the number of their usage
`Map<String,Integer>`	`getCrudEnginesToInit(Integer treshold)` Returns the container of the CRUD Engines' names, which has to be initialized.
`Set<String>`	`getDontProcessingCacheEngines()` Returns the list of engines, for which the processing cache can't be used
`Set<String>`	`getDoProcessingCacheEngines()` Returns the list of engines, for which the processing cache can be used
`ConcurrentHashMap<String,String>`	`getDynamicCrudEngines()` Returns the container of initialized dynamic CRUD Engines' names together with their SQL statement
`ConcurrentHashMap<String,String>`	`getDynamicProcedureEngines()` Returns the container of initialized dynamic Procedure Engines' names together with their SQL statement
`ConcurrentHashMap<String,String>`	`getDynamicQueryEngines()` Returns the container of initialized dynamic Query Engines' names together with their SQL statement
`protected Map<String,Integer>`	`getEnginesToInit(ConcurrentHashMap<String,AtomicInteger> engines, Integer treshold)` Returns the container of the SQL Engines' names, which has to be initialized.
`Boolean`	`getInitClearUsage()` Returns the indicator that after the engines instantiations the users should be cleared
`Boolean`	`getInitInUsageOrder()` Returns the indicator that the most frequently used engines should be initialized preferentially
`Integer`	`getInitTreshold()` Returns the initialization threshold.
`Boolean`	`getLazyInit()` Returns the indicator to speed up the initialization process
`ConcurrentHashMap<String,AtomicInteger>`	`getProcedureEngines()` Returns the container of initialized Procedure Engines' names (static or dynamic ones) together with the number of their usage
`Map<String,Integer>`	`getProcedureEnginesToInit(Integer treshold)` Returns the container of the Procedure Engines' names, which has to be initialized.
`ConcurrentHashMap<String,AtomicInteger>`	`getQueryEngines()` Returns the container of initialized Query Engines' names (static or dynamic ones) together with the number of their usage
`Map<String,Integer>`	`getQueryEnginesToInit(Integer treshold)` Returns the container of the Query Engines' names, which has to be initialized.
`Boolean`	`getUseProcessingCache()` Returns the indicator that the processing cache can be used
`void`	`load()` Loads the persisted configuration.
`int`	`removeCrudEngine(String name)` Removes the CRUD Engine from the container of initialized engines.
`int`	`removeDynamicCrudEngine(String name)` Removes the dynamic CRUD Engine from the container of initialized engines.
`int`	`removeDynamicProcedureEngine(String name)` Removes the dynamic Procedure Engine from the container of initialized engines.
`int`	`removeDynamicQueryEngine(String name)` Removes the dynamic Query Engine from the container of initialized engines.
`protected int`	`removeEngine(String name, ConcurrentHashMap<String,AtomicInteger> engines)` Removes the SQL Engine from the container of initialized engines.
`int`	`removeProcedureEngine(String name)` Removes the Procedure Engine from the container of initialized engines.
`int`	`removeQueryEngine(String name)` Removes the Query Engine from the container of initialized engines.
`void`	`setAsyncInitThreads(Integer asyncInitThreads)` Sets the number of threads used for asynchronous initialization
`void`	`setCrudEngines(ConcurrentHashMap<String,AtomicInteger> crudEngines)` Sets the container of initialized CRUD Engines' names (static or dynamic ones) together with the number of their usage
`void`	`setDontProcessingCacheEngines(Set<String> dontProcessingCacheEngines)` Sets the list of engines, for which the processing cache can't be used
`void`	`setDoProcessingCacheEngines(Set<String> doProcessingCacheEngines)` Sets the list of engines, for which the processing cache can be used
`void`	`setDynamicCrudEngines(ConcurrentHashMap<String,String> dynamicCrudEngines)` Sets the container of initialized dynamic CRUD Engines' names together with their SQL statement
`void`	`setDynamicProcedureEngines(ConcurrentHashMap<String,String> dynamicProcedureEngines)` Sets the container of initialized dynamic Procedure Engines' names together with their SQL statement
`void`	`setDynamicQueryEngines(ConcurrentHashMap<String,String> dynamicQueryEngines)` Sets the container of initialized dynamic Query Engines' names together with their SQL statement
`void`	`setInitClearUsage(Boolean initClearUsage)` Sets the indicator that after the engines instantiations the users should be cleared
`void`	`setInitInUsageOrder(Boolean initInUsageOrder)` Sets the indicator that the most frequently used engines should be initialized preferentially
`void`	`setInitTreshold(Integer initTreshold)` Sets the initialization threshold.
`void`	`setLazyInit(Boolean lazyInit)` Sets the indicator to speed up the initialization process
`void`	`setProcedureEngines(ConcurrentHashMap<String,AtomicInteger> procedureEngines)` Sets the container of initialized Procedure Engines' names (static or dynamic ones) together with the number of their usage
`void`	`setQueryEngines(ConcurrentHashMap<String,AtomicInteger> queryEngines)` Sets the container of initialized Query Engines' names (static or dynamic ones) together with the number of their usage
`void`	`setUseProcessingCache(Boolean useProcessingCache)` Sets the indicator that the processing cache can be used
`void`	`store()` Persist the configuration into the external file.
`String`	`toString()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - logger
```
final org.slf4j.Logger logger
```
    The internal slf4j logger.
  - queryEngines
```
private ConcurrentHashMap<String,AtomicInteger> queryEngines
```
    The container of initialized Query Engines' names (static or dynamic ones) together with the number of their usage.
  - crudEngines
```
private ConcurrentHashMap<String,AtomicInteger> crudEngines
```
    The container of initialized CRUD Engines' names (static or dynamic ones) together with the number of their usage.
  - procedureEngines
```
private ConcurrentHashMap<String,AtomicInteger> procedureEngines
```
    The container of initialized Procedure Engines' names (static or dynamic ones) together with the number of their usage.
  - dynamicQueryEngines
```
private ConcurrentHashMap<String,String> dynamicQueryEngines
```
    The container of initialized dynamic Query Engines' names together with their SQL statement.
  - dynamicCrudEngines
```
private ConcurrentHashMap<String,String> dynamicCrudEngines
```
    The container of initialized dynamic CRUD Engines' names together with their SQL statement.
  - dynamicProcedureEngines
```
private ConcurrentHashMap<String,String> dynamicProcedureEngines
```
    The container of initialized dynamic Procedure Engines' names together with their SQL statement.
  - lazyInit
```
private Boolean lazyInit
```
    This flag indicates to speed up the initialization process.
  - asyncInitThreads
```
private Integer asyncInitThreads
```
    The number of threads used for asynchronous initialization.
  - initTreshold
```
private Integer initTreshold
```
    The engines, which usage is at least this number should be initialized directly.
  - initInUsageOrder
```
private Boolean initInUsageOrder
```
    The most frequently used engines should be initialized preferentially.
  - initClearUsage
```
private Boolean initClearUsage
```
    After the engines instantiations the users should be cleared.
  - useProcessingCache
```
private Boolean useProcessingCache
```
    The processing cache can be used for SqlProcessResult instances.
  - doProcessingCacheEngines
```
private Set<String> doProcessingCacheEngines
```
    Positive list of engines, for which the processing cache can be used.
  - dontProcessingCacheEngines
```
private Set<String> dontProcessingCacheEngines
```
    Negative list of engines, for which the processing cache can be used.
  - store
```
private SqlEngineConfigurationStore store
```
    The store to persist this configuration;
- Constructor Detail
  - SqlEngineConfiguration
```
public SqlEngineConfiguration()
```
    The default constructor.
  - SqlEngineConfiguration
```
public SqlEngineConfiguration(String directory,
                      String fileName)
                       throws IOException,
                              JAXBException
```
    The constructor takes data from the persisted state in external file.
    
    Parameters:
    directory - the directory, where the persisted file is placed
    fileName - the name of the persisted file
    
    Throws:
    
    IOException - in the case there's a I/O problem with the persisted file
    
    JAXBException - in the case there's a problem with JAXB deserialization
  - SqlEngineConfiguration
```
public SqlEngineConfiguration(SqlEngineConfigurationStore store)
```
    The constructor takes data from the persisted state in external file.
    
    Parameters:
    store - the store to persist this configuration
    
    Throws:
    
    IOException - in the case there's a I/O problem with the persisted file
    
    JAXBException - in the case there's a problem with JAXB deserialization
- Method Detail
  - load
```
public void load()
          throws JAXBException
```
    Loads the persisted configuration.
    
    Throws:
    
    JAXBException
  - store
```
public void store()
```
    Persist the configuration into the external file.
  - clear
```
public void clear()
```
    Reset the state of the dynamic configuration instance.
  - clearUsage
```
public void clearUsage()
```
    Reset the engines' usage counters.
  - addEngine
```
protected int addEngine(String name,
            ConcurrentHashMap<String,AtomicInteger> engines)
```
    Adds the SQL Engine to the container of initialized engines.
    
    Parameters:
    name - the name of the SQL Engine
    engines - the container of initialized engines
    
    Returns:
    the actual number of the engine's usage
  - removeEngine
```
protected int removeEngine(String name,
               ConcurrentHashMap<String,AtomicInteger> engines)
```
    Removes the SQL Engine from the container of initialized engines.
    
    Parameters:
    name - the name of the SQL Engine
    engines - the container of initialized engines
    
    Returns:
    the actual number of the engine's usage
  - addQueryEngine
```
public int addQueryEngine(String name)
```
    Adds the Query Engine to the container of initialized engines.
    
    Parameters:
    name - the name of the Query Engine
    
    Returns:
    the actual number of the engine's usage
  - addCrudEngine
```
public int addCrudEngine(String name)
```
    Adds the CRUD Engine to the container of initialized engines.
    
    Parameters:
    name - the name of the CRUD Engine
    
    Returns:
    the actual number of the engine's usage
  - addProcedureEngine
```
public int addProcedureEngine(String name)
```
    Adds the Procedure Engine to the container of initialized engines.
    
    Parameters:
    name - the name of the Procedure Engine
    
    Returns:
    the actual number of the engine's usage
  - removeQueryEngine
```
public int removeQueryEngine(String name)
```
    Removes the Query Engine from the container of initialized engines.
    
    Parameters:
    name - the name of the Query Engine
    
    Returns:
    the actual number of the engine's usage
  - removeCrudEngine
```
public int removeCrudEngine(String name)
```
    Removes the CRUD Engine from the container of initialized engines.
    
    Parameters:
    name - the name of the CRUD Engine
    
    Returns:
    the actual number of the engine's usage
  - removeProcedureEngine
```
public int removeProcedureEngine(String name)
```
    Removes the Procedure Engine from the container of initialized engines.
    
    Parameters:
    name - the name of the Procedure Engine
    
    Returns:
    the actual number of the engine's usage
  - addDynamicQueryEngine
```
public int addDynamicQueryEngine(String name,
                        String sqlStatement)
```
    Adds the dynamic Query Engine to the container of initialized engines.
    
    Parameters:
    name - the name of the dynamic Query Engine
    
    Returns:
    the actual number of the engine's usage
  - addDynamicCrudEngine
```
public int addDynamicCrudEngine(String name,
                       String sqlStatement)
```
    Adds the dynamic CRUD Engine to the container of initialized engines.
    
    Parameters:
    name - the name of the dynamic CRUD Engine
    
    Returns:
    the actual number of the engine's usage
  - addDynamicProcedureEngine
```
public int addDynamicProcedureEngine(String name,
                            String sqlStatement)
```
    Adds the dynamic Procedure Engine to the container of initialized engines.
    
    Parameters:
    name - the name of the dynamic Procedure Engine
    
    Returns:
    the actual number of the engine's usage
  - removeDynamicQueryEngine
```
public int removeDynamicQueryEngine(String name)
```
    Removes the dynamic Query Engine from the container of initialized engines.
    
    Parameters:
    name - the name of the dynamic Query Engine
    
    Returns:
    the actual number of the engine's usage
  - removeDynamicCrudEngine
```
public int removeDynamicCrudEngine(String name)
```
    Removes the dynamic CRUD Engine from the container of initialized engines.
    
    Parameters:
    name - the name of the dynamic CRUD Engine
    
    Returns:
    the actual number of the engine's usage
  - removeDynamicProcedureEngine
```
public int removeDynamicProcedureEngine(String name)
```
    Removes the dynamic Procedure Engine from the container of initialized engines.
    
    Parameters:
    name - the name of the dynamic Procedure Engine
    
    Returns:
    the actual number of the engine's usage
  - getQueryEngines
```
public ConcurrentHashMap<String,AtomicInteger> getQueryEngines()
```
    Returns the container of initialized Query Engines' names (static or dynamic ones) together with the number of their usage
    
    Returns:
    the container of initialized Query Engines' names (static or dynamic ones) together with the number of their usage
  - getCrudEngines
```
public ConcurrentHashMap<String,AtomicInteger> getCrudEngines()
```
    Returns the container of initialized CRUD Engines' names (static or dynamic ones) together with the number of their usage
    
    Returns:
    the container of initialized CRUD Engines' names (static or dynamic ones) together with the number of their usage
  - getProcedureEngines
```
public ConcurrentHashMap<String,AtomicInteger> getProcedureEngines()
```
    Returns the container of initialized Procedure Engines' names (static or dynamic ones) together with the number of their usage
    
    Returns:
    the container of initialized Procedure Engines' names (static or dynamic ones) together with the number of their usage
  - getDynamicQueryEngines
```
public ConcurrentHashMap<String,String> getDynamicQueryEngines()
```
    Returns the container of initialized dynamic Query Engines' names together with their SQL statement
    
    Returns:
    the container of initialized dynamic Query Engines' names together with their SQL statement
  - getDynamicCrudEngines
```
public ConcurrentHashMap<String,String> getDynamicCrudEngines()
```
    Returns the container of initialized dynamic CRUD Engines' names together with their SQL statement
    
    Returns:
    the container of initialized dynamic CRUD Engines' names together with their SQL statement
  - getDynamicProcedureEngines
```
public ConcurrentHashMap<String,String> getDynamicProcedureEngines()
```
    Returns the container of initialized dynamic Procedure Engines' names together with their SQL statement
    
    Returns:
    the container of initialized dynamic Procedure Engines' names together with their SQL statement
  - setQueryEngines
```
public void setQueryEngines(ConcurrentHashMap<String,AtomicInteger> queryEngines)
```
    Sets the container of initialized Query Engines' names (static or dynamic ones) together with the number of their usage
    
    Parameters:
    queryEngines - the container of initialized Query Engines' names (static or dynamic ones) together with the number of their usage
  - setCrudEngines
```
public void setCrudEngines(ConcurrentHashMap<String,AtomicInteger> crudEngines)
```
    Sets the container of initialized CRUD Engines' names (static or dynamic ones) together with the number of their usage
    
    Parameters:
    crudEngines - the container of initialized CRUD Engines' names (static or dynamic ones) together with the number of their usage
  - setProcedureEngines
```
public void setProcedureEngines(ConcurrentHashMap<String,AtomicInteger> procedureEngines)
```
    Sets the container of initialized Procedure Engines' names (static or dynamic ones) together with the number of their usage
    
    Parameters:
    procedureEngines - the container of initialized Procedure Engines' names (static or dynamic ones) together with the number of their usage
  - setDynamicQueryEngines
```
public void setDynamicQueryEngines(ConcurrentHashMap<String,String> dynamicQueryEngines)
```
    Sets the container of initialized dynamic Query Engines' names together with their SQL statement
    
    Parameters:
    dynamicQueryEngines - the container of initialized dynamic Query Engines' names together with their SQL statement
  - setDynamicCrudEngines
```
public void setDynamicCrudEngines(ConcurrentHashMap<String,String> dynamicCrudEngines)
```
    Sets the container of initialized dynamic CRUD Engines' names together with their SQL statement
    
    Parameters:
    dynamicCrudEngines - the container of initialized dynamic CRUD Engines' names together with their SQL statement
  - setDynamicProcedureEngines
```
public void setDynamicProcedureEngines(ConcurrentHashMap<String,String> dynamicProcedureEngines)
```
    Sets the container of initialized dynamic Procedure Engines' names together with their SQL statement
    
    Parameters:
    dynamicProcedureEngines - the container of initialized dynamic Procedure Engines' names together with their SQL statement
  - getLazyInit
```
public Boolean getLazyInit()
```
    Returns the indicator to speed up the initialization process
    
    Returns:
    the indicator to speed up the initialization process
  - setLazyInit
```
public void setLazyInit(Boolean lazyInit)
```
    Sets the indicator to speed up the initialization process
    
    Parameters:
    lazyInit - the indicator to speed up the initialization process
  - getAsyncInitThreads
```
public Integer getAsyncInitThreads()
```
    Returns the number of threads used for asynchronous initialization
    
    Returns:
    the number of threads used for asynchronous initialization
  - setAsyncInitThreads
```
public void setAsyncInitThreads(Integer asyncInitThreads)
```
    Sets the number of threads used for asynchronous initialization
    
    Parameters:
    asyncInitThreads - the number of threads used for asynchronous initialization
  - getInitTreshold
```
public Integer getInitTreshold()
```
    Returns the initialization threshold. The engines, which usage is at least this number should be initialized directly
    
    Returns:
    the initialization threshold. The engines, which usage is at least this number should be initialized directly
  - setInitTreshold
```
public void setInitTreshold(Integer initTreshold)
```
    Sets the initialization threshold. The engines, which usage is at least this number should be initialized directly
    
    Parameters:
    initTreshold - the initialization threshold. The engines, which usage is at least this number should be initialized directly
  - getInitInUsageOrder
```
public Boolean getInitInUsageOrder()
```
    Returns the indicator that the most frequently used engines should be initialized preferentially
    
    Returns:
    the indicator that the most frequently used engines should be initialized preferentially
  - setInitInUsageOrder
```
public void setInitInUsageOrder(Boolean initInUsageOrder)
```
    Sets the indicator that the most frequently used engines should be initialized preferentially
    
    Parameters:
    initInUsageOrder - the indicator that the most frequently used engines should be initialized preferentially
  - getInitClearUsage
```
public Boolean getInitClearUsage()
```
    Returns the indicator that after the engines instantiations the users should be cleared
    
    Returns:
    the indicator that after the engines instantiations the users should be cleared
  - setInitClearUsage
```
public void setInitClearUsage(Boolean initClearUsage)
```
    Sets the indicator that after the engines instantiations the users should be cleared
    
    Parameters:
    initClearUsage - the indicator that after the engines instantiations the users should be cleared
  - getUseProcessingCache
```
public Boolean getUseProcessingCache()
```
    Returns the indicator that the processing cache can be used
    
    Returns:
    the indicator that the processing cache can be used
  - setUseProcessingCache
```
public void setUseProcessingCache(Boolean useProcessingCache)
```
    Sets the indicator that the processing cache can be used
    
    Parameters:
    useProcessingCache - the indicator that the processing cache can be used
  - getDoProcessingCacheEngines
```
public Set<String> getDoProcessingCacheEngines()
```
    Returns the list of engines, for which the processing cache can be used
    
    Returns:
    the list of engines, for which the processing cache can be used
  - setDoProcessingCacheEngines
```
public void setDoProcessingCacheEngines(Set<String> doProcessingCacheEngines)
```
    Sets the list of engines, for which the processing cache can be used
    
    Parameters:
    doProcessingCacheEngines - the list of engines, for which the processing cache can be used
  - getDontProcessingCacheEngines
```
public Set<String> getDontProcessingCacheEngines()
```
    Returns the list of engines, for which the processing cache can't be used
    
    Returns:
    the list of engines, for which the processing cache can't be used
  - setDontProcessingCacheEngines
```
public void setDontProcessingCacheEngines(Set<String> dontProcessingCacheEngines)
```
    Sets the list of engines, for which the processing cache can't be used
    
    Parameters:
    dontProcessingCacheEngines - the list of engines, for which the processing cache can't be used
  - getEnginesToInit
```
protected Map<String,Integer> getEnginesToInit(ConcurrentHashMap<String,AtomicInteger> engines,
                                   Integer treshold)
```
    Returns the container of the SQL Engines' names, which has to be initialized. This is called during The SQL Processor initialization, so there's no need to handle concurrent changes.
    
    Parameters:
    engines - the container of initialized engines
    treshold - the engines, which usage is at least this number should be initialized directly
    
    Returns:
    the container of the Query Engines' names, which has to be initialized
  - getQueryEnginesToInit
```
public Map<String,Integer> getQueryEnginesToInit(Integer treshold)
```
    Returns the container of the Query Engines' names, which has to be initialized. This is called during The SQL Processor initialization, so there's no need to handle concurrent changes.
    
    Parameters:
    treshold - the engines, which usage is at least this number should be initialized directly
    
    Returns:
    the container of the Query Engines' names, which has to be initialized
  - getCrudEnginesToInit
```
public Map<String,Integer> getCrudEnginesToInit(Integer treshold)
```
    Returns the container of the CRUD Engines' names, which has to be initialized. This is called during The SQL Processor initialization, so there's no need to handle concurrent changes.
    
    Parameters:
    treshold - the engines, which usage is at least this number should be initialized directly
    
    Returns:
    the container of the CRUD Engines' names, which has to be initialized
  - getProcedureEnginesToInit
```
public Map<String,Integer> getProcedureEnginesToInit(Integer treshold)
```
    Returns the container of the Procedure Engines' names, which has to be initialized. This is called during The SQL Processor initialization, so there's no need to handle concurrent changes.
    
    Parameters:
    treshold - the engines, which usage is at least this number should be initialized directly
    
    Returns:
    the container of the Procedure Engines' names, which has to be initialized
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class SqlEngineConfiguration

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

logger

queryEngines

crudEngines

procedureEngines

dynamicQueryEngines

dynamicCrudEngines

dynamicProcedureEngines

lazyInit

asyncInitThreads

initTreshold

initInUsageOrder

initClearUsage

useProcessingCache

doProcessingCacheEngines

dontProcessingCacheEngines

store

Constructor Detail

SqlEngineConfiguration

SqlEngineConfiguration

SqlEngineConfiguration

Method Detail

load

store

clear

clearUsage

addEngine

removeEngine

addQueryEngine

addCrudEngine

addProcedureEngine

removeQueryEngine

removeCrudEngine

removeProcedureEngine

addDynamicQueryEngine

addDynamicCrudEngine

addDynamicProcedureEngine

removeDynamicQueryEngine

removeDynamicCrudEngine

removeDynamicProcedureEngine

getQueryEngines

getCrudEngines

getProcedureEngines

getDynamicQueryEngines

getDynamicCrudEngines

getDynamicProcedureEngines

setQueryEngines

setCrudEngines

setProcedureEngines

setDynamicQueryEngines

setDynamicCrudEngines

setDynamicProcedureEngines

getLazyInit

setLazyInit

getAsyncInitThreads

setAsyncInitThreads

getInitTreshold

setInitTreshold

getInitInUsageOrder

setInitInUsageOrder

getInitClearUsage

setInitClearUsage

getUseProcessingCache

setUseProcessingCache

getDoProcessingCacheEngines

setDoProcessingCacheEngines

getDontProcessingCacheEngines

setDontProcessingCacheEngines

getEnginesToInit

getQueryEnginesToInit

getCrudEnginesToInit

getProcedureEnginesToInit

toString