ibatis的动态sql

位于包
com.ibatis.sqlmap.engine.mapping.sql.dynamic
。ibatis的标签和mybatis的标签之间，区别已经很大了


ibatis在启动的时候，会把所有的sql对象解析出来，并初始化为对应的实际实现。Sql对象的实现类有很多，常见的有
StaticSql，这个是纯净态的，没有动态SQL
DynamicSql是包含了动态标签的SQL对象。

理解了动态SQL其他都是类似原理。

<select id="selectOutSales" resultClass="hashmap">
		SELECT
		t_tz_btscxx.BTSCID,
		t_tz_btscxx.SZTZDID,
		t_tz_btscxx.TZSXH,
		t_tz_btscxx.RTSJ,
		t_tz_btscxx.RTSL,
		t_tz_btscxx.SCLXDM,
		t_tz_btscxx.RTSCX,
		t_tz_btscxx.ZZL,
		t_tz_btscxx.SCZT,
		t_tz_btscxx.SFWCTZ,
		t_tz_btscxx.WCTZSJ,
		t_tz_btscxx.CJRY,
		t_tz_btscxx.CJRQ,
		t_tz_btscxx.XGRY,
		t_tz_btscxx.XGRQ,
		t_tz_btscxx.SCBJ
		FROM
		t_tz_btscxx
		<dynamic prepend="where">
			<isNotEmpty prepend="and" property="BTSCID">
				BTSCID like '%$BTSCID$%'
			</isNotEmpty>
		</dynamic>
	</select>

如上配置的一个sql语句，第一层节点有三个，text，dynamic元素，text（这个属于XML的知识，具体从XML脑补）。

在调用该SQL的时候，会执行是DynamicSql的
process方法

private void process(StatementScope statementScope, Object parameterObject) {
    SqlTagContext ctx = new SqlTagContext();
    List localChildren = children;
    processBodyChildren(statementScope, ctx, parameterObject, localChildren.iterator());

    ParameterMap map = new ParameterMap(delegate);
    map.setId(statementScope.getStatement().getId() + "-InlineParameterMap");
    map.setParameterClass(((MappedStatement) statementScope.getStatement()).getParameterClass());
    map.setParameterMappingList(ctx.getParameterMappings());

    String dynSql = ctx.getBodyText();

    // Processes $substitutions$ after DynamicSql
    if (SimpleDynamicSql.isSimpleDynamicSql(dynSql)) {
      dynSql = new SimpleDynamicSql(delegate, dynSql).getSql(statementScope, parameterObject);
    }

    statementScope.setDynamicSql(dynSql);
    statementScope.setDynamicParameterMap(map);
  }

比较重要的方法

//这是处理SQL内部各个节点的方法
private void processBodyChildren(StatementScope statementScope, SqlTagContext ctx, Object parameterObject, Iterator localChildren, PrintWriter out) {
//每个节点都需要被处理
    while (localChildren.hasNext()) {
      SqlChild child = (SqlChild) localChildren.next();
//纯文本节点，处理比较简单，就是把参数等解析出来。
      if (child instanceof SqlText) {
        SqlText sqlText = (SqlText) child;
        String sqlStatement = sqlText.getText();
        if (sqlText.isWhiteSpace()) {
          out.print(sqlStatement);
        } else if (!sqlText.isPostParseRequired()) {

          // BODY OUT
          out.print(sqlStatement);

          ParameterMapping[] mappings = sqlText.getParameterMappings();
          if (mappings != null) {
            for (int i = 0, n = mappings.length; i < n; i++) {
              ctx.addParameterMapping(mappings[i]);
            }
          }
        } else {

          IterateContext itCtx = ctx.peekIterateContext();

          if(null != itCtx && itCtx.isAllowNext()){
            itCtx.next();
            itCtx.setAllowNext(false);
            if(!itCtx.hasNext()) {
              itCtx.setFinal(true);
            }
          }

          if(itCtx!=null) {
            StringBuffer sqlStatementBuffer = new StringBuffer(sqlStatement);
            iteratePropertyReplace(sqlStatementBuffer, itCtx);
            sqlStatement = sqlStatementBuffer.toString();
          }

          sqlText = PARAM_PARSER.parseInlineParameterMap(delegate.getTypeHandlerFactory(), sqlStatement);

          ParameterMapping[] mappings = sqlText.getParameterMappings();
          out.print(sqlText.getText());
          if (mappings != null) {
             for (int i = 0, n = mappings.length; i < n; i++) {
               ctx.addParameterMapping(mappings[i]);
             }
          }
        }
      } else if (child instanceof SqlTag) {
//节点本身就是一个节点。每种节点都有自己的显示，每个节点实际上用的是SqlTag，一种Tag的子类。内部包含了SqlTagHandler，每个SqlTag都会初始化自己的处理器。对于dynamic使用的是DynamicTagHandler
        SqlTag tag = (SqlTag) child;
        SqlTagHandler handler = tag.getHandler();
        int response = SqlTagHandler.INCLUDE_BODY;
        do {
          StringWriter sw = new StringWriter();
          PrintWriter pw = new PrintWriter(sw);
          //这句比较重要，对于条件标签，如果条件不满足，会返回SKIP_BODY，来跳过该元素处理
          response = handler.doStartFragment(ctx, tag, parameterObject);
          if (response != SqlTagHandler.SKIP_BODY) {

            processBodyChildren(statementScope, ctx, parameterObject, tag.getChildren(), pw);
            pw.flush();
            pw.close();
            StringBuffer body = sw.getBuffer();
            response = handler.doEndFragment(ctx, tag, parameterObject, body);
            handler.doPrepend(ctx, tag, parameterObject, body);
            
            if (response != SqlTagHandler.SKIP_BODY) {
              if (body.length() > 0) {
                out.print(body.toString());
              }
            }

          }
        } while (response == SqlTagHandler.REPEAT_BODY);

        ctx.popRemoveFirstPrependMarker(tag);

        if(ctx.peekIterateContext()!= null && ctx.peekIterateContext().getTag() == tag) {
          ctx.setAttribute(ctx.peekIterateContext().getTag(), null);
          ctx.popIterateContext();
        }

      }
    }
  }

