Home » iBatis-2.3.4 » com.ibatis.sqlmap.engine.builder » xml » [javadoc | source]

    1   package com.ibatis.sqlmap.engine.builder.xml;
    2   
    3   import com.ibatis.common.resources.Resources;
    4   import com.ibatis.common.xml.Nodelet;
    5   import com.ibatis.common.xml.NodeletException;
    6   import com.ibatis.common.xml.NodeletParser;
    7   import com.ibatis.common.xml.NodeletUtils;
    8   import com.ibatis.common.exception.NestedRuntimeException;
    9   import com.ibatis.sqlmap.client.extensions.TypeHandlerCallback;
   10   import com.ibatis.sqlmap.engine.cache.CacheModel;
   11   import com.ibatis.sqlmap.engine.mapping.parameter.BasicParameterMap;
   12   import com.ibatis.sqlmap.engine.mapping.parameter.BasicParameterMapping;
   13   import com.ibatis.sqlmap.engine.mapping.result;
   14   import com.ibatis.sqlmap.engine.mapping.statement;
   15   import com.ibatis.sqlmap.engine.type.CustomTypeHandler;
   16   import com.ibatis.sqlmap.engine.type.TypeHandler;
   17   import org.w3c.dom.Node;
   18   
   19   import java.io.Reader;
   20   import java.util.ArrayList;
   21   import java.util.Properties;
   22   import java.util.StringTokenizer;
   23   import java.util.Iterator;
   24   
   25   public class SqlMapParser extends BaseParser {
   26   
   27     private final NodeletParser parser = new NodeletParser();
   28   
   29     public SqlMapParser(Variables vars) {
   30       super(vars);
   31       parser.setValidation(true);
   32       parser.setEntityResolver(new SqlMapClasspathEntityResolver());
   33   
   34       addSqlMapNodelets();
   35       addSqlNodelets();
   36       addTypeAliasNodelets();
   37       addCacheModelNodelets();
   38       addParameterMapNodelets();
   39       addResultMapNodelets();
   40       addStatementNodelets();
   41   
   42     }
   43   
   44     public void parse(Reader reader) throws NodeletException {
   45       parser.parse(reader);
   46     }
   47   
   48     private void addSqlMapNodelets() {
   49       parser.addNodelet("/sqlMap", new Nodelet() {
   50         public void process(Node node) throws Exception {
   51           Properties attributes = NodeletUtils.parseAttributes(node, vars.properties);
   52           vars.currentNamespace = attributes.getProperty("namespace");
   53         }
   54       });
   55       parser.addNodelet("/sqlMap/end()", new Nodelet() {
   56         public void process(Node node) throws Exception {
   57           Iterator names = vars.delegate.getResultMapNames();
   58           while (names.hasNext()) {
   59             String name = (String)names.next();
   60             ResultMap rm = vars.delegate.getResultMap(name);
   61             Discriminator disc = rm.getDiscriminator();
   62             if (disc != null) {
   63               disc.bindSubMaps();
   64             }
   65           }
   66         }
   67       });
   68     }
   69   
   70     private void addSqlNodelets() {
   71       parser.addNodelet("/sqlMap/sql", new Nodelet() {
   72         public void process(Node node) throws Exception {
   73           Properties attributes = NodeletUtils.parseAttributes(node, vars.properties);
   74           String id = attributes.getProperty("id");
   75           if (vars.useStatementNamespaces) {
   76             id = applyNamespace(id);
   77           }
   78           vars.sqlIncludes.put(id, node);
   79         }
   80       });
   81     }
   82   
   83     private void addTypeAliasNodelets() {
   84       parser.addNodelet("/sqlMap/typeAlias", new Nodelet() {
   85         public void process(Node node) throws Exception {
   86           Properties prop = NodeletUtils.parseAttributes(node, vars.properties);
   87           String alias = prop.getProperty("alias");
   88           String type = prop.getProperty("type");
   89           vars.typeHandlerFactory.putTypeAlias(alias, type);
   90         }
   91       });
   92     }
   93   
   94     private void addCacheModelNodelets() {
   95       parser.addNodelet("/sqlMap/cacheModel", new Nodelet() {
   96         public void process(Node node) throws Exception {
   97           vars.currentCacheModel = new CacheModel();
   98           vars.currentProperties = new Properties();
   99         }
  100       });
  101       parser.addNodelet("/sqlMap/cacheModel/end()", new Nodelet() {
  102         public void process(Node node) throws Exception {
  103           vars.errorCtx.setActivity("building a cache model");
  104   
  105           Properties attributes = NodeletUtils.parseAttributes(node, vars.properties);
  106           String id = applyNamespace(attributes.getProperty("id"));
  107           String type = attributes.getProperty("type");
  108           type = vars.typeHandlerFactory.resolveAlias(type);
  109   
  110           String readOnly = attributes.getProperty("readOnly");
  111           if (readOnly != null && readOnly.length() > 0) {
  112             vars.currentCacheModel.setReadOnly("true".equals(readOnly));
  113           } else {
  114             vars.currentCacheModel.setReadOnly(true);
  115           }
  116   
  117           String serialize = attributes.getProperty("serialize");
  118           if (serialize != null && serialize.length() > 0) {
  119             vars.currentCacheModel.setSerialize("true".equals(serialize));
  120           } else {
  121             vars.currentCacheModel.setSerialize(false);
  122           }
  123   
  124           vars.errorCtx.setObjectId(id + " cache model");
  125   
  126           vars.errorCtx.setMoreInfo("Check the cache model type.");
  127           vars.currentCacheModel.setId(id);
  128           vars.currentCacheModel.setResource(vars.errorCtx.getResource());
  129   
  130           try {
  131             vars.currentCacheModel.setControllerClassName(type);
  132           } catch (Exception e) {
  133             throw new NestedRuntimeException("Error setting Cache Controller Class.  Cause: " + e, e);
  134           }
  135   
  136           vars.errorCtx.setMoreInfo("Check the cache model configuration.");
  137           vars.currentCacheModel.configure(vars.currentProperties);
  138   
  139           if (vars.client.getDelegate().isCacheModelsEnabled()) {
  140             vars.client.getDelegate().addCacheModel(vars.currentCacheModel);
  141           }
  142   
  143           vars.errorCtx.setMoreInfo(null);
  144           vars.errorCtx.setObjectId(null);
  145           vars.currentProperties = null;
  146           vars.currentCacheModel = null;
  147         }
  148       });
  149       parser.addNodelet("/sqlMap/cacheModel/property", new Nodelet() {
  150         public void process(Node node) throws Exception {
  151           vars.errorCtx.setMoreInfo("Check the cache model properties.");
  152           Properties attributes = NodeletUtils.parseAttributes(node, vars.properties);
  153           String name = attributes.getProperty("name");
  154           String value = NodeletUtils.parsePropertyTokens(attributes.getProperty("value"), vars.properties);
  155           vars.currentProperties.put(name, value);
  156         }
  157       });
  158       parser.addNodelet("/sqlMap/cacheModel/flushOnExecute", new Nodelet() {
  159         public void process(Node node) throws Exception {
  160           vars.errorCtx.setMoreInfo("Check the cache model flush on statement elements.");
  161           Properties childAttributes = NodeletUtils.parseAttributes(node, vars.properties);
  162           vars.currentCacheModel.addFlushTriggerStatement(childAttributes.getProperty("statement"));
  163         }
  164       });
  165       parser.addNodelet("/sqlMap/cacheModel/flushInterval", new Nodelet() {
  166         public void process(Node node) throws Exception {
  167           Properties childAttributes = NodeletUtils.parseAttributes(node, vars.properties);
  168           long t = 0;
  169           try {
  170             vars.errorCtx.setMoreInfo("Check the cache model flush interval.");
  171             String milliseconds = childAttributes.getProperty("milliseconds");
  172             String seconds = childAttributes.getProperty("seconds");
  173             String minutes = childAttributes.getProperty("minutes");
  174             String hours = childAttributes.getProperty("hours");
  175             if (milliseconds != null) t += Integer.parseInt(milliseconds);
  176             if (seconds != null) t += Integer.parseInt(seconds) * 1000;
  177             if (minutes != null) t += Integer.parseInt(minutes) * 60 * 1000;
  178             if (hours != null) t += Integer.parseInt(hours) * 60 * 60 * 1000;
  179             if (t < 1) throw new NestedRuntimeException("A flush interval must specify one or more of milliseconds, seconds, minutes or hours.");
  180             vars.currentCacheModel.setFlushInterval(t);
  181           } catch (NumberFormatException e) {
  182             throw new NestedRuntimeException("Error building cache '" + vars.currentCacheModel.getId() + "' in '" + "resourceNAME" + "'.  Flush interval milliseconds must be a valid long integer value.  Cause: " + e, e);
  183           }
  184         }
  185       });
  186     }
  187   
  188     private void addParameterMapNodelets() {
  189       parser.addNodelet("/sqlMap/parameterMap/end()", new Nodelet() {
  190         public void process(Node node) throws Exception {
  191   
  192           vars.currentParameterMap.setParameterMappingList(vars.parameterMappingList);
  193   
  194           vars.client.getDelegate().addParameterMap(vars.currentParameterMap);
  195   
  196           vars.errorCtx.setMoreInfo(null);
  197           vars.errorCtx.setObjectId(null);
  198         }
  199       });
  200       parser.addNodelet("/sqlMap/parameterMap", new Nodelet() {
  201         public void process(Node node) throws Exception {
  202           vars.errorCtx.setActivity("building a parameter map");
  203   
  204           vars.currentParameterMap = new BasicParameterMap(vars.client.getDelegate());
  205   
  206           Properties attributes = NodeletUtils.parseAttributes(node, vars.properties);
  207           String id = applyNamespace(attributes.getProperty("id"));
  208           String parameterClassName = attributes.getProperty("class");
  209           parameterClassName = vars.typeHandlerFactory.resolveAlias(parameterClassName);
  210   
  211           vars.currentParameterMap.setId(id);
  212           vars.currentParameterMap.setResource(vars.errorCtx.getResource());
  213   
  214           vars.errorCtx.setObjectId(id + " parameter map");
  215   
  216           Class parameterClass = null;
  217           try {
  218             vars.errorCtx.setMoreInfo("Check the parameter class.");
  219             parameterClass = Resources.classForName(parameterClassName);
  220           } catch (Exception e) {
  221             //TODO: Why is this commented out?
  222             //throw new SqlMapException("Error configuring ParameterMap.  Could not set ParameterClass.  Cause: " + e, e);
  223           }
  224   
  225           vars.currentParameterMap.setParameterClass(parameterClass);
  226   
  227           vars.parameterMappingList = new ArrayList();
  228   
  229           vars.errorCtx.setMoreInfo("Check the parameter mappings.");
  230         }
  231       });
  232       parser.addNodelet("/sqlMap/parameterMap/parameter", new Nodelet() {
  233         public void process(Node node) throws Exception {
  234           Properties childAttributes = NodeletUtils.parseAttributes(node, vars.properties);
  235           String propertyName = childAttributes.getProperty("property");
  236           String jdbcType = childAttributes.getProperty("jdbcType");
  237           String javaType = childAttributes.getProperty("javaType");
  238           String nullValue = childAttributes.getProperty("nullValue");
  239           String mode = childAttributes.getProperty("mode");
  240           String callback = childAttributes.getProperty("typeHandler");
  241   
  242           callback = vars.typeHandlerFactory.resolveAlias(callback);
  243           javaType = vars.typeHandlerFactory.resolveAlias(javaType);
  244   
  245           vars.errorCtx.setObjectId(propertyName + " mapping of the " + vars.currentParameterMap.getId() + " parameter map");
  246   
  247           TypeHandler handler = null;
  248           if (callback != null) {
  249             vars.errorCtx.setMoreInfo("Check the parameter mapping typeHandler attribute '" + callback + "' (must be a TypeHandlerCallback implementation).");
  250             try {
  251               TypeHandlerCallback typeHandlerCallback = (TypeHandlerCallback) Resources.classForName(callback).newInstance();
  252               handler = new CustomTypeHandler(typeHandlerCallback);
  253             } catch (Exception e) {
  254               throw new NestedRuntimeException("Error occurred during custom type handler configuration.  Cause: " + e, e);
  255             }
  256           } else {
  257             vars.errorCtx.setMoreInfo("Check the parameter mapping property type or name.");
  258             handler = resolveTypeHandler(vars.client.getDelegate().getTypeHandlerFactory(), vars.currentParameterMap.getParameterClass(), propertyName, javaType, jdbcType);
  259           }
  260   
  261           BasicParameterMapping mapping = new BasicParameterMapping();
  262           mapping.setPropertyName(propertyName);
  263           mapping.setJdbcTypeName(jdbcType);
  264           mapping.setNullValue(nullValue);
  265           if (mode != null && mode.length() > 0) {
  266             mapping.setMode(mode);
  267           }
  268           mapping.setTypeHandler(handler);
  269           try {
  270             if (javaType != null && javaType.length() > 0) {
  271               mapping.setJavaType(Class.forName(javaType));
  272             }
  273           } catch (ClassNotFoundException e) {
  274             throw new NestedRuntimeException("Error setting javaType on parameter mapping.  Cause: " + e);
  275           }
  276   
  277           vars.parameterMappingList.add(mapping);
  278   
  279         }
  280       });
  281     }
  282   
  283     private void addResultMapNodelets() {
  284       parser.addNodelet("/sqlMap/resultMap/end()", new Nodelet() {
  285         public void process(Node node) throws Exception {
  286           vars.currentResultMap.setResultMappingList(vars.resultMappingList);
  287   
  288           vars.currentResultMap.setDiscriminator(vars.discriminator);
  289   
  290           vars.client.getDelegate().addResultMap(vars.currentResultMap);
  291   
  292           vars.errorCtx.setMoreInfo(null);
  293   
  294           vars.errorCtx.setObjectId(null);
  295         }
  296       });
  297       parser.addNodelet("/sqlMap/resultMap", new Nodelet() {
  298         public void process(Node node) throws Exception {
  299           vars.errorCtx.setActivity("building a result map");
  300   
  301           vars.currentResultMap = new BasicResultMap(vars.client.getDelegate());
  302   
  303           Properties attributes = NodeletUtils.parseAttributes(node, vars.properties);
  304           String id = applyNamespace(attributes.getProperty("id"));
  305           String resultClassName = attributes.getProperty("class");
  306           String extended = applyNamespace(attributes.getProperty("extends"));
  307           String xmlName = attributes.getProperty("xmlName");
  308           String groupBy = attributes.getProperty("groupBy");
  309           resultClassName = vars.typeHandlerFactory.resolveAlias(resultClassName);
  310   
  311           vars.errorCtx.setObjectId(id + " result map");
  312   
  313           vars.currentResultMap.setId(id);
  314           vars.currentResultMap.setXmlName(xmlName);
  315           vars.currentResultMap.setResource(vars.errorCtx.getResource());
  316   
  317           if (groupBy != null && groupBy.length() > 0) {
  318             StringTokenizer parser = new StringTokenizer(groupBy, ", ", false);
  319             while (parser.hasMoreTokens()) {
  320               vars.currentResultMap.addGroupByProperty(parser.nextToken());
  321             }
  322           }
  323   
  324           Class resultClass = null;
  325           try {
  326             vars.errorCtx.setMoreInfo("Check the result class.");
  327             resultClass = Resources.classForName(resultClassName);
  328           } catch (Exception e) {
  329             throw new NestedRuntimeException("Error configuring Result.  Could not set ResultClass.  Cause: " + e, e);
  330   
  331           }
  332   
  333           vars.currentResultMap.setResultClass(resultClass);
  334   
  335           vars.resultMappingList = new ArrayList();
  336   
  337           vars.errorCtx.setMoreInfo("Check the extended result map.");
  338           if (extended != null) {
  339             BasicResultMap extendedResultMap = (BasicResultMap) vars.client.getDelegate().getResultMap(extended);
  340             ResultMapping[] resultMappings = extendedResultMap.getResultMappings();
  341             for (int i = 0; i < resultMappings.length; i++) {
  342               vars.resultMappingList.add(resultMappings[i]);
  343             }
  344           }
  345   
  346           vars.errorCtx.setMoreInfo("Check the result mappings.");
  347           vars.resultMappingIndex = vars.resultMappingList.size();
  348   
  349         }
  350       });
  351       parser.addNodelet("/sqlMap/resultMap/result", new Nodelet() {
  352         public void process(Node node) throws Exception {
  353           Properties childAttributes = NodeletUtils.parseAttributes(node, vars.properties);
  354           String propertyName = childAttributes.getProperty("property");
  355           String nullValue = childAttributes.getProperty("nullValue");
  356           String jdbcType = childAttributes.getProperty("jdbcType");
  357           String javaType = childAttributes.getProperty("javaType");
  358           String columnName = childAttributes.getProperty("column");
  359           String columnIndex = childAttributes.getProperty("columnIndex");
  360           String statementName = childAttributes.getProperty("select");
  361           String resultMapName = childAttributes.getProperty("resultMap");
  362           String callback = childAttributes.getProperty("typeHandler");
  363   
  364           callback = vars.typeHandlerFactory.resolveAlias(callback);
  365           javaType = vars.typeHandlerFactory.resolveAlias(javaType);
  366   
  367           vars.errorCtx.setObjectId(propertyName + " mapping of the " + vars.currentResultMap.getId() + " result map");
  368   
  369           TypeHandler handler = null;
  370           if (callback != null) {
  371             vars.errorCtx.setMoreInfo("Check the result mapping typeHandler attribute '" + callback + "' (must be a TypeHandlerCallback implementation).");
  372             try {
  373               Object impl = Resources.classForName(callback).newInstance();
  374               if (impl instanceof TypeHandlerCallback) {
  375                 handler = new CustomTypeHandler((TypeHandlerCallback) impl);
  376               } else if (impl instanceof TypeHandler) {
  377                 handler = (TypeHandler) impl;
  378               } else {
  379                 throw new NestedRuntimeException ("The class '' is not a valid implementation of TypeHandler or TypeHandlerCallback");
  380               }
  381             } catch (Exception e) {
  382               throw new NestedRuntimeException("Error occurred during custom type handler configuration.  Cause: " + e, e);
  383             }
  384           } else {
  385             vars.errorCtx.setMoreInfo("Check the result mapping property type or name.");
  386             handler = resolveTypeHandler(vars.client.getDelegate().getTypeHandlerFactory(), vars.currentResultMap.getResultClass(), propertyName, javaType, jdbcType, true);
  387           }
  388   
  389   
  390           BasicResultMapping mapping = new BasicResultMapping();
  391           mapping.setPropertyName(propertyName);
  392           mapping.setColumnName(columnName);
  393           mapping.setJdbcTypeName(jdbcType);
  394           mapping.setTypeHandler(handler);
  395           mapping.setNullValue(nullValue);
  396           mapping.setStatementName(statementName);
  397           mapping.setNestedResultMapName(resultMapName);
  398   
  399           if (resultMapName != null && resultMapName.length() > 0) {
  400             vars.currentResultMap.addNestedResultMappings(mapping);
  401           }
  402   
  403           try {
  404             if (javaType != null && javaType.length() > 0) {
  405               mapping.setJavaType(Class.forName(javaType));
  406             }
  407           } catch (ClassNotFoundException e) {
  408             throw new NestedRuntimeException("Error setting javaType on result mapping.  Cause: " + e);
  409           }
  410   
  411           if (columnIndex != null && columnIndex.length() > 0) {
  412             mapping.setColumnIndex(Integer.parseInt(columnIndex));
  413           } else {
  414             vars.resultMappingIndex++;
  415             mapping.setColumnIndex(vars.resultMappingIndex);
  416           }
  417   
  418           vars.resultMappingList.add(mapping);
  419         }
  420       });
  421   
  422       parser.addNodelet("/sqlMap/resultMap/discriminator/subMap", new Nodelet() {
  423         public void process(Node node) throws Exception {
  424           if (vars.discriminator == null) {
  425             throw new NestedRuntimeException ("The discriminator is null, but somehow a subMap was reached.  This is a bug.");
  426           }
  427           Properties childAttributes = NodeletUtils.parseAttributes(node, vars.properties);
  428           String value = childAttributes.getProperty("value");
  429           String resultMap = childAttributes.getProperty("resultMap");
  430           vars.discriminator.addSubMap(value, applyNamespace(resultMap));
  431         }
  432       });
  433   
  434       parser.addNodelet("/sqlMap/resultMap/discriminator", new Nodelet() {
  435         public void process(Node node) throws Exception {
  436           Properties childAttributes = NodeletUtils.parseAttributes(node, vars.properties);
  437           String nullValue = childAttributes.getProperty("nullValue");
  438           String jdbcType = childAttributes.getProperty("jdbcType");
  439           String javaType = childAttributes.getProperty("javaType");
  440           String columnName = childAttributes.getProperty("column");
  441           String columnIndex = childAttributes.getProperty("columnIndex");
  442           String callback = childAttributes.getProperty("typeHandler");
  443   
  444           callback = vars.typeHandlerFactory.resolveAlias(callback);
  445           javaType = vars.typeHandlerFactory.resolveAlias(javaType);
  446   
  447           TypeHandler handler = null;
  448           if (callback != null) {
  449             vars.errorCtx.setMoreInfo("Check the result mapping typeHandler attribute '" + callback + "' (must be a TypeHandlerCallback implementation).");
  450             try {
  451               Object impl = Resources.classForName(callback).newInstance();
  452               if (impl instanceof TypeHandlerCallback) {
  453                 handler = new CustomTypeHandler((TypeHandlerCallback) impl);
  454               } else if (impl instanceof TypeHandler) {
  455                 handler = (TypeHandler) impl;
  456               } else {
  457                 throw new NestedRuntimeException ("The class '' is not a valid implementation of TypeHandler or TypeHandlerCallback");
  458               }
  459             } catch (Exception e) {
  460               throw new NestedRuntimeException("Error occurred during custom type handler configuration.  Cause: " + e, e);
  461             }
  462           } else {
  463             vars.errorCtx.setMoreInfo("Check the result mapping property type or name.");
  464             handler = resolveTypeHandler(vars.client.getDelegate().getTypeHandlerFactory(), vars.currentResultMap.getResultClass(), "", javaType, jdbcType, true);
  465           }
  466   
  467           BasicResultMapping mapping = new BasicResultMapping();
  468           mapping.setColumnName(columnName);
  469           mapping.setJdbcTypeName(jdbcType);
  470           mapping.setTypeHandler(handler);
  471           mapping.setNullValue(nullValue);
  472   
  473           try {
  474             if (javaType != null && javaType.length() > 0) {
  475               mapping.setJavaType(Class.forName(javaType));
  476             }
  477           } catch (ClassNotFoundException e) {
  478             throw new NestedRuntimeException("Error setting javaType on result mapping.  Cause: " + e);
  479           }
  480   
  481           if (columnIndex != null && columnIndex.length() > 0) {
  482             mapping.setColumnIndex(Integer.parseInt(columnIndex));
  483           }
  484   
  485           vars.discriminator = new Discriminator (vars.delegate, mapping);
  486         }
  487       });
  488     }
  489   
  490     private void addStatementNodelets() {
  491       parser.addNodelet("/sqlMap/statement", new Nodelet() {
  492         public void process(Node node) throws Exception {
  493           vars.currentStatement = new SqlStatementParser(vars).parseGeneralStatement(node, new GeneralStatement());
  494           vars.delegate.addMappedStatement(vars.currentStatement);
  495         }
  496       });
  497       parser.addNodelet("/sqlMap/insert", new Nodelet() {
  498         public void process(Node node) throws Exception {
  499           vars.currentStatement = new SqlStatementParser(vars).parseGeneralStatement(node, new InsertStatement());
  500           vars.delegate.addMappedStatement(vars.currentStatement);
  501         }
  502       });
  503       parser.addNodelet("/sqlMap/update", new Nodelet() {
  504         public void process(Node node) throws Exception {
  505           vars.currentStatement = new SqlStatementParser(vars).parseGeneralStatement(node, new UpdateStatement());
  506           vars.delegate.addMappedStatement(vars.currentStatement);
  507         }
  508       });
  509       parser.addNodelet("/sqlMap/delete", new Nodelet() {
  510         public void process(Node node) throws Exception {
  511           vars.currentStatement = new SqlStatementParser(vars).parseGeneralStatement(node, new DeleteStatement());
  512           vars.delegate.addMappedStatement(vars.currentStatement);
  513         }
  514       });
  515       parser.addNodelet("/sqlMap/select", new Nodelet() {
  516         public void process(Node node) throws Exception {
  517           vars.currentStatement = new SqlStatementParser(vars).parseGeneralStatement(node, new SelectStatement());
  518           vars.delegate.addMappedStatement(vars.currentStatement);
  519         }
  520       });
  521       parser.addNodelet("/sqlMap/procedure", new Nodelet() {
  522         public void process(Node node) throws Exception {
  523           vars.currentStatement = new SqlStatementParser(vars).parseGeneralStatement(node, new ProcedureStatement());
  524           vars.delegate.addMappedStatement(vars.currentStatement);
  525         }
  526       });
  527     }
  528   
  529   
  530   }

Home » iBatis-2.3.4 » com.ibatis.sqlmap.engine.builder » xml » [javadoc | source]