|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectorg.sqlproc.engine.SqlSimpleFactory
public class SqlSimpleFactory
The simple implementation of the SqlEngineFactory
.
It's suitable mainly for the Spring DI based configuration, like the next one for the new loader
SqlProcessorLoader
:
<beans ...> ... <bean id="typeFactory" class="org.sqlproc.engine.jdbc.type.JdbcTypeFactory" factory-method="getInstance" /> <bean id="sqlFactory" class="org.sqlproc.engine.SqlSimpleFactory" init-method="init"> <property name="metaFilesNames"> <list> <value>statements.qry</value> </list> </property> <property name="typeFactory" ref="typeFactory" /> </bean> </beans>or like the next one for the old loader
SqlEngineLoader
:<beans ...> ... <bean id="typeFactory" class="org.sqlproc.engine.jdbc.type.JdbcTypeFactory" factory-method="getInstance" /> <bean id="sqlQueries" class="org.springframework.beans.factory.config.PropertiesFactoryBean"> <property name="location"> <value>classpath:queries.properties</value> </property> </bean> <bean id="sqlFactory" class="org.sqlproc.engine.SqlSimpleFactory" init-method="init"> <property name="metaProps" ref="sqlQueries" /> <property name="typeFactory" ref="typeFactory" /> </bean> </beans>and use the next code to obtain an instance of the SQL Query engine
SqlQueryEngine sqlEngine = sqlFactory.getQueryEngine("ALL");or the next code to obtain an instance of the SQL CRUD engine
SqlCrudEngine sqlEngine = sqlFactory.getCrudEngine("ALL");
In the case the SQL Processor runs on the top of the JDBC stack, there's more suitable JdbcEngineFactory
.
For more info please see the Tutorials.
Field Summary | |
---|---|
private List<SqlInternalType> |
customTypes
The custom META types. |
protected static String |
DEFAULT_META_PROPS_NAME
Default value for metaPropsNames . |
private String |
filter
The name of the filter to filter the META SQL statements, mapping rules and optional features. |
private boolean |
jdbc
The indicator the JDBC stack is used. |
private static String |
LINESEP
The platform based line separator. |
private SqlEngineLoader |
loader
The helper class for the META SQL statements and mapping rules parsing. |
private List<String> |
metaFilesNames
The names of files, which hold a collection of the SQL Processor artifacts (META SQL statements, mapping rules and optional features). |
private Properties |
metaProps
The collection of all SQL Processor artifacts (META SQL statements, mapping rules and optional features). |
private List<String> |
metaPropsNames
The names of property files, which hold a collection of the SQL Processor artifacts (META SQL statements, mapping rules and optional features). |
private StringBuilder |
metaStatements
The String representation of all SQL Processor artifacts (META SQL statements, mapping rules and optional features). |
private SqlMonitorFactory |
monitorFactory
The monitor factory used in the process of the SQL Monitor instances creation. |
private String[] |
onlyStatements
Only statements and rules with the names in this set are picked up from the properties repository. |
private SqlProcessorLoader |
processorLoader
The helper class for the META SQL statements and mapping rules parsing. |
private SqlTypeFactory |
typeFactory
The factory for the META types construction. |
Constructor Summary | |
---|---|
SqlSimpleFactory()
Creates a new instance with no default values. |
Method Summary | |
---|---|
void |
addCustomType(SqlInternalType customType)
Adds a new custom META type. |
SqlCrudEngine |
getCrudEngine(String name)
Returns the named SQL CRUD Engine instance (the primary SQL Processor class). |
List<SqlInternalType> |
getCustomTypes()
Returns the custom META types. |
String |
getFilter()
Returns the name of the filter to filter the META SQL statements, mapping rules and optional features. |
SqlEngineFactory |
getLoader()
Returns the internal SQL engine or processor loader. |
List<String> |
getMetaFilesNames()
Returns the names of files, which holds a collection of META SQL statements, mapping rules and optional features. |
Properties |
getMetaProps()
Returns the collection of the META SQL statements, mapping rules and optional features. |
List<String> |
getMetaPropsNames()
Returns the names of property files, which holds a collection of META SQL statements, mapping rules and optional features. |
StringBuilder |
getMetaStatements()
Returns the String representation of the META SQL statements, mapping rules and optional features. |
SqlMonitorFactory |
getMonitorFactory()
Returns the monitor factory used in the process of the SQL Monitor instances creation. |
String[] |
getOnlyStatements()
Returns the only statements and rules, which are picked up from the properties repository. |
SqlProcedureEngine |
getProcedureEngine(String name)
Returns the named SQL Procedure Engine instance (the primary SQL Processor class). |
SqlQueryEngine |
getQueryEngine(String name)
Returns the named SQL Query Engine instance (the primary SQL Processor class). |
SqlTypeFactory |
getTypeFactory()
Returns the factory for the META types construction. |
void |
init()
Dynamic initialization, called mainly from the Spring configuration initialization. |
boolean |
isJdbc()
Return the indicator the JDBC stack is used. |
void |
setCustomTypes(List<SqlInternalType> customTypes)
Sets the custom META types. |
void |
setCustomTypes(SqlInternalType... customTypes)
Sets the custom META types. |
void |
setFilter(String filter)
Sets the name of the filter to filter the META SQL statements, mapping rules and optional features. |
void |
setJdbc(boolean jdbc)
Sets the indicator the JDBC stack is used. |
void |
setMetaFilesNames(List<String> metaFilesNames)
Sets the names of files, which holds a collection of META SQL statements, mapping rules and optional features. |
void |
setMetaFilesNames(String... metaFilesNames)
Sets the names of files, which holds a collection of META SQL statements, mapping rules and optional features. |
void |
setMetaProps(Properties props)
Sets the collection of the META SQL statements, mapping rules and optional features. |
void |
setMetaPropsNames(List<String> propsNames)
Sets the names of property files, which holds a collection of META SQL statements, mapping rules and optional features. |
void |
setMetaPropsNames(String... propsNames)
Sets the names of property files, which holds a collection of META SQL statements, mapping rules and optional features. |
void |
setMetaStatements(StringBuilder metaStatements)
Sets the String representation of the META SQL statements, mapping rules and optional features. |
void |
setMonitorFactory(SqlMonitorFactory monitorFactory)
Sets the monitor factory used in the process of the SQL Monitor instances creation. |
void |
setOnlyStatements(String[] selectQueries)
Sets the only statements and rules, which are picked up from the properties repository. |
void |
setTypeFactory(SqlTypeFactory typeFactory)
Sets the factory for the META types construction. |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Field Detail |
---|
private static final String LINESEP
protected static final String DEFAULT_META_PROPS_NAME
metaPropsNames
.
private List<String> metaPropsNames
private List<String> metaFilesNames
private Properties metaProps
private StringBuilder metaStatements
private SqlTypeFactory typeFactory
private String filter
private SqlMonitorFactory monitorFactory
private List<SqlInternalType> customTypes
private String[] onlyStatements
private boolean jdbc
private SqlEngineLoader loader
private SqlProcessorLoader processorLoader
Constructor Detail |
---|
public SqlSimpleFactory()
Method Detail |
---|
public void init()
public SqlQueryEngine getQueryEngine(String name)
getQueryEngine
in interface SqlEngineFactory
name
- the name of the required SQL Query Engine instance
public SqlCrudEngine getCrudEngine(String name)
getCrudEngine
in interface SqlEngineFactory
name
- the name of the required SQL CRUD Engine instance
public SqlProcedureEngine getProcedureEngine(String name)
getProcedureEngine
in interface SqlEngineFactory
name
- the name of the required SQL Procedure Engine instance
public List<String> getMetaPropsNames()
public void setMetaPropsNames(List<String> propsNames)
propsNames
- the names of property files, which holds a collection of META SQL statements, mapping rules and
optional featurespublic void setMetaPropsNames(String... propsNames)
propsNames
- the names of property files, which holds a collection of META SQL statements, mapping rules and
optional featurespublic List<String> getMetaFilesNames()
public void setMetaFilesNames(List<String> metaFilesNames)
metaFilesNames
- the names of files, which holds a collection of META SQL statements, mapping rules and optional
featurespublic void setMetaFilesNames(String... metaFilesNames)
metaFilesNames
- the names of files, which holds a collection of META SQL statements, mapping rules and optional
featurespublic Properties getMetaProps()
public void setMetaProps(Properties props)
props
- the collection of the META SQL statements, mapping rules and optional featurespublic StringBuilder getMetaStatements()
public void setMetaStatements(StringBuilder metaStatements)
metaStatements
- the String representation of the META SQL statements, mapping rules and optional featurespublic SqlTypeFactory getTypeFactory()
public void setTypeFactory(SqlTypeFactory typeFactory)
typeFactory
- the factory for the META types constructionpublic String getFilter()
public void setFilter(String filter)
filter
- the name of the filter to filter the META SQL statements, mapping rules and optional featurespublic SqlMonitorFactory getMonitorFactory()
public void setMonitorFactory(SqlMonitorFactory monitorFactory)
monitorFactory
- the monitor factory used in the process of the SQL Monitor instances creationpublic List<SqlInternalType> getCustomTypes()
public void setCustomTypes(List<SqlInternalType> customTypes)
customTypes
- the custom META typespublic void setCustomTypes(SqlInternalType... customTypes)
customTypes
- the custom META typespublic void addCustomType(SqlInternalType customType)
customType
- the custom META typepublic String[] getOnlyStatements()
public void setOnlyStatements(String[] selectQueries)
selectQueries
- the only statements and rules, which are picked up from the properties repositorypublic boolean isJdbc()
public void setJdbc(boolean jdbc)
jdbc
- the indicator the JDBC stack is usedpublic SqlEngineFactory getLoader()
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |