com.ibatis.sqlmap.engine.mapping.sql.dynamic.DynamicSql Maven / Gradle / Ivy

Go to download
/*
 * Copyright 2004-2022 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.ibatis.sqlmap.engine.mapping.sql.dynamic;

import com.ibatis.sqlmap.engine.impl.SqlMapExecutorDelegate;
import com.ibatis.sqlmap.engine.mapping.parameter.InlineParameterMapParser;
import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMap;
import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMapping;
import com.ibatis.sqlmap.engine.mapping.result.ResultMap;
import com.ibatis.sqlmap.engine.mapping.sql.Sql;
import com.ibatis.sqlmap.engine.mapping.sql.SqlChild;
import com.ibatis.sqlmap.engine.mapping.sql.SqlText;
import com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements.*;
import com.ibatis.sqlmap.engine.mapping.sql.simple.SimpleDynamicSql;
import com.ibatis.sqlmap.engine.mapping.statement.MappedStatement;
import com.ibatis.sqlmap.engine.scope.StatementScope;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * The Class DynamicSql.
 */
public class DynamicSql implements Sql, DynamicParent {

  /** The Constant PARAM_PARSER. */
  private static final InlineParameterMapParser PARAM_PARSER = new InlineParameterMapParser();

  /** The children. */
  private List children = new ArrayList();

  /** The delegate. */
  private SqlMapExecutorDelegate delegate;

  /**
   * Instantiates a new dynamic sql.
   *
   * @param delegate
   *          the delegate
   */
  public DynamicSql(SqlMapExecutorDelegate delegate) {
    this.delegate = delegate;
  }

  public String getSql(StatementScope statementScope, Object parameterObject) {
    String sql = statementScope.getDynamicSql();
    if (sql == null) {
      process(statementScope, parameterObject);
      sql = statementScope.getDynamicSql();
    }
    return sql;
  }

  public ParameterMap getParameterMap(StatementScope statementScope, Object parameterObject) {
    ParameterMap map = statementScope.getDynamicParameterMap();
    if (map == null) {
      process(statementScope, parameterObject);
      map = statementScope.getDynamicParameterMap();
    }
    return map;
  }

  public ResultMap getResultMap(StatementScope statementScope, Object parameterObject) {
    return statementScope.getResultMap();
  }

  public void cleanup(StatementScope statementScope) {
    statementScope.setDynamicSql(null);
    statementScope.setDynamicParameterMap(null);
  }

  /**
   * Process.
   *
   * @param statementScope
   *          the statement scope
   * @param parameterObject
   *          the parameter object
   */
  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);
  }

  /**
   * Process body children.
   *
   * @param statementScope
   *          the statement scope
   * @param ctx
   *          the ctx
   * @param parameterObject
   *          the parameter object
   * @param localChildren
   *          the local children
   */
  private void processBodyChildren(StatementScope statementScope, SqlTagContext ctx, Object parameterObject,
      Iterator localChildren) {
    PrintWriter out = ctx.getWriter();
    processBodyChildren(statementScope, ctx, parameterObject, localChildren, out);
  }

  /**
   * Process body children.
   *
   * @param statementScope
   *          the statement scope
   * @param ctx
   *          the ctx
   * @param parameterObject
   *          the parameter object
   * @param localChildren
   *          the local children
   * @param out
   *          the out
   */
  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) {
            StringBuilder sqlStatementBuffer = new StringBuilder(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 = (SqlTag) child;
        SqlTagHandler handler = tag.getHandler();
        int response = SqlTagHandler.INCLUDE_BODY;
        do {
          StringWriter sw = new StringWriter();
          PrintWriter pw = new PrintWriter(sw);

          response = handler.doStartFragment(ctx, tag, parameterObject);
          if (response != SqlTagHandler.SKIP_BODY) {

            processBodyChildren(statementScope, ctx, parameterObject, tag.getChildren(), pw);
            pw.flush();
            pw.close();
            StringBuilder body = new StringBuilder(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();
        }

      }
    }
  }

  /**
   * Iterate property replace.
   *
   * @param bodyContent
   *          the body content
   * @param iterate
   *          the iterate
   */
  protected void iteratePropertyReplace(StringBuilder bodyContent, IterateContext iterate) {
    if (iterate != null) {
      String[] mappings = new String[] { "#", "$" };
      for (int i = 0; i < mappings.length; i++) {
        int startIndex = 0;
        int endIndex = -1;
        while (startIndex > -1 && startIndex < bodyContent.length()) {
          startIndex = bodyContent.indexOf(mappings[i], endIndex + 1);
          endIndex = bodyContent.indexOf(mappings[i], startIndex + 1);
          if (startIndex > -1 && endIndex > -1) {
            bodyContent.replace(startIndex + 1, endIndex,
                iterate.addIndexToTagProperty(bodyContent.substring(startIndex + 1, endIndex)));
          }
        }
      }
    }
  }

  /**
   * Replace.
   *
   * @param builder
   *          the builder
   * @param find
   *          the find
   * @param replace
   *          the replace
   */
  protected static void replace(StringBuilder builder, String find, String replace) {
    int pos = builder.toString().indexOf(find);
    int len = find.length();
    while (pos > -1) {
      builder.replace(pos, pos + len, replace);
      pos = builder.toString().indexOf(find);
    }
  }

  public void addChild(SqlChild child) {
    children.add(child);
  }

}