You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ibatis.apache.org by cb...@apache.org on 2007/02/24 23:40:42 UTC
svn commit: r511363 - in
/ibatis/trunk/java/mapper/mapper2/src/com/ibatis/sqlmap/engine/builder/xml:
BaseParser.java ParserState.java SqlMapConfigParser.java SqlMapParser.java
SqlStatementParser.java XmlConverter.java
Author: cbegin
Date: Sat Feb 24 14:40:42 2007
New Revision: 511363
URL: http://svn.apache.org/viewvc?view=rev&rev=511363
Log:
Relatively minor refactorings.
1) Deleted BaseParser - moved Variables and utility methods to ParserState
2) Moved type alias mappings from SqlMapConfigParser to ParserState.
3) Deleted all XML Conversion related classes, methods and constructors (unsupported)
4) Noticed one possible bug, SqlStatementParser was using cache model properties instead of the global properties, so ${this} may not have been working...
5) Renamed properties and other variables in ParserState to hopefully be more clear.
Added:
ibatis/trunk/java/mapper/mapper2/src/com/ibatis/sqlmap/engine/builder/xml/ParserState.java
Removed:
ibatis/trunk/java/mapper/mapper2/src/com/ibatis/sqlmap/engine/builder/xml/BaseParser.java
ibatis/trunk/java/mapper/mapper2/src/com/ibatis/sqlmap/engine/builder/xml/XmlConverter.java
Modified:
ibatis/trunk/java/mapper/mapper2/src/com/ibatis/sqlmap/engine/builder/xml/SqlMapConfigParser.java
ibatis/trunk/java/mapper/mapper2/src/com/ibatis/sqlmap/engine/builder/xml/SqlMapParser.java
ibatis/trunk/java/mapper/mapper2/src/com/ibatis/sqlmap/engine/builder/xml/SqlStatementParser.java
Added: ibatis/trunk/java/mapper/mapper2/src/com/ibatis/sqlmap/engine/builder/xml/ParserState.java
URL: http://svn.apache.org/viewvc/ibatis/trunk/java/mapper/mapper2/src/com/ibatis/sqlmap/engine/builder/xml/ParserState.java?view=auto&rev=511363
==============================================================================
--- ibatis/trunk/java/mapper/mapper2/src/com/ibatis/sqlmap/engine/builder/xml/ParserState.java (added)
+++ ibatis/trunk/java/mapper/mapper2/src/com/ibatis/sqlmap/engine/builder/xml/ParserState.java Sat Feb 24 14:40:42 2007
@@ -0,0 +1,176 @@
+package com.ibatis.sqlmap.engine.builder.xml;
+
+import com.ibatis.common.beans.Probe;
+import com.ibatis.common.beans.ProbeFactory;
+import com.ibatis.common.resources.Resources;
+import com.ibatis.sqlmap.engine.cache.CacheModel;
+import com.ibatis.sqlmap.engine.cache.fifo.FifoCacheController;
+import com.ibatis.sqlmap.engine.cache.lru.LruCacheController;
+import com.ibatis.sqlmap.engine.cache.memory.MemoryCacheController;
+import com.ibatis.sqlmap.engine.datasource.DbcpDataSourceFactory;
+import com.ibatis.sqlmap.engine.datasource.JndiDataSourceFactory;
+import com.ibatis.sqlmap.engine.datasource.SimpleDataSourceFactory;
+import com.ibatis.sqlmap.engine.impl.ExtendedSqlMapClient;
+import com.ibatis.sqlmap.engine.impl.SqlMapExecutorDelegate;
+import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl;
+import com.ibatis.sqlmap.engine.mapping.parameter.BasicParameterMap;
+import com.ibatis.sqlmap.engine.mapping.result.BasicResultMap;
+import com.ibatis.sqlmap.engine.mapping.result.Discriminator;
+import com.ibatis.sqlmap.engine.mapping.statement.MappedStatement;
+import com.ibatis.sqlmap.engine.scope.ErrorContext;
+import com.ibatis.sqlmap.engine.transaction.external.ExternalTransactionConfig;
+import com.ibatis.sqlmap.engine.transaction.jdbc.JdbcTransactionConfig;
+import com.ibatis.sqlmap.engine.transaction.jta.JtaTransactionConfig;
+import com.ibatis.sqlmap.engine.type.*;
+
+import javax.sql.DataSource;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+
+/**
+ * Variables the parser uses. This "struct" like class is necessary because
+ * that's what it is. It's package scope to help protect the public fields from abuse.
+ *
+ * I'm favouring pragmatism in this case rather than OO dogma.
+ *
+ * The public methods are general utility methods that don't modify the state, but may
+ * use the state. They are tolerant of any and all values.
+ */
+class ParserState {
+
+ private static final Probe PROBE = ProbeFactory.getProbe();
+
+ public ErrorContext errorContext = new ErrorContext();
+ public String resource = "SQL Map Config XML File";
+
+ public ExtendedSqlMapClient client;
+ public SqlMapExecutorDelegate delegate;
+ public TypeHandlerFactory typeHandlerFactory;
+
+ //
+ // SQL Map Config
+ //
+
+ public Properties globalProps;
+ public Properties txProps = new Properties();
+ public Properties dsProps = new Properties();
+ public boolean useStatementNamespaces;
+ public Integer defaultStatementTimeout;
+ public DataSource dataSource;
+
+ //
+ // SQL Map State
+ //
+
+ public String namespace;
+
+ public CacheModel cacheModel;
+ public Properties cacheProps;
+
+ public BasicResultMap resultMap;
+ public List resultMappingList;
+ public int resultMappingIndex;
+ public Discriminator discriminator;
+
+ public BasicParameterMap parameterMap;
+ public List parameterMappingList;
+
+ public Map sqlIncludes = new HashMap();
+ public MappedStatement currentStatement;
+
+ public ParserState() {
+ delegate = new SqlMapExecutorDelegate();
+ typeHandlerFactory = delegate.getTypeHandlerFactory();
+ client = new SqlMapClientImpl(delegate);
+ useStatementNamespaces = false;
+ registerDefaultTypeAliases();
+ }
+
+ //
+ // Utility Methods
+ //
+
+ public TypeHandler resolveTypeHandler(TypeHandlerFactory typeHandlerFactory, Class clazz, String propertyName, String javaType, String jdbcType) {
+ return resolveTypeHandler(typeHandlerFactory, clazz, propertyName, javaType, jdbcType, false);
+ }
+
+ public TypeHandler resolveTypeHandler(TypeHandlerFactory typeHandlerFactory, Class clazz, String propertyName, String javaType, String jdbcType, boolean useSetterToResolve) {
+ TypeHandler handler;
+ if (clazz == null) {
+ // Unknown
+ handler = typeHandlerFactory.getUnkownTypeHandler();
+ } else if (DomTypeMarker.class.isAssignableFrom(clazz)) {
+ // DOM
+ handler = typeHandlerFactory.getTypeHandler(String.class, jdbcType);
+ } else if (java.util.Map.class.isAssignableFrom(clazz)) {
+ // Map
+ if (javaType == null) {
+ handler = typeHandlerFactory.getUnkownTypeHandler(); //BUG 1012591 - typeHandlerFactory.getTypeHandler(java.lang.Object.class, jdbcType);
+ } else {
+ try {
+ Class javaClass = Resources.classForName(javaType);
+ handler = typeHandlerFactory.getTypeHandler(javaClass, jdbcType);
+ } catch (Exception e) {
+ throw new RuntimeException("Error. Could not set TypeHandler. Cause: " + e, e);
+ }
+ }
+ } else if (typeHandlerFactory.getTypeHandler(clazz, jdbcType) != null) {
+ // Primitive
+ handler = typeHandlerFactory.getTypeHandler(clazz, jdbcType);
+ } else {
+ // JavaBean
+ if (javaType == null) {
+ if (useSetterToResolve) {
+ Class type = PROBE.getPropertyTypeForSetter(clazz, propertyName);
+ handler = typeHandlerFactory.getTypeHandler(type, jdbcType);
+ } else {
+ Class type = PROBE.getPropertyTypeForGetter(clazz, propertyName);
+ handler = typeHandlerFactory.getTypeHandler(type, jdbcType);
+ }
+ } else {
+ try {
+ Class javaClass = Resources.classForName(javaType);
+ handler = typeHandlerFactory.getTypeHandler(javaClass, jdbcType);
+ } catch (Exception e) {
+ throw new RuntimeException("Error. Could not set TypeHandler. Cause: " + e, e);
+ }
+ }
+ }
+ return handler;
+ }
+
+ public String applyNamespace(String id) {
+ String newId = id;
+ if (namespace != null && namespace.length() > 0 && id != null && id.indexOf('.') < 0) {
+ newId = namespace + "." + id;
+ }
+ return newId;
+ }
+
+ private void registerDefaultTypeAliases() {
+ // TRANSACTION ALIASES
+ typeHandlerFactory.putTypeAlias("JDBC", JdbcTransactionConfig.class.getName());
+ typeHandlerFactory.putTypeAlias("JTA", JtaTransactionConfig.class.getName());
+ typeHandlerFactory.putTypeAlias("EXTERNAL", ExternalTransactionConfig.class.getName());
+
+ // DATA SOURCE ALIASES
+ typeHandlerFactory.putTypeAlias("SIMPLE", SimpleDataSourceFactory.class.getName());
+ typeHandlerFactory.putTypeAlias("DBCP", DbcpDataSourceFactory.class.getName());
+ typeHandlerFactory.putTypeAlias("JNDI", JndiDataSourceFactory.class.getName());
+
+ // CACHE ALIASES
+ typeHandlerFactory.putTypeAlias("FIFO", FifoCacheController.class.getName());
+ typeHandlerFactory.putTypeAlias("LRU", LruCacheController.class.getName());
+ typeHandlerFactory.putTypeAlias("MEMORY", MemoryCacheController.class.getName());
+ // use a string for OSCache to avoid unnecessary loading of properties upon init
+ typeHandlerFactory.putTypeAlias("OSCACHE", "com.ibatis.sqlmap.engine.cache.oscache.OSCacheController");
+
+ // TYPE ALIASEs
+ typeHandlerFactory.putTypeAlias("dom", DomTypeMarker.class.getName());
+ typeHandlerFactory.putTypeAlias("domCollection", DomCollectionTypeMarker.class.getName());
+ typeHandlerFactory.putTypeAlias("xml", XmlTypeMarker.class.getName());
+ typeHandlerFactory.putTypeAlias("xmlCollection", XmlCollectionTypeMarker.class.getName());
+ }
+}
Modified: ibatis/trunk/java/mapper/mapper2/src/com/ibatis/sqlmap/engine/builder/xml/SqlMapConfigParser.java
URL: http://svn.apache.org/viewvc/ibatis/trunk/java/mapper/mapper2/src/com/ibatis/sqlmap/engine/builder/xml/SqlMapConfigParser.java?view=diff&rev=511363&r1=511362&r2=511363
==============================================================================
--- ibatis/trunk/java/mapper/mapper2/src/com/ibatis/sqlmap/engine/builder/xml/SqlMapConfigParser.java (original)
+++ ibatis/trunk/java/mapper/mapper2/src/com/ibatis/sqlmap/engine/builder/xml/SqlMapConfigParser.java Sat Feb 24 14:40:42 2007
@@ -1,34 +1,23 @@
package com.ibatis.sqlmap.engine.builder.xml;
+import com.ibatis.common.beans.ClassInfo;
import com.ibatis.common.resources.Resources;
import com.ibatis.common.xml.Nodelet;
import com.ibatis.common.xml.NodeletParser;
import com.ibatis.common.xml.NodeletUtils;
-
-import com.ibatis.common.beans.ClassInfo;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapException;
import com.ibatis.sqlmap.client.extensions.TypeHandlerCallback;
import com.ibatis.sqlmap.engine.accessplan.AccessPlanFactory;
import com.ibatis.sqlmap.engine.cache.CacheModel;
-import com.ibatis.sqlmap.engine.cache.fifo.FifoCacheController;
-import com.ibatis.sqlmap.engine.cache.lru.LruCacheController;
-import com.ibatis.sqlmap.engine.cache.memory.MemoryCacheController;
import com.ibatis.sqlmap.engine.datasource.DataSourceFactory;
-import com.ibatis.sqlmap.engine.datasource.DbcpDataSourceFactory;
-import com.ibatis.sqlmap.engine.datasource.JndiDataSourceFactory;
-import com.ibatis.sqlmap.engine.datasource.SimpleDataSourceFactory;
-import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl;
-import com.ibatis.sqlmap.engine.impl.SqlMapExecutorDelegate;
import com.ibatis.sqlmap.engine.mapping.result.ResultObjectFactory;
import com.ibatis.sqlmap.engine.mapping.statement.MappedStatement;
import com.ibatis.sqlmap.engine.transaction.TransactionConfig;
import com.ibatis.sqlmap.engine.transaction.TransactionManager;
-import com.ibatis.sqlmap.engine.transaction.external.ExternalTransactionConfig;
-import com.ibatis.sqlmap.engine.transaction.jdbc.JdbcTransactionConfig;
-import com.ibatis.sqlmap.engine.transaction.jta.JtaTransactionConfig;
-import com.ibatis.sqlmap.engine.type.*;
-
+import com.ibatis.sqlmap.engine.type.CustomTypeHandler;
+import com.ibatis.sqlmap.engine.type.TypeHandler;
+import com.ibatis.sqlmap.engine.type.TypeHandlerFactory;
import org.w3c.dom.Node;
import java.io.InputStream;
@@ -36,29 +25,17 @@
import java.util.Iterator;
import java.util.Properties;
-public class SqlMapConfigParser extends BaseParser {
+public class SqlMapConfigParser {
protected final NodeletParser parser = new NodeletParser();
- private boolean usingStreams;
+ private ParserState state = new ParserState();
- public SqlMapConfigParser() {
- this(null, null);
- }
+ private boolean usingStreams = false;
- public SqlMapConfigParser(XmlConverter sqlMapConfigConv, XmlConverter sqlMapConv) {
- super(new Variables());
+ public SqlMapConfigParser() {
parser.setValidation(true);
parser.setEntityResolver(new SqlMapClasspathEntityResolver());
- vars.sqlMapConfigConv = sqlMapConfigConv;
- vars.sqlMapConv = sqlMapConv;
-
- vars.delegate = new SqlMapExecutorDelegate();
- vars.typeHandlerFactory = vars.delegate.getTypeHandlerFactory();
- vars.client = new SqlMapClientImpl(vars.delegate);
-
- registerDefaultTypeAliases();
-
addSqlMapConfigNodelets();
addGlobalPropNodelets();
addSettingsNodelets();
@@ -71,40 +48,32 @@
}
public SqlMapClient parse(Reader reader, Properties props) {
- vars.properties = props;
+ state.globalProps = props;
return parse(reader);
}
public SqlMapClient parse(Reader reader) {
try {
- if (vars.sqlMapConfigConv != null) {
- reader = vars.sqlMapConfigConv.convertXml(reader);
- }
-
usingStreams = false;
parser.parse(reader);
- return vars.client;
+ return state.client;
} catch (Exception e) {
throw new RuntimeException("Error occurred. Cause: " + e, e);
}
}
public SqlMapClient parse(InputStream inputStream, Properties props) {
- vars.properties = props;
+ state.globalProps = props;
return parse(inputStream);
}
public SqlMapClient parse(InputStream inputStream) {
try {
- if (vars.sqlMapConfigConv != null) {
- inputStream = vars.sqlMapConfigConv.convertXml(inputStream);
- }
-
usingStreams = true;
parser.parse(inputStream);
- return vars.client;
+ return state.client;
} catch (Exception e) {
throw new RuntimeException("Error occurred. Cause: " + e, e);
}
@@ -113,15 +82,15 @@
private void addSqlMapConfigNodelets() {
parser.addNodelet("/sqlMapConfig/end()", new Nodelet() {
public void process(Node node) throws Exception {
- Iterator cacheNames = vars.client.getDelegate().getCacheModelNames();
+ Iterator cacheNames = state.client.getDelegate().getCacheModelNames();
while (cacheNames.hasNext()) {
String cacheName = (String) cacheNames.next();
- CacheModel cacheModel = vars.client.getDelegate().getCacheModel(cacheName);
+ CacheModel cacheModel = state.client.getDelegate().getCacheModel(cacheName);
Iterator statementNames = cacheModel.getFlushTriggerStatementNames();
while (statementNames.hasNext()) {
String statementName = (String) statementNames.next();
- MappedStatement statement = vars.client.getDelegate().getMappedStatement(statementName);
+ MappedStatement statement = state.client.getDelegate().getMappedStatement(statementName);
if (statement != null) {
statement.addExecuteListener(cacheModel);
} else {
@@ -136,29 +105,29 @@
private void addGlobalPropNodelets() {
parser.addNodelet("/sqlMapConfig/properties", new Nodelet() {
public void process(Node node) throws Exception {
- vars.errorCtx.setActivity("loading global properties");
+ state.errorContext.setActivity("loading global properties");
- Properties attributes = NodeletUtils.parseAttributes(node,vars.properties);
+ Properties attributes = NodeletUtils.parseAttributes(node, state.globalProps);
String resource = attributes.getProperty("resource");
String url = attributes.getProperty("url");
try {
Properties props = null;
if (resource != null) {
- vars.errorCtx.setResource(resource);
+ state.errorContext.setResource(resource);
props = Resources.getResourceAsProperties(resource);
} else if (url != null) {
- vars.errorCtx.setResource(url);
+ state.errorContext.setResource(url);
props = Resources.getUrlAsProperties(url);
} else {
throw new RuntimeException("The " + "properties" + " element requires either a resource or a url attribute.");
}
- if (vars.properties == null) {
- vars.properties = props;
+ if (state.globalProps == null) {
+ state.globalProps = props;
} else {
- props.putAll(vars.properties);
- vars.properties = props;
+ props.putAll(state.globalProps);
+ state.globalProps = props;
}
} catch (Exception e) {
throw new RuntimeException("Error loading properties. Cause: " + e);
@@ -170,9 +139,9 @@
private void addSettingsNodelets() {
parser.addNodelet("/sqlMapConfig/settings", new Nodelet() {
public void process(Node node) throws Exception {
- vars.errorCtx.setActivity("loading settings properties");
+ state.errorContext.setActivity("loading settings properties");
- Properties attributes = NodeletUtils.parseAttributes(node, vars.properties);
+ Properties attributes = NodeletUtils.parseAttributes(node, state.globalProps);
String classInfoCacheEnabledAttr = attributes.getProperty("classInfoCacheEnabled");
boolean classInfoCacheEnabled = (classInfoCacheEnabledAttr == null || "true".equals(classInfoCacheEnabledAttr));
@@ -180,15 +149,15 @@
String lazyLoadingEnabledAttr = attributes.getProperty("lazyLoadingEnabled");
boolean lazyLoadingEnabled = (lazyLoadingEnabledAttr == null || "true".equals(lazyLoadingEnabledAttr));
- vars.client.getDelegate().setLazyLoadingEnabled(lazyLoadingEnabled);
+ state.client.getDelegate().setLazyLoadingEnabled(lazyLoadingEnabled);
String statementCachingEnabledAttr = attributes.getProperty("statementCachingEnabled");
boolean statementCachingEnabled = (statementCachingEnabledAttr == null || "true".equals(statementCachingEnabledAttr));
- vars.client.getDelegate().setStatementCacheEnabled(statementCachingEnabled);
+ state.client.getDelegate().setStatementCacheEnabled(statementCachingEnabled);
String cacheModelsEnabledAttr = attributes.getProperty("cacheModelsEnabled");
boolean cacheModelsEnabled = (cacheModelsEnabledAttr == null || "true".equals(cacheModelsEnabledAttr));
- vars.client.getDelegate().setCacheModelsEnabled(cacheModelsEnabled);
+ state.client.getDelegate().setCacheModelsEnabled(cacheModelsEnabled);
String enhancementEnabledAttr = attributes.getProperty("enhancementEnabled");
boolean enhancementEnabled = (enhancementEnabledAttr == null || "true".equals(enhancementEnabledAttr));
@@ -197,33 +166,33 @@
} catch (ClassNotFoundException e) {
enhancementEnabled = false;
}
- vars.client.getDelegate().setEnhancementEnabled(enhancementEnabled);
+ state.client.getDelegate().setEnhancementEnabled(enhancementEnabled);
String useStatementNamespacesAttr = attributes.getProperty("useStatementNamespaces");
- vars.useStatementNamespaces = ("true".equals(useStatementNamespacesAttr));
+ state.useStatementNamespaces = ("true".equals(useStatementNamespacesAttr));
String maxTransactions = attributes.getProperty("maxTransactions");
if (maxTransactions != null && Integer.parseInt(maxTransactions) > 0) {
- vars.client.getDelegate().setMaxTransactions(Integer.parseInt(maxTransactions));
+ state.client.getDelegate().setMaxTransactions(Integer.parseInt(maxTransactions));
}
String maxRequests = attributes.getProperty("maxRequests");
if (maxRequests != null && Integer.parseInt(maxRequests) > 0) {
- vars.client.getDelegate().setMaxRequests(Integer.parseInt(maxRequests));
+ state.client.getDelegate().setMaxRequests(Integer.parseInt(maxRequests));
}
String maxSessions = attributes.getProperty("maxSessions");
if (maxSessions != null && Integer.parseInt(maxSessions) > 0) {
- vars.client.getDelegate().setMaxSessions(Integer.parseInt(maxSessions));
+ state.client.getDelegate().setMaxSessions(Integer.parseInt(maxSessions));
}
- AccessPlanFactory.setBytecodeEnhancementEnabled(vars.client.getDelegate().isEnhancementEnabled());
+ AccessPlanFactory.setBytecodeEnhancementEnabled(state.client.getDelegate().isEnhancementEnabled());
String defaultStatementTimeout = attributes.getProperty("defaultStatementTimeout");
if (defaultStatementTimeout != null) {
try {
Integer defaultTimeout = Integer.valueOf(defaultStatementTimeout);
- vars.defaultStatementTimeout = defaultTimeout;
+ state.defaultStatementTimeout = defaultTimeout;
} catch (NumberFormatException e) {
throw new SqlMapException("Specified defaultStatementTimeout is not a valid integer");
}
@@ -235,10 +204,10 @@
private void addTypeAliasNodelets() {
parser.addNodelet("/sqlMapConfig/typeAlias", new Nodelet() {
public void process(Node node) throws Exception {
- Properties prop = NodeletUtils.parseAttributes(node, vars.properties);
+ Properties prop = NodeletUtils.parseAttributes(node, state.globalProps);
String alias = prop.getProperty("alias");
String type = prop.getProperty("type");
- vars.typeHandlerFactory.putTypeAlias(alias, type);
+ state.typeHandlerFactory.putTypeAlias(alias, type);
}
});
}
@@ -246,11 +215,11 @@
private void addTypeHandlerNodelets() {
parser.addNodelet("/sqlMapConfig/typeHandler", new Nodelet() {
public void process(Node node) throws Exception {
- vars.errorCtx.setActivity("building a building custom type handler");
+ state.errorContext.setActivity("building a building custom type handler");
try {
- TypeHandlerFactory typeHandlerFactory = vars.client.getDelegate().getTypeHandlerFactory();
+ TypeHandlerFactory typeHandlerFactory = state.client.getDelegate().getTypeHandlerFactory();
- Properties prop = NodeletUtils.parseAttributes(node, vars.properties);
+ Properties prop = NodeletUtils.parseAttributes(node, state.globalProps);
String jdbcType = prop.getProperty("jdbcType");
String javaType = prop.getProperty("javaType");
@@ -258,7 +227,7 @@
callback = typeHandlerFactory.resolveAlias(callback);
javaType = typeHandlerFactory.resolveAlias(javaType);
- vars.errorCtx.setMoreInfo("Check the callback attribute '" + callback + "' (must be a classname).");
+ state.errorContext.setMoreInfo("Check the callback attribute '" + callback + "' (must be a classname).");
TypeHandler typeHandler;
Object impl = Resources.instantiate(callback);
@@ -270,7 +239,7 @@
throw new RuntimeException ("The class '' is not a valid implementation of TypeHandler or TypeHandlerCallback");
}
- vars.errorCtx.setMoreInfo("Check the javaType attribute '" + javaType + "' (must be a classname) or the jdbcType '" + jdbcType + "' (must be a JDBC type name).");
+ state.errorContext.setMoreInfo("Check the javaType attribute '" + javaType + "' (must be a classname) or the jdbcType '" + jdbcType + "' (must be a JDBC type name).");
if (jdbcType != null && jdbcType.length() > 0) {
typeHandlerFactory.register(Resources.classForName(javaType), jdbcType, typeHandler);
} else {
@@ -279,8 +248,8 @@
} catch (Exception e) {
throw new SqlMapException("Error registering occurred. Cause: " + e, e);
}
- vars.errorCtx.setMoreInfo(null);
- vars.errorCtx.setObjectId(null);
+ state.errorContext.setMoreInfo(null);
+ state.errorContext.setObjectId(null);
}
});
}
@@ -288,23 +257,23 @@
private void addTransactionManagerNodelets() {
parser.addNodelet("/sqlMapConfig/transactionManager/end()", new Nodelet() {
public void process(Node node) throws Exception {
- vars.errorCtx.setActivity("configuring the transaction manager");
+ state.errorContext.setActivity("configuring the transaction manager");
- Properties attributes = NodeletUtils.parseAttributes(node, vars.properties);
+ Properties attributes = NodeletUtils.parseAttributes(node, state.globalProps);
String type = attributes.getProperty("type");
- type = vars.typeHandlerFactory.resolveAlias(type);
+ type = state.typeHandlerFactory.resolveAlias(type);
TransactionManager txManager = null;
try {
- vars.errorCtx.setMoreInfo("Check the transaction manager type or class.");
+ state.errorContext.setMoreInfo("Check the transaction manager type or class.");
TransactionConfig config = (TransactionConfig) Resources.instantiate(type);
- config.setDataSource(vars.dataSource);
- config.setMaximumConcurrentTransactions(vars.client.getDelegate().getMaxTransactions());
- vars.errorCtx.setMoreInfo("Check the transactio nmanager properties or configuration.");
- config.initialize(vars.txProps);
- vars.errorCtx.setMoreInfo(null);
+ config.setDataSource(state.dataSource);
+ config.setMaximumConcurrentTransactions(state.client.getDelegate().getMaxTransactions());
+ state.errorContext.setMoreInfo("Check the transactio nmanager properties or configuration.");
+ config.initialize(state.txProps);
+ state.errorContext.setMoreInfo(null);
txManager = new TransactionManager(config);
txManager.setForceCommit("true".equals(attributes.getProperty("commitRequired")));
} catch (Exception e) {
@@ -315,38 +284,38 @@
}
}
- vars.client.getDelegate().setTxManager(txManager);
+ state.client.getDelegate().setTxManager(txManager);
}
});
parser.addNodelet("/sqlMapConfig/transactionManager/property", new Nodelet() {
public void process(Node node) throws Exception {
- Properties attributes = NodeletUtils.parseAttributes(node, vars.properties);
+ Properties attributes = NodeletUtils.parseAttributes(node, state.globalProps);
String name = attributes.getProperty("name");
- String value = NodeletUtils.parsePropertyTokens(attributes.getProperty("value"), vars.properties);
- vars.txProps.setProperty(name, value);
+ String value = NodeletUtils.parsePropertyTokens(attributes.getProperty("value"), state.globalProps);
+ state.txProps.setProperty(name, value);
}
});
parser.addNodelet("/sqlMapConfig/transactionManager/dataSource", new Nodelet() {
public void process(Node node) throws Exception {
- vars.dsProps = new Properties();
+ state.dsProps = new Properties();
}
});
parser.addNodelet("/sqlMapConfig/transactionManager/dataSource/end()", new Nodelet() {
public void process(Node node) throws Exception {
- vars.errorCtx.setActivity("configuring the data source");
+ state.errorContext.setActivity("configuring the data source");
- Properties attributes = NodeletUtils.parseAttributes(node, vars.properties);
+ Properties attributes = NodeletUtils.parseAttributes(node, state.globalProps);
String type = attributes.getProperty("type");
- type = vars.typeHandlerFactory.resolveAlias(type);
+ type = state.typeHandlerFactory.resolveAlias(type);
try {
- vars.errorCtx.setMoreInfo("Check the data source type or class.");
+ state.errorContext.setMoreInfo("Check the data source type or class.");
DataSourceFactory dsFactory = (DataSourceFactory) Resources.instantiate(type);
- vars.errorCtx.setMoreInfo("Check the data source properties or configuration.");
- dsFactory.initialize(vars.dsProps);
- vars.dataSource = dsFactory.getDataSource();
- vars.errorCtx.setMoreInfo(null);
+ state.errorContext.setMoreInfo("Check the data source properties or configuration.");
+ dsFactory.initialize(state.dsProps);
+ state.dataSource = dsFactory.getDataSource();
+ state.errorContext.setMoreInfo(null);
} catch (Exception e) {
if (e instanceof SqlMapException) {
throw (SqlMapException) e;
@@ -358,10 +327,10 @@
});
parser.addNodelet("/sqlMapConfig/transactionManager/dataSource/property", new Nodelet() {
public void process(Node node) throws Exception {
- Properties attributes = NodeletUtils.parseAttributes(node, vars.properties);
+ Properties attributes = NodeletUtils.parseAttributes(node, state.globalProps);
String name = attributes.getProperty("name");
- String value = NodeletUtils.parsePropertyTokens(attributes.getProperty("value"), vars.properties);
- vars.dsProps.setProperty(name, value);
+ String value = NodeletUtils.parsePropertyTokens(attributes.getProperty("value"), state.globalProps);
+ state.dsProps.setProperty(name, value);
}
});
}
@@ -369,9 +338,9 @@
protected void addSqlMapNodelets() {
parser.addNodelet("/sqlMapConfig/sqlMap", new Nodelet() {
public void process(Node node) throws Exception {
- vars.errorCtx.setActivity("loading the SQL Map resource");
+ state.errorContext.setActivity("loading the SQL Map resource");
- Properties attributes = NodeletUtils.parseAttributes(node, vars.properties);
+ Properties attributes = NodeletUtils.parseAttributes(node, state.globalProps);
String resource = attributes.getProperty("resource");
String url = attributes.getProperty("url");
@@ -379,35 +348,29 @@
if (usingStreams) {
InputStream inputStream = null;
if (resource != null) {
- vars.errorCtx.setResource(resource);
+ state.errorContext.setResource(resource);
inputStream = Resources.getResourceAsStream(resource);
} else if (url != null) {
- vars.errorCtx.setResource(url);
+ state.errorContext.setResource(url);
inputStream = Resources.getUrlAsStream(url);
} else {
throw new SqlMapException("The <sqlMap> element requires either a resource or a url attribute.");
}
- if (vars.sqlMapConv != null) {
- inputStream = vars.sqlMapConv.convertXml(inputStream);
- }
- new SqlMapParser(vars).parse(inputStream);
+ new SqlMapParser(state).parse(inputStream);
} else {
Reader reader = null;
if (resource != null) {
- vars.errorCtx.setResource(resource);
+ state.errorContext.setResource(resource);
reader = Resources.getResourceAsReader(resource);
} else if (url != null) {
- vars.errorCtx.setResource(url);
+ state.errorContext.setResource(url);
reader = Resources.getUrlAsReader(url);
} else {
throw new SqlMapException("The <sqlMap> element requires either a resource or a url attribute.");
}
- if (vars.sqlMapConv != null) {
- reader = vars.sqlMapConv.convertXml(reader);
- }
- new SqlMapParser(vars).parse(reader);
+ new SqlMapParser(state).parse(reader);
}
}
});
@@ -416,16 +379,16 @@
private void addResultObjectFactoryNodelets() {
parser.addNodelet("/sqlMapConfig/resultObjectFactory", new Nodelet() {
public void process(Node node) throws Exception {
- vars.errorCtx.setActivity("configuring the Result Object Factory");
+ state.errorContext.setActivity("configuring the Result Object Factory");
- Properties attributes = NodeletUtils.parseAttributes(node, vars.properties);
+ Properties attributes = NodeletUtils.parseAttributes(node, state.globalProps);
String type = attributes.getProperty("type");
ResultObjectFactory rof;
try {
rof = (ResultObjectFactory) Resources.instantiate(type);
- vars.delegate.setResultObjectFactory(rof);
+ state.delegate.setResultObjectFactory(rof);
} catch (Exception e) {
throw new SqlMapException("Error instantiating resultObjectFactory: " + type, e);
}
@@ -433,37 +396,12 @@
});
parser.addNodelet("/sqlMapConfig/resultObjectFactory/property", new Nodelet() {
public void process(Node node) throws Exception {
- Properties attributes = NodeletUtils.parseAttributes(node, vars.properties);
+ Properties attributes = NodeletUtils.parseAttributes(node, state.globalProps);
String name = attributes.getProperty("name");
- String value = NodeletUtils.parsePropertyTokens(attributes.getProperty("value"), vars.properties);
- vars.delegate.getResultObjectFactory().setProperty(name, value);
+ String value = NodeletUtils.parsePropertyTokens(attributes.getProperty("value"), state.globalProps);
+ state.delegate.getResultObjectFactory().setProperty(name, value);
}
});
}
- private void registerDefaultTypeAliases() {
- // TRANSACTION ALIASES
- vars.typeHandlerFactory.putTypeAlias("JDBC", JdbcTransactionConfig.class.getName());
- vars.typeHandlerFactory.putTypeAlias("JTA", JtaTransactionConfig.class.getName());
- vars.typeHandlerFactory.putTypeAlias("EXTERNAL", ExternalTransactionConfig.class.getName());
-
- // DATA SOURCE ALIASES
- vars.typeHandlerFactory.putTypeAlias("SIMPLE", SimpleDataSourceFactory.class.getName());
- vars.typeHandlerFactory.putTypeAlias("DBCP", DbcpDataSourceFactory.class.getName());
- vars.typeHandlerFactory.putTypeAlias("JNDI", JndiDataSourceFactory.class.getName());
-
- // CACHE ALIASES
- vars.typeHandlerFactory.putTypeAlias("FIFO", FifoCacheController.class.getName());
- vars.typeHandlerFactory.putTypeAlias("LRU", LruCacheController.class.getName());
- vars.typeHandlerFactory.putTypeAlias("MEMORY", MemoryCacheController.class.getName());
- // use a string for OSCache to avoid unnecessary loading of properties upon init
- vars.typeHandlerFactory.putTypeAlias("OSCACHE", "com.ibatis.sqlmap.engine.cache.oscache.OSCacheController");
-
- // TYPE ALIASEs
- vars.typeHandlerFactory.putTypeAlias("dom", DomTypeMarker.class.getName());
- vars.typeHandlerFactory.putTypeAlias("domCollection", DomCollectionTypeMarker.class.getName());
- vars.typeHandlerFactory.putTypeAlias("xml", XmlTypeMarker.class.getName());
- vars.typeHandlerFactory.putTypeAlias("xmlCollection", XmlCollectionTypeMarker.class.getName());
- }
-
}
Modified: ibatis/trunk/java/mapper/mapper2/src/com/ibatis/sqlmap/engine/builder/xml/SqlMapParser.java
URL: http://svn.apache.org/viewvc/ibatis/trunk/java/mapper/mapper2/src/com/ibatis/sqlmap/engine/builder/xml/SqlMapParser.java?view=diff&rev=511363&r1=511362&r2=511363
==============================================================================
--- ibatis/trunk/java/mapper/mapper2/src/com/ibatis/sqlmap/engine/builder/xml/SqlMapParser.java (original)
+++ ibatis/trunk/java/mapper/mapper2/src/com/ibatis/sqlmap/engine/builder/xml/SqlMapParser.java Sat Feb 24 14:40:42 2007
@@ -1,13 +1,11 @@
package com.ibatis.sqlmap.engine.builder.xml;
-import com.ibatis.common.logging.Log;
-import com.ibatis.common.logging.LogFactory;
import com.ibatis.common.resources.Resources;
import com.ibatis.common.xml.Nodelet;
import com.ibatis.common.xml.NodeletException;
import com.ibatis.common.xml.NodeletParser;
import com.ibatis.common.xml.NodeletUtils;
-
+import com.ibatis.sqlmap.client.SqlMapException;
import com.ibatis.sqlmap.client.extensions.TypeHandlerCallback;
import com.ibatis.sqlmap.engine.cache.CacheModel;
import com.ibatis.sqlmap.engine.mapping.parameter.BasicParameterMap;
@@ -20,20 +18,15 @@
import java.io.InputStream;
import java.io.Reader;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Properties;
-import java.util.StringTokenizer;
-import java.util.Iterator;
-
-public class SqlMapParser extends BaseParser {
+import java.util.*;
- private static final Log log = LogFactory.getLog(SqlMapParser.class);
+public class SqlMapParser {
- protected final NodeletParser parser = new NodeletParser();
+ private final NodeletParser parser = new NodeletParser();
+ private ParserState state;
- public SqlMapParser(Variables vars) {
- super(vars);
+ public SqlMapParser(ParserState state) {
+ this.state = state;
parser.setValidation(true);
parser.setEntityResolver(new SqlMapClasspathEntityResolver());
@@ -58,16 +51,16 @@
private void addSqlMapNodelets() {
parser.addNodelet("/sqlMap", new Nodelet() {
public void process(Node node) throws Exception {
- Properties attributes = NodeletUtils.parseAttributes(node, vars.properties);
- vars.currentNamespace = attributes.getProperty("namespace");
+ Properties attributes = NodeletUtils.parseAttributes(node, state.globalProps);
+ state.namespace = attributes.getProperty("namespace");
}
});
parser.addNodelet("/sqlMap/end()", new Nodelet() {
public void process(Node node) throws Exception {
- Iterator names = vars.delegate.getResultMapNames();
+ Iterator names = state.delegate.getResultMapNames();
while (names.hasNext()) {
String name = (String)names.next();
- ResultMap rm = vars.delegate.getResultMap(name);
+ ResultMap rm = state.delegate.getResultMap(name);
Discriminator disc = rm.getDiscriminator();
if (disc != null) {
disc.bindSubMaps();
@@ -80,17 +73,16 @@
private void addSqlNodelets() {
parser.addNodelet("/sqlMap/sql", new Nodelet() {
public void process(Node node) throws Exception {
- Properties attributes = NodeletUtils.parseAttributes(node, vars.properties);
+ Properties attributes = NodeletUtils.parseAttributes(node, state.globalProps);
String id = attributes.getProperty("id");
- if (vars.useStatementNamespaces) {
- id = applyNamespace(id);
+ if (state.useStatementNamespaces) {
+ id = state.applyNamespace(id);
}
- if (vars.sqlIncludes.containsKey(id)) {
- // To be upgraded to throwing of a RuntimeException later on
- log.warn("Duplicate <sql>-include '" + id + "' found.");
+ if (state.sqlIncludes.containsKey(id)) {
+ throw new SqlMapException("Duplicate <sql>-include '" + id + "' found.");
}
else {
- vars.sqlIncludes.put(id, node);
+ state.sqlIncludes.put(id, node);
}
}
});
@@ -99,10 +91,10 @@
private void addTypeAliasNodelets() {
parser.addNodelet("/sqlMap/typeAlias", new Nodelet() {
public void process(Node node) throws Exception {
- Properties prop = NodeletUtils.parseAttributes(node, vars.properties);
+ Properties prop = NodeletUtils.parseAttributes(node, state.globalProps);
String alias = prop.getProperty("alias");
String type = prop.getProperty("type");
- vars.typeHandlerFactory.putTypeAlias(alias, type);
+ state.typeHandlerFactory.putTypeAlias(alias, type);
}
});
}
@@ -110,80 +102,80 @@
private void addCacheModelNodelets() {
parser.addNodelet("/sqlMap/cacheModel", new Nodelet() {
public void process(Node node) throws Exception {
- vars.currentCacheModel = new CacheModel();
- vars.currentProperties = new Properties();
+ state.cacheModel = new CacheModel();
+ state.cacheProps = new Properties();
}
});
parser.addNodelet("/sqlMap/cacheModel/end()", new Nodelet() {
public void process(Node node) throws Exception {
- vars.errorCtx.setActivity("building a cache model");
+ state.errorContext.setActivity("building a cache model");
- Properties attributes = NodeletUtils.parseAttributes(node, vars.properties);
- String id = applyNamespace(attributes.getProperty("id"));
+ Properties attributes = NodeletUtils.parseAttributes(node, state.globalProps);
+ String id = state.applyNamespace(attributes.getProperty("id"));
String type = attributes.getProperty("type");
- type = vars.typeHandlerFactory.resolveAlias(type);
+ type = state.typeHandlerFactory.resolveAlias(type);
String readOnly = attributes.getProperty("readOnly");
if (readOnly != null && readOnly.length() > 0) {
- vars.currentCacheModel.setReadOnly("true".equals(readOnly));
+ state.cacheModel.setReadOnly("true".equals(readOnly));
} else {
- vars.currentCacheModel.setReadOnly(true);
+ state.cacheModel.setReadOnly(true);
}
String serialize = attributes.getProperty("serialize");
if (serialize != null && serialize.length() > 0) {
- vars.currentCacheModel.setSerialize("true".equals(serialize));
+ state.cacheModel.setSerialize("true".equals(serialize));
} else {
- vars.currentCacheModel.setSerialize(false);
+ state.cacheModel.setSerialize(false);
}
- vars.errorCtx.setObjectId(id + " cache model");
+ state.errorContext.setObjectId(id + " cache model");
- vars.errorCtx.setMoreInfo("Check the cache model type.");
- vars.currentCacheModel.setId(id);
- vars.currentCacheModel.setResource(vars.errorCtx.getResource());
+ state.errorContext.setMoreInfo("Check the cache model type.");
+ state.cacheModel.setId(id);
+ state.cacheModel.setResource(state.errorContext.getResource());
try {
- vars.currentCacheModel.setControllerClassName(type);
+ state.cacheModel.setControllerClassName(type);
} catch (Exception e) {
throw new RuntimeException("Error setting Cache Controller Class. Cause: " + e, e);
}
- vars.errorCtx.setMoreInfo("Check the cache model configuration.");
- vars.currentCacheModel.configure(vars.currentProperties);
+ state.errorContext.setMoreInfo("Check the cache model configuration.");
+ state.cacheModel.configure(state.cacheProps);
- if (vars.client.getDelegate().isCacheModelsEnabled()) {
- vars.client.getDelegate().addCacheModel(vars.currentCacheModel);
+ if (state.client.getDelegate().isCacheModelsEnabled()) {
+ state.client.getDelegate().addCacheModel(state.cacheModel);
}
- vars.errorCtx.setMoreInfo(null);
- vars.errorCtx.setObjectId(null);
- vars.currentProperties = null;
- vars.currentCacheModel = null;
+ state.errorContext.setMoreInfo(null);
+ state.errorContext.setObjectId(null);
+ state.cacheProps = null;
+ state.cacheModel = null;
}
});
parser.addNodelet("/sqlMap/cacheModel/property", new Nodelet() {
public void process(Node node) throws Exception {
- vars.errorCtx.setMoreInfo("Check the cache model properties.");
- Properties attributes = NodeletUtils.parseAttributes(node, vars.properties);
+ state.errorContext.setMoreInfo("Check the cache model properties.");
+ Properties attributes = NodeletUtils.parseAttributes(node, state.globalProps);
String name = attributes.getProperty("name");
- String value = NodeletUtils.parsePropertyTokens(attributes.getProperty("value"), vars.properties);
- vars.currentProperties.put(name, value);
+ String value = NodeletUtils.parsePropertyTokens(attributes.getProperty("value"), state.globalProps);
+ state.cacheProps.put(name, value);
}
});
parser.addNodelet("/sqlMap/cacheModel/flushOnExecute", new Nodelet() {
public void process(Node node) throws Exception {
- vars.errorCtx.setMoreInfo("Check the cache model flush on statement elements.");
- Properties childAttributes = NodeletUtils.parseAttributes(node, vars.properties);
- vars.currentCacheModel.addFlushTriggerStatement(childAttributes.getProperty("statement"));
+ state.errorContext.setMoreInfo("Check the cache model flush on statement elements.");
+ Properties childAttributes = NodeletUtils.parseAttributes(node, state.globalProps);
+ state.cacheModel.addFlushTriggerStatement(childAttributes.getProperty("statement"));
}
});
parser.addNodelet("/sqlMap/cacheModel/flushInterval", new Nodelet() {
public void process(Node node) throws Exception {
- Properties childAttributes = NodeletUtils.parseAttributes(node, vars.properties);
+ Properties childAttributes = NodeletUtils.parseAttributes(node, state.globalProps);
long t = 0;
try {
- vars.errorCtx.setMoreInfo("Check the cache model flush interval.");
+ state.errorContext.setMoreInfo("Check the cache model flush interval.");
String milliseconds = childAttributes.getProperty("milliseconds");
String seconds = childAttributes.getProperty("seconds");
String minutes = childAttributes.getProperty("minutes");
@@ -193,9 +185,9 @@
if (minutes != null) t += Integer.parseInt(minutes) * 60 * 1000;
if (hours != null) t += Integer.parseInt(hours) * 60 * 60 * 1000;
if (t < 1) throw new RuntimeException("A flush interval must specify one or more of milliseconds, seconds, minutes or hours.");
- vars.currentCacheModel.setFlushInterval(t);
+ state.cacheModel.setFlushInterval(t);
} catch (NumberFormatException e) {
- throw new RuntimeException("Error building cache '" + vars.currentCacheModel.getId() + "' in '" + "resourceNAME" + "'. Flush interval milliseconds must be a valid long integer value. Cause: " + e, e);
+ throw new RuntimeException("Error building cache '" + state.cacheModel.getId() + "' in '" + "resourceNAME" + "'. Flush interval milliseconds must be a valid long integer value. Cause: " + e, e);
}
}
});
@@ -205,49 +197,49 @@
parser.addNodelet("/sqlMap/parameterMap/end()", new Nodelet() {
public void process(Node node) throws Exception {
- vars.currentParameterMap.setParameterMappingList(vars.parameterMappingList);
+ state.parameterMap.setParameterMappingList(state.parameterMappingList);
- vars.client.getDelegate().addParameterMap(vars.currentParameterMap);
+ state.client.getDelegate().addParameterMap(state.parameterMap);
- vars.errorCtx.setMoreInfo(null);
- vars.errorCtx.setObjectId(null);
+ state.errorContext.setMoreInfo(null);
+ state.errorContext.setObjectId(null);
}
});
parser.addNodelet("/sqlMap/parameterMap", new Nodelet() {
public void process(Node node) throws Exception {
- vars.errorCtx.setActivity("building a parameter map");
+ state.errorContext.setActivity("building a parameter map");
- vars.currentParameterMap = new BasicParameterMap(vars.client.getDelegate());
+ state.parameterMap = new BasicParameterMap(state.client.getDelegate());
- Properties attributes = NodeletUtils.parseAttributes(node, vars.properties);
- String id = applyNamespace(attributes.getProperty("id"));
+ Properties attributes = NodeletUtils.parseAttributes(node, state.globalProps);
+ String id = state.applyNamespace(attributes.getProperty("id"));
String parameterClassName = attributes.getProperty("class");
- parameterClassName = vars.typeHandlerFactory.resolveAlias(parameterClassName);
+ parameterClassName = state.typeHandlerFactory.resolveAlias(parameterClassName);
- vars.currentParameterMap.setId(id);
- vars.currentParameterMap.setResource(vars.errorCtx.getResource());
+ state.parameterMap.setId(id);
+ state.parameterMap.setResource(state.errorContext.getResource());
- vars.errorCtx.setObjectId(id + " parameter map");
+ state.errorContext.setObjectId(id + " parameter map");
Class parameterClass = null;
try {
- vars.errorCtx.setMoreInfo("Check the parameter class.");
+ state.errorContext.setMoreInfo("Check the parameter class.");
parameterClass = Resources.classForName(parameterClassName);
} catch (Exception e) {
//TODO: Why is this commented out?
//throw new SqlMapException("Error configuring ParameterMap. Could not set ParameterClass. Cause: " + e, e);
}
- vars.currentParameterMap.setParameterClass(parameterClass);
+ state.parameterMap.setParameterClass(parameterClass);
- vars.parameterMappingList = new ArrayList();
+ state.parameterMappingList = new ArrayList();
- vars.errorCtx.setMoreInfo("Check the parameter mappings.");
+ state.errorContext.setMoreInfo("Check the parameter mappings.");
}
});
parser.addNodelet("/sqlMap/parameterMap/parameter", new Nodelet() {
public void process(Node node) throws Exception {
- Properties childAttributes = NodeletUtils.parseAttributes(node, vars.properties);
+ Properties childAttributes = NodeletUtils.parseAttributes(node, state.globalProps);
String propertyName = childAttributes.getProperty("property");
String jdbcType = childAttributes.getProperty("jdbcType");
String type = childAttributes.getProperty("typeName");
@@ -258,15 +250,15 @@
String callback = childAttributes.getProperty("typeHandler");
String numericScale = childAttributes.getProperty("numericScale");
- callback = vars.typeHandlerFactory.resolveAlias(callback);
- javaType = vars.typeHandlerFactory.resolveAlias(javaType);
- resultMap = applyNamespace( resultMap );
+ callback = state.typeHandlerFactory.resolveAlias(callback);
+ javaType = state.typeHandlerFactory.resolveAlias(javaType);
+ resultMap = state.applyNamespace( resultMap );
- vars.errorCtx.setObjectId(propertyName + " mapping of the " + vars.currentParameterMap.getId() + " parameter map");
+ state.errorContext.setObjectId(propertyName + " mapping of the " + state.parameterMap.getId() + " parameter map");
TypeHandler handler = null;
if (callback != null) {
- vars.errorCtx.setMoreInfo("Check the parameter mapping typeHandler attribute '" + callback + "' (must be a TypeHandler or TypeHandlerCallback implementation).");
+ state.errorContext.setMoreInfo("Check the parameter mapping typeHandler attribute '" + callback + "' (must be a TypeHandler or TypeHandlerCallback implementation).");
try {
Object impl = Resources.instantiate(callback);
if (impl instanceof TypeHandlerCallback) {
@@ -280,8 +272,8 @@
throw new RuntimeException("Error occurred during custom type handler configuration. Cause: " + e, e);
}
} else {
- vars.errorCtx.setMoreInfo("Check the parameter mapping property type or name.");
- handler = resolveTypeHandler(vars.client.getDelegate().getTypeHandlerFactory(), vars.currentParameterMap.getParameterClass(), propertyName, javaType, jdbcType);
+ state.errorContext.setMoreInfo("Check the parameter mapping property type or name.");
+ handler = state.resolveTypeHandler(state.client.getDelegate().getTypeHandlerFactory(), state.parameterMap.getParameterClass(), propertyName, javaType, jdbcType);
}
BasicParameterMapping mapping = new BasicParameterMapping();
@@ -315,7 +307,7 @@
}
}
- vars.parameterMappingList.add(mapping);
+ state.parameterMappingList.add(mapping);
}
});
@@ -325,75 +317,75 @@
parser.addNodelet("/sqlMap/resultMap/end()", new Nodelet() {
public void process(Node node) throws Exception {
- if (vars.resultMappingList.size() == 0) {
- throw new RuntimeException("resultMap " + vars.currentResultMap.getId() + " must have at least one result mapping");
+ if (state.resultMappingList.size() == 0) {
+ throw new RuntimeException("resultMap " + state.resultMap.getId() + " must have at least one result mapping");
}
- vars.currentResultMap.setResultMappingList(vars.resultMappingList);
+ state.resultMap.setResultMappingList(state.resultMappingList);
- vars.currentResultMap.setDiscriminator(vars.discriminator);
- vars.discriminator = null;
+ state.resultMap.setDiscriminator(state.discriminator);
+ state.discriminator = null;
- vars.client.getDelegate().addResultMap(vars.currentResultMap);
+ state.client.getDelegate().addResultMap(state.resultMap);
- vars.errorCtx.setMoreInfo(null);
+ state.errorContext.setMoreInfo(null);
- vars.errorCtx.setObjectId(null);
+ state.errorContext.setObjectId(null);
}
});
parser.addNodelet("/sqlMap/resultMap", new Nodelet() {
public void process(Node node) throws Exception {
- vars.errorCtx.setActivity("building a result map");
+ state.errorContext.setActivity("building a result map");
- vars.currentResultMap = new BasicResultMap(vars.client.getDelegate());
+ state.resultMap = new BasicResultMap(state.client.getDelegate());
- Properties attributes = NodeletUtils.parseAttributes(node, vars.properties);
- String id = applyNamespace(attributes.getProperty("id"));
+ Properties attributes = NodeletUtils.parseAttributes(node, state.globalProps);
+ String id = state.applyNamespace(attributes.getProperty("id"));
String resultClassName = attributes.getProperty("class");
- String extended = applyNamespace(attributes.getProperty("extends"));
+ String extended = state.applyNamespace(attributes.getProperty("extends"));
String xmlName = attributes.getProperty("xmlName");
String groupBy = attributes.getProperty("groupBy");
- resultClassName = vars.typeHandlerFactory.resolveAlias(resultClassName);
+ resultClassName = state.typeHandlerFactory.resolveAlias(resultClassName);
- vars.errorCtx.setObjectId(id + " result map");
+ state.errorContext.setObjectId(id + " result map");
- vars.currentResultMap.setId(id);
- vars.currentResultMap.setXmlName(xmlName);
- vars.currentResultMap.setResource(vars.errorCtx.getResource());
+ state.resultMap.setId(id);
+ state.resultMap.setXmlName(xmlName);
+ state.resultMap.setResource(state.errorContext.getResource());
if (groupBy != null && groupBy.length() > 0) {
StringTokenizer parser = new StringTokenizer(groupBy, ", ", false);
while (parser.hasMoreTokens()) {
- vars.currentResultMap.addGroupByProperty(parser.nextToken());
+ state.resultMap.addGroupByProperty(parser.nextToken());
}
}
Class resultClass = null;
try {
- vars.errorCtx.setMoreInfo("Check the result class.");
+ state.errorContext.setMoreInfo("Check the result class.");
resultClass = Resources.classForName(resultClassName);
} catch (Exception e) {
throw new RuntimeException("Error configuring Result. Could not set ResultClass. Cause: " + e, e);
}
- vars.currentResultMap.setResultClass(resultClass);
+ state.resultMap.setResultClass(resultClass);
- vars.resultMappingList = new ArrayList();
+ state.resultMappingList = new ArrayList();
- vars.errorCtx.setMoreInfo("Check the extended result map.");
+ state.errorContext.setMoreInfo("Check the extended result map.");
if (extended != null) {
- BasicResultMap extendedResultMap = (BasicResultMap) vars.client.getDelegate().getResultMap(extended);
+ BasicResultMap extendedResultMap = (BasicResultMap) state.client.getDelegate().getResultMap(extended);
ResultMapping[] resultMappings = extendedResultMap.getResultMappings();
for (int i = 0; i < resultMappings.length; i++) {
- vars.resultMappingList.add(resultMappings[i]);
+ state.resultMappingList.add(resultMappings[i]);
}
List nestedResultMappings = extendedResultMap.getNestedResultMappings();
if (nestedResultMappings != null) {
Iterator iter = nestedResultMappings.iterator();
while (iter.hasNext()) {
- vars.currentResultMap.addNestedResultMappings((ResultMapping) iter.next());
+ state.resultMap.addNestedResultMappings((ResultMapping) iter.next());
}
}
@@ -401,20 +393,20 @@
if (extendedResultMap.hasGroupBy()) {
Iterator i = extendedResultMap.groupByProps();
while (i.hasNext()) {
- vars.currentResultMap.addGroupByProperty((String) i.next());
+ state.resultMap.addGroupByProperty((String) i.next());
}
}
}
}
- vars.errorCtx.setMoreInfo("Check the result mappings.");
- vars.resultMappingIndex = vars.resultMappingList.size();
+ state.errorContext.setMoreInfo("Check the result mappings.");
+ state.resultMappingIndex = state.resultMappingList.size();
}
});
parser.addNodelet("/sqlMap/resultMap/result", new Nodelet() {
public void process(Node node) throws Exception {
- Properties childAttributes = NodeletUtils.parseAttributes(node, vars.properties);
+ Properties childAttributes = NodeletUtils.parseAttributes(node, state.globalProps);
String propertyName = childAttributes.getProperty("property");
String nullValue = childAttributes.getProperty("nullValue");
String jdbcType = childAttributes.getProperty("jdbcType");
@@ -425,14 +417,14 @@
String resultMapName = childAttributes.getProperty("resultMap");
String callback = childAttributes.getProperty("typeHandler");
- callback = vars.typeHandlerFactory.resolveAlias(callback);
- javaType = vars.typeHandlerFactory.resolveAlias(javaType);
+ callback = state.typeHandlerFactory.resolveAlias(callback);
+ javaType = state.typeHandlerFactory.resolveAlias(javaType);
- vars.errorCtx.setObjectId(propertyName + " mapping of the " + vars.currentResultMap.getId() + " result map");
+ state.errorContext.setObjectId(propertyName + " mapping of the " + state.resultMap.getId() + " result map");
TypeHandler handler = null;
if (callback != null) {
- vars.errorCtx.setMoreInfo("Check the result mapping typeHandler attribute '" + callback + "' (must be a TypeHandler or TypeHandlerCallback implementation).");
+ state.errorContext.setMoreInfo("Check the result mapping typeHandler attribute '" + callback + "' (must be a TypeHandler or TypeHandlerCallback implementation).");
try {
Object impl = Resources.instantiate(callback);
if (impl instanceof TypeHandlerCallback) {
@@ -446,8 +438,8 @@
throw new RuntimeException("Error occurred during custom type handler configuration. Cause: " + e, e);
}
} else {
- vars.errorCtx.setMoreInfo("Check the result mapping property type or name.");
- handler = resolveTypeHandler(vars.client.getDelegate().getTypeHandlerFactory(), vars.currentResultMap.getResultClass(), propertyName, javaType, jdbcType, true);
+ state.errorContext.setMoreInfo("Check the result mapping property type or name.");
+ handler = state.resolveTypeHandler(state.client.getDelegate().getTypeHandlerFactory(), state.resultMap.getResultClass(), propertyName, javaType, jdbcType, true);
}
@@ -461,7 +453,7 @@
mapping.setNestedResultMapName(resultMapName);
if (resultMapName != null && resultMapName.length() > 0) {
- vars.currentResultMap.addNestedResultMappings(mapping);
+ state.resultMap.addNestedResultMappings(mapping);
}
try {
@@ -475,29 +467,29 @@
if (columnIndex != null && columnIndex.length() > 0) {
mapping.setColumnIndex(Integer.parseInt(columnIndex));
} else {
- vars.resultMappingIndex++;
- mapping.setColumnIndex(vars.resultMappingIndex);
+ state.resultMappingIndex++;
+ mapping.setColumnIndex(state.resultMappingIndex);
}
- vars.resultMappingList.add(mapping);
+ state.resultMappingList.add(mapping);
}
});
parser.addNodelet("/sqlMap/resultMap/discriminator/subMap", new Nodelet() {
public void process(Node node) throws Exception {
- if (vars.discriminator == null) {
+ if (state.discriminator == null) {
throw new RuntimeException ("The discriminator is null, but somehow a subMap was reached. This is a bug.");
}
- Properties childAttributes = NodeletUtils.parseAttributes(node, vars.properties);
+ Properties childAttributes = NodeletUtils.parseAttributes(node, state.globalProps);
String value = childAttributes.getProperty("value");
String resultMap = childAttributes.getProperty("resultMap");
- vars.discriminator.addSubMap(value, applyNamespace(resultMap));
+ state.discriminator.addSubMap(value, state.applyNamespace(resultMap));
}
});
parser.addNodelet("/sqlMap/resultMap/discriminator", new Nodelet() {
public void process(Node node) throws Exception {
- Properties childAttributes = NodeletUtils.parseAttributes(node, vars.properties);
+ Properties childAttributes = NodeletUtils.parseAttributes(node, state.globalProps);
String nullValue = childAttributes.getProperty("nullValue");
String jdbcType = childAttributes.getProperty("jdbcType");
String javaType = childAttributes.getProperty("javaType");
@@ -505,12 +497,12 @@
String columnIndex = childAttributes.getProperty("columnIndex");
String callback = childAttributes.getProperty("typeHandler");
- callback = vars.typeHandlerFactory.resolveAlias(callback);
- javaType = vars.typeHandlerFactory.resolveAlias(javaType);
+ callback = state.typeHandlerFactory.resolveAlias(callback);
+ javaType = state.typeHandlerFactory.resolveAlias(javaType);
TypeHandler handler = null;
if (callback != null) {
- vars.errorCtx.setMoreInfo("Check the result mapping typeHandler attribute '" + callback + "' (must be a TypeHandlerCallback implementation).");
+ state.errorContext.setMoreInfo("Check the result mapping typeHandler attribute '" + callback + "' (must be a TypeHandlerCallback implementation).");
try {
Object impl = Resources.instantiate(callback);
if (impl instanceof TypeHandlerCallback) {
@@ -524,8 +516,8 @@
throw new RuntimeException("Error occurred during custom type handler configuration. Cause: " + e, e);
}
} else {
- vars.errorCtx.setMoreInfo("Check the result mapping property type or name.");
- handler = resolveTypeHandler(vars.client.getDelegate().getTypeHandlerFactory(), vars.currentResultMap.getResultClass(), "", javaType, jdbcType, true);
+ state.errorContext.setMoreInfo("Check the result mapping property type or name.");
+ handler = state.resolveTypeHandler(state.client.getDelegate().getTypeHandlerFactory(), state.resultMap.getResultClass(), "", javaType, jdbcType, true);
}
BasicResultMapping mapping = new BasicResultMapping();
@@ -546,7 +538,7 @@
mapping.setColumnIndex(Integer.parseInt(columnIndex));
}
- vars.discriminator = new Discriminator (vars.delegate, mapping);
+ state.discriminator = new Discriminator (state.delegate, mapping);
}
});
}
@@ -554,38 +546,38 @@
protected void addStatementNodelets() {
parser.addNodelet("/sqlMap/statement", new Nodelet() {
public void process(Node node) throws Exception {
- vars.currentStatement = new SqlStatementParser(vars).parseGeneralStatement(node, new GeneralStatement());
- vars.delegate.addMappedStatement(vars.currentStatement);
+ state.currentStatement = new SqlStatementParser(state).parseGeneralStatement(node, new GeneralStatement());
+ state.delegate.addMappedStatement(state.currentStatement);
}
});
parser.addNodelet("/sqlMap/insert", new Nodelet() {
public void process(Node node) throws Exception {
- vars.currentStatement = new SqlStatementParser(vars).parseGeneralStatement(node, new InsertStatement());
- vars.delegate.addMappedStatement(vars.currentStatement);
+ state.currentStatement = new SqlStatementParser(state).parseGeneralStatement(node, new InsertStatement());
+ state.delegate.addMappedStatement(state.currentStatement);
}
});
parser.addNodelet("/sqlMap/update", new Nodelet() {
public void process(Node node) throws Exception {
- vars.currentStatement = new SqlStatementParser(vars).parseGeneralStatement(node, new UpdateStatement());
- vars.delegate.addMappedStatement(vars.currentStatement);
+ state.currentStatement = new SqlStatementParser(state).parseGeneralStatement(node, new UpdateStatement());
+ state.delegate.addMappedStatement(state.currentStatement);
}
});
parser.addNodelet("/sqlMap/delete", new Nodelet() {
public void process(Node node) throws Exception {
- vars.currentStatement = new SqlStatementParser(vars).parseGeneralStatement(node, new DeleteStatement());
- vars.delegate.addMappedStatement(vars.currentStatement);
+ state.currentStatement = new SqlStatementParser(state).parseGeneralStatement(node, new DeleteStatement());
+ state.delegate.addMappedStatement(state.currentStatement);
}
});
parser.addNodelet("/sqlMap/select", new Nodelet() {
public void process(Node node) throws Exception {
- vars.currentStatement = new SqlStatementParser(vars).parseGeneralStatement(node, new SelectStatement());
- vars.delegate.addMappedStatement(vars.currentStatement);
+ state.currentStatement = new SqlStatementParser(state).parseGeneralStatement(node, new SelectStatement());
+ state.delegate.addMappedStatement(state.currentStatement);
}
});
parser.addNodelet("/sqlMap/procedure", new Nodelet() {
public void process(Node node) throws Exception {
- vars.currentStatement = new SqlStatementParser(vars).parseGeneralStatement(node, new ProcedureStatement());
- vars.delegate.addMappedStatement(vars.currentStatement);
+ state.currentStatement = new SqlStatementParser(state).parseGeneralStatement(node, new ProcedureStatement());
+ state.delegate.addMappedStatement(state.currentStatement);
}
});
}
Modified: ibatis/trunk/java/mapper/mapper2/src/com/ibatis/sqlmap/engine/builder/xml/SqlStatementParser.java
URL: http://svn.apache.org/viewvc/ibatis/trunk/java/mapper/mapper2/src/com/ibatis/sqlmap/engine/builder/xml/SqlStatementParser.java?view=diff&rev=511363&r1=511362&r2=511363
==============================================================================
--- ibatis/trunk/java/mapper/mapper2/src/com/ibatis/sqlmap/engine/builder/xml/SqlStatementParser.java (original)
+++ ibatis/trunk/java/mapper/mapper2/src/com/ibatis/sqlmap/engine/builder/xml/SqlStatementParser.java Sat Feb 24 14:40:42 2007
@@ -25,32 +25,34 @@
import java.sql.ResultSet;
import java.util.*;
-public class SqlStatementParser extends BaseParser {
+public class SqlStatementParser {
private static final Probe PROBE = ProbeFactory.getProbe();
private static final InlineParameterMapParser PARAM_PARSER = new InlineParameterMapParser();
- public SqlStatementParser(Variables vars) {
- super(vars);
+ private ParserState state;
+
+ public SqlStatementParser(ParserState state) {
+ this.state = state;
}
public MappedStatement parseGeneralStatement(Node node, GeneralStatement statement) {
- vars.errorCtx.setActivity("parsing a mapped statement");
+ state.errorContext.setActivity("parsing a mapped statement");
// get attributes
- Properties attributes = NodeletUtils.parseAttributes(node, vars.currentProperties);
+ Properties attributes = NodeletUtils.parseAttributes(node, state.globalProps);
String id = attributes.getProperty("id");
- if (vars.useStatementNamespaces) {
- id = applyNamespace(id);
+ if (state.useStatementNamespaces) {
+ id = state.applyNamespace(id);
}
- String parameterMapName = applyNamespace(attributes.getProperty("parameterMap"));
+ String parameterMapName = state.applyNamespace(attributes.getProperty("parameterMap"));
String parameterClassName = attributes.getProperty("parameterClass");
String resultMapName = attributes.getProperty("resultMap");
String resultClassName = attributes.getProperty("resultClass");
- String cacheModelName = applyNamespace(attributes.getProperty("cacheModel"));
+ String cacheModelName = state.applyNamespace(attributes.getProperty("cacheModel"));
String xmlResultName = attributes.getProperty("xmlResultName");
String resultSetType = attributes.getProperty("resultSetType");
String fetchSize = attributes.getProperty("fetchSize");
@@ -59,30 +61,30 @@
String[] additionalResultMapNames;
- vars.errorCtx.setObjectId(id + " statement");
+ state.errorContext.setObjectId(id + " statement");
// get parameter and result maps
- vars.errorCtx.setMoreInfo("Check the result map name.");
+ state.errorContext.setMoreInfo("Check the result map name.");
//BasicResultMap resultMap = null;
if (resultMapName != null) {
additionalResultMapNames = getAllButFirstToken(resultMapName);
resultMapName = getFirstToken (resultMapName);
- statement.setResultMap((BasicResultMap) vars.client.getDelegate().getResultMap(applyNamespace(resultMapName)));
+ statement.setResultMap((BasicResultMap) state.client.getDelegate().getResultMap(state.applyNamespace(resultMapName)));
for (int i=0; i < additionalResultMapNames.length; i++) {
- statement.addResultMap((BasicResultMap) vars.client.getDelegate().getResultMap(applyNamespace(additionalResultMapNames[i])));
+ statement.addResultMap((BasicResultMap) state.client.getDelegate().getResultMap(state.applyNamespace(additionalResultMapNames[i])));
}
}
- vars.errorCtx.setMoreInfo("Check the parameter map name.");
+ state.errorContext.setMoreInfo("Check the parameter map name.");
if (parameterMapName != null) {
- statement.setParameterMap((BasicParameterMap) vars.client.getDelegate().getParameterMap(parameterMapName));
+ statement.setParameterMap((BasicParameterMap) state.client.getDelegate().getParameterMap(parameterMapName));
}
statement.setId(id);
- statement.setResource(vars.errorCtx.getResource());
+ statement.setResource(state.errorContext.getResource());
if (resultSetType != null) {
if ("FORWARD_ONLY".equals(resultSetType)) {
@@ -103,8 +105,8 @@
if (parameterMap == null) {
try {
if (parameterClassName != null) {
- vars.errorCtx.setMoreInfo("Check the parameter class.");
- parameterClassName = vars.typeHandlerFactory.resolveAlias(parameterClassName);
+ state.errorContext.setMoreInfo("Check the parameter class.");
+ parameterClassName = state.typeHandlerFactory.resolveAlias(parameterClassName);
Class parameterClass = Resources.classForName(parameterClassName);
statement.setParameterClass(parameterClass);
}
@@ -116,7 +118,7 @@
}
// process SQL statement, including inline parameter maps
- vars.errorCtx.setMoreInfo("Check the SQL statement.");
+ state.errorContext.setMoreInfo("Check the SQL statement.");
processSqlStatement(node, statement);
// set up either null result map or automatic result mapping
@@ -134,7 +136,7 @@
}
- statement.setTimeout(vars.defaultStatementTimeout);
+ statement.setTimeout(state.defaultStatementTimeout);
if (timeout != null) {
try {
statement.setTimeout(Integer.valueOf(timeout));
@@ -144,12 +146,12 @@
}
}
- vars.errorCtx.setMoreInfo(null);
- vars.errorCtx.setObjectId(null);
+ state.errorContext.setMoreInfo(null);
+ state.errorContext.setObjectId(null);
- statement.setSqlMapClient(vars.client);
- if (cacheModelName != null && cacheModelName.length() > 0 && vars.client.getDelegate().isCacheModelsEnabled()) {
- CacheModel cacheModel = vars.client.getDelegate().getCacheModel(cacheModelName);
+ statement.setSqlMapClient(state.client);
+ if (cacheModelName != null && cacheModelName.length() > 0 && state.client.getDelegate().isCacheModelsEnabled()) {
+ CacheModel cacheModel = state.client.getDelegate().getCacheModel(cacheModelName);
return new CachingStatement(statement, cacheModel);
} else {
return statement;
@@ -159,7 +161,7 @@
private BasicResultMap buildAutoResultMap(String allowRemapping, GeneralStatement statement, String firstResultClass, String xmlResultName) {
BasicResultMap resultMap;
- resultMap = new AutoResultMap(vars.client.getDelegate(), "true".equals(allowRemapping));
+ resultMap = new AutoResultMap(state.client.getDelegate(), "true".equals(allowRemapping));
resultMap.setId(statement.getId() + "-AutoResultMap");
resultMap.setResultClass(resolveClass(firstResultClass));
resultMap.setXmlName(xmlResultName);
@@ -170,8 +172,8 @@
private Class resolveClass(String resultClassName) {
try {
if (resultClassName != null) {
- vars.errorCtx.setMoreInfo("Check the result class.");
- return Resources.classForName(vars.typeHandlerFactory.resolveAlias(resultClassName));
+ state.errorContext.setMoreInfo("Check the result class.");
+ return Resources.classForName(state.typeHandlerFactory.resolveAlias(resultClassName));
} else {
return null;
}
@@ -195,10 +197,10 @@
}
private void processSqlStatement(Node n, GeneralStatement statement) {
- vars.errorCtx.setActivity("processing an SQL statement");
+ state.errorContext.setActivity("processing an SQL statement");
boolean isDynamic = false;
- DynamicSql dynamic = new DynamicSql(vars.client.getDelegate());
+ DynamicSql dynamic = new DynamicSql(state.client.getDelegate());
StringBuffer sqlBuffer = new StringBuffer();
isDynamic = parseDynamicTags(n, dynamic, sqlBuffer, isDynamic, false);
@@ -218,7 +220,7 @@
}
private boolean parseDynamicTags(Node node, DynamicParent dynamic, StringBuffer sqlBuffer, boolean isDynamic, boolean postParseRequired) {
- vars.errorCtx.setActivity("parsing dynamic SQL tags");
+ state.errorContext.setActivity("parsing dynamic SQL tags");
NodeList children = node.getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
@@ -228,7 +230,7 @@
|| child.getNodeType() == Node.TEXT_NODE) {
String data = ((CharacterData) child).getData();
- data = NodeletUtils.parsePropertyTokens(data, vars.properties);
+ data = NodeletUtils.parsePropertyTokens(data, state.globalProps);
SqlText sqlText;
@@ -237,7 +239,7 @@
sqlText.setPostParseRequired(postParseRequired);
sqlText.setText(data);
} else {
- sqlText = PARAM_PARSER.parseInlineParameterMap(vars.client.getDelegate().getTypeHandlerFactory(), data, null);
+ sqlText = PARAM_PARSER.parseInlineParameterMap(state.client.getDelegate().getTypeHandlerFactory(), data, null);
sqlText.setPostParseRequired(postParseRequired);
}
@@ -245,19 +247,19 @@
sqlBuffer.append(data);
} else if ("include".equals(nodeName)) {
- Properties attributes = NodeletUtils.parseAttributes(child, vars.properties);
+ Properties attributes = NodeletUtils.parseAttributes(child, state.globalProps);
String refid = (String) attributes.get("refid");
- Node includeNode = (Node) vars.sqlIncludes.get(refid);
+ Node includeNode = (Node) state.sqlIncludes.get(refid);
if (includeNode == null) {
- String nsrefid = applyNamespace(refid);
- includeNode = (Node) vars.sqlIncludes.get(nsrefid);
+ String nsrefid = state.applyNamespace(refid);
+ includeNode = (Node) state.sqlIncludes.get(nsrefid);
if (includeNode == null) {
throw new RuntimeException("Could not find SQL statement to include with refid '" + refid + "'");
}
}
isDynamic = parseDynamicTags(includeNode, dynamic, sqlBuffer, isDynamic, false);
} else {
- vars.errorCtx.setMoreInfo("Check the dynamic tags.");
+ state.errorContext.setMoreInfo("Check the dynamic tags.");
SqlTagHandler handler = SqlTagHandlerFactory.getSqlTagHandler(nodeName);
if (handler != null) {
@@ -267,7 +269,7 @@
tag.setName(nodeName);
tag.setHandler(handler);
- Properties attributes = NodeletUtils.parseAttributes(child, vars.properties);
+ Properties attributes = NodeletUtils.parseAttributes(child, state.globalProps);
tag.setPrependAttr(attributes.getProperty("prepend"));
tag.setPropertyAttr(attributes.getProperty("property"));
@@ -302,12 +304,12 @@
}
}
}
- vars.errorCtx.setMoreInfo(null);
+ state.errorContext.setMoreInfo(null);
return isDynamic;
}
private SelectKeyStatement findAndParseSelectKeyStatement(Node n, GeneralStatement insertStatement) {
- vars.errorCtx.setActivity("parsing select key tags");
+ state.errorContext.setActivity("parsing select key tags");
SelectKeyStatement selectKeyStatement = null;
@@ -333,7 +335,7 @@
if (selectKeyStatement != null && !hasType) {
selectKeyStatement.setAfter(foundTextFirst);
}
- vars.errorCtx.setMoreInfo(null);
+ state.errorContext.setMoreInfo(null);
return selectKeyStatement;
}
@@ -347,20 +349,20 @@
* of the element in the text (the legacy behavior)
*/
private boolean parseSelectKey(Node node, GeneralStatement insertStatement, SelectKeyStatement selectKeyStatement) {
- vars.errorCtx.setActivity("parsing a select key");
+ state.errorContext.setActivity("parsing a select key");
// get attributes
- Properties attributes = NodeletUtils.parseAttributes(node, vars.properties);
+ Properties attributes = NodeletUtils.parseAttributes(node, state.globalProps);
String keyPropName = attributes.getProperty("keyProperty");
String resultClassName = attributes.getProperty("resultClass");
- resultClassName = vars.typeHandlerFactory.resolveAlias(resultClassName);
+ resultClassName = state.typeHandlerFactory.resolveAlias(resultClassName);
Class resultClass = null;
// get parameter and result maps
- selectKeyStatement.setSqlMapClient(vars.client);
+ selectKeyStatement.setSqlMapClient(state.client);
selectKeyStatement.setId(insertStatement.getId() + "-SelectKey");
- selectKeyStatement.setResource(vars.errorCtx.getResource());
+ selectKeyStatement.setResource(state.errorContext.getResource());
selectKeyStatement.setKeyProperty(keyPropName);
// process the type (pre or post) attribute
@@ -375,7 +377,7 @@
try {
if (resultClassName != null) {
- vars.errorCtx.setMoreInfo("Check the select key result class.");
+ state.errorContext.setMoreInfo("Check the select key result class.");
resultClass = Resources.classForName(resultClassName);
} else {
Class parameterClass = insertStatement.getParameterClass();
@@ -392,39 +394,39 @@
}
// process SQL statement, including inline parameter maps
- vars.errorCtx.setMoreInfo("Check the select key SQL statement.");
+ state.errorContext.setMoreInfo("Check the select key SQL statement.");
processSqlStatement(node, selectKeyStatement);
BasicResultMap resultMap;
- resultMap = new AutoResultMap(vars.client.getDelegate(), false);
+ resultMap = new AutoResultMap(state.client.getDelegate(), false);
resultMap.setId(selectKeyStatement.getId() + "-AutoResultMap");
resultMap.setResultClass(resultClass);
resultMap.setResource(selectKeyStatement.getResource());
selectKeyStatement.setResultMap(resultMap);
- vars.errorCtx.setMoreInfo(null);
+ state.errorContext.setMoreInfo(null);
return hasType;
}
private void applyInlineParameterMap(GeneralStatement statement, String sqlStatement) {
String newSql = sqlStatement;
- vars.errorCtx.setActivity("building an inline parameter map");
+ state.errorContext.setActivity("building an inline parameter map");
ParameterMap parameterMap = statement.getParameterMap();
- vars.errorCtx.setMoreInfo("Check the inline parameters.");
+ state.errorContext.setMoreInfo("Check the inline parameters.");
if (parameterMap == null) {
BasicParameterMap map;
- map = new BasicParameterMap(vars.client.getDelegate());
+ map = new BasicParameterMap(state.client.getDelegate());
map.setId(statement.getId() + "-InlineParameterMap");
map.setParameterClass(statement.getParameterClass());
map.setResource(statement.getResource());
statement.setParameterMap(map);
- SqlText sqlText = PARAM_PARSER.parseInlineParameterMap(vars.client.getDelegate().getTypeHandlerFactory(), newSql, statement.getParameterClass());
+ SqlText sqlText = PARAM_PARSER.parseInlineParameterMap(state.client.getDelegate().getTypeHandlerFactory(), newSql, statement.getParameterClass());
newSql = sqlText.getText();
List mappingList = Arrays.asList(sqlText.getParameterMappings());
@@ -434,7 +436,7 @@
Sql sql = null;
if (SimpleDynamicSql.isSimpleDynamicSql(newSql)) {
- sql = new SimpleDynamicSql(vars.client.getDelegate(), newSql);
+ sql = new SimpleDynamicSql(state.client.getDelegate(), newSql);
} else {
sql = new StaticSql(newSql);
}