dynamic元素有三个属性
prepend="where" open="" close=""

prepend和open是在DynamicTagHandler的doStartFragment和doPrepend共同完成处理，close是在doEndFragment处理的。

public class DynamicTagHandler extends BaseTagHandler {

  public int doStartFragment(SqlTagContext ctx, SqlTag tag, Object parameterObject) {
//DynamicTagHandler的doStartFragment只是负责把RemoveFirstPrependMarker标记对象创建和压入。
    ctx.pushRemoveFirstPrependMarker(tag);
    return BaseTagHandler.INCLUDE_BODY;
  }

}

public void pushRemoveFirstPrependMarker(SqlTag tag) {
    
    if(tag.getHandler() instanceof DynamicTagHandler) {
//对于DynamicTagHandler之类的条件标签，如果开启了prepend属性，需要设置标记为true。这会造成之后的条件语句的改变，即当出现过一个条件满足时，之后的条件的prepend才会有效，而DynamicTagHandler本身的prepend也才会生效。

对于只有条件，而没有对应的上级（select 标签元素等不是上级），只要满足了条件，那么就会追加prepend，而不管具体是不是第一次满足。
      // this was added to retain default behavior
      if(tag.isPrependAvailable()) {
        removeFirstPrependStack.addFirst(
            new RemoveFirstPrependMarker(tag,true));
      } else {
        removeFirstPrependStack.addFirst(
            new RemoveFirstPrependMarker(tag,false));
      }
    } else if("true".equals(tag.getRemoveFirstPrepend())
        || "iterate".equals(tag.getRemoveFirstPrepend())){
      // you must be specific about the removal otherwise it
      // will function as ibatis has always functioned and add
      // the prepend
      removeFirstPrependStack.addFirst(
          new RemoveFirstPrependMarker(tag,true));
    } else if(!tag.isPrependAvailable() && 
        !"true".equals(tag.getRemoveFirstPrepend()) &&
        !"iterate".equals(tag.getRemoveFirstPrepend()) &&
        tag.getParent() != null) {
      // if no prepend or removeFirstPrepend is specified 
      // we need to look to the parent tag for default values
      if("true".equals(tag.getParent().getRemoveFirstPrepend())
          || "iterate".equals(tag.getParent().getRemoveFirstPrepend())) {
        removeFirstPrependStack.addFirst(
            new RemoveFirstPrependMarker(tag,true));
      }
    } else {
      removeFirstPrependStack.addFirst(
          new RemoveFirstPrependMarker(tag,false));
    }

  }

由于dynamic包含了isNotEmpty，因此在dynamic处理之前，需要处理isNotEmpty，
isNotEmpty之前的处理是和dynamic类似的。


isNotEmpty的doPrepend方法是BaseTagHandler的，并没有改写

public void doPrepend(SqlTagContext ctx, SqlTag tag, Object parameterObject, StringBuffer bodyContent) {
    
//可以看到open属性是先于prepend属性处理的。但是每次sql字符插入都是从0位置插入，所以open先处理，但是当open和prepend都存在，prepend会插入到open之前的位置。
    if (tag.isOpenAvailable() && !(tag.getHandler() instanceof IterateTagHandler)) {
      if (bodyContent.toString().trim().length() > 0) {
        bodyContent.insert(0, tag.getOpenAttr());
      }
    }
    
    if (tag.isPrependAvailable()) {
      if (bodyContent.toString().trim().length() > 0) {
//这里看到对于标记是true的，那么第一次不进行追加
//ctx.peekRemoveFirstPrependMarker(tag)取的是堆栈的第二个数据，而不是最顶部的数据。如上的配置，当处理IsNotEmpty的时候，取得是它的父级dynamic的设置。

//实际上ibatis的实现者把父级也看成和子元素一样的的平行级别处理了，
P---
        C---1
        C---2
变成了
C---1
C---2
P---
的结构，那么当C--1满足，C1不进行住家prepend，而C--2和P--则需要。

        if (tag.getParent() != null && ctx.peekRemoveFirstPrependMarker(tag)) {
          ctx.disableRemoveFirstPrependMarker();
        }else {
          bodyContent.insert(0, tag.getPrependAttr());
        }
      }
    }

  }