<?xml version="1.0" encoding="UTF-8"?>
<!--

       Copyright ${license.git.copyrightYears} 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

          http://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.

-->
<document xmlns="http://maven.apache.org/XDOC/2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/XDOC/2.0 http://maven.apache.org/xsd/xdoc-2.0.xsd">

  <properties>
    <title>MyBatis 3 | SQL语句构建器</title>
    <author email="clinton.begin@gmail.com">Clinton Begin</author>
    <author email="nanlei1987@gmail.com">Nan Lei</author>
  </properties>

  <body>
    <section name="SQL语句构建器类">
      <subsection name="问题">
        <p>Java程序员面对的最痛苦的事情之一就是在Java代码中嵌入SQL语句。这么来做通常是由于SQL语句需要动态来生成-否则可以将它们放到外部文件或者存储过程中。正如你已经看到的那样，MyBatis在它的XML映射特性中有一个强大的动态SQL生成方案。但有时在Java代码内部创建SQL语句也是必要的。此时，MyBatis有另外一个特性可以帮到你，在减少典型的加号,引号,新行,格式化问题和嵌入条件来处理多余的逗号或 AND 连接词之前。事实上，在Java代码中来动态生成SQL代码就是一场噩梦。例如：
        </p>

        <source><![CDATA[
String sql = "SELECT P.ID, P.USERNAME, P.PASSWORD, P.FULL_NAME, "
"P.LAST_NAME,P.CREATED_ON, P.UPDATED_ON " +
"FROM PERSON P, ACCOUNT A " +
"INNER JOIN DEPARTMENT D on D.ID = P.DEPARTMENT_ID " +
"INNER JOIN COMPANY C on D.COMPANY_ID = C.ID " +
"WHERE (P.ID = A.ID AND P.FIRST_NAME like ?) " +
"OR (P.LAST_NAME like ?) " +
"GROUP BY P.ID " +
"HAVING (P.LAST_NAME like ?) " +
"OR (P.FIRST_NAME like ?) " +
"ORDER BY P.ID, P.FULL_NAME";
]]></source>
      </subsection>
      <subsection name="The Solution">
      <p>MyBatis 3提供了方便的工具类来帮助解决该问题。使用SQL类，简单地创建一个实例来调用方法生成SQL语句。上面示例中的问题就像重写SQL类那样：
      </p>

      <source><![CDATA[
private String selectPersonSql() {
  return new SQL() {{
    SELECT("P.ID, P.USERNAME, P.PASSWORD, P.FULL_NAME");
    SELECT("P.LAST_NAME, P.CREATED_ON, P.UPDATED_ON");
    FROM("PERSON P");
    FROM("ACCOUNT A");
    INNER_JOIN("DEPARTMENT D on D.ID = P.DEPARTMENT_ID");
    INNER_JOIN("COMPANY C on D.COMPANY_ID = C.ID");
    WHERE("P.ID = A.ID");
    WHERE("P.FIRST_NAME like ?");
    OR();
    WHERE("P.LAST_NAME like ?");
    GROUP_BY("P.ID");
    HAVING("P.LAST_NAME like ?");
    OR();
    HAVING("P.FIRST_NAME like ?");
    ORDER_BY("P.ID");
    ORDER_BY("P.FULL_NAME");
  }}.toString();
}
]]></source>

      <p>该例中有什么特殊之处？当你仔细看时，那不用担心偶然间重复出现的"AND"关键字，或者在"WHERE"和"AND"之间的选择，抑或什么都不选。该SQL类非常注意"WHERE"应该出现在何处，哪里又应该使用"AND"，还有所有的字符串链接。
        </p>

      </subsection>

      <subsection name="SQL类">

        <p>这里给出一些示例：</p>

        <source><![CDATA[
// Anonymous inner class
public String deletePersonSql() {
  return new SQL() {{
    DELETE_FROM("PERSON");
    WHERE("ID = #{id}");
  }}.toString();
}

// Builder / Fluent style
public String insertPersonSql() {
  String sql = new SQL()
    .INSERT_INTO("PERSON")
    .VALUES("ID, FIRST_NAME", "#{id}, #{firstName}")
    .VALUES("LAST_NAME", "#{lastName}")
    .toString();
  return sql;
}

// With conditionals (note the final parameters, required for the anonymous inner class to access them)
public String selectPersonLike(final String id, final String firstName, final String lastName) {
  return new SQL() {{
    SELECT("P.ID, P.USERNAME, P.PASSWORD, P.FIRST_NAME, P.LAST_NAME");
    FROM("PERSON P");
    if (id != null) {
      WHERE("P.ID like #{id}");
    }
    if (firstName != null) {
      WHERE("P.FIRST_NAME like #{firstName}");
    }
    if (lastName != null) {
      WHERE("P.LAST_NAME like #{lastName}");
    }
    ORDER_BY("P.LAST_NAME");
  }}.toString();
}

public String deletePersonSql() {
  return new SQL() {{
    DELETE_FROM("PERSON");
    WHERE("ID = #{id}");
  }}.toString();
}

public String insertPersonSql() {
  return new SQL() {{
    INSERT_INTO("PERSON");
    VALUES("ID, FIRST_NAME", "#{id}, #{firstName}");
    VALUES("LAST_NAME", "#{lastName}");
  }}.toString();
}

public String updatePersonSql() {
  return new SQL() {{
    UPDATE("PERSON");
    SET("FIRST_NAME = #{firstName}");
    WHERE("ID = #{id}");
  }}.toString();
}
]]></source>

        <table>
          <thead>
            <tr>
              <th>方法</th>
              <th>描述</th>
            </tr>
          </thead>
          <tbody>
            <tr>
              <td>
                <ul>
                  <li>
                    <code>SELECT(String)</code>
                  </li>
                  <li>
                    <code>SELECT(String...)</code>
                  </li>
                </ul>
              </td>
              <td>开始或插入到
                <code>SELECT</code>子句。
                可以被多次调用，参数也会添加到
                <code>SELECT</code>子句。
                参数通常使用逗号分隔的列名和别名列表，但也可以是数据库驱动程序接受的任意类型。
              </td>
            </tr>
            <tr>
              <td>
                <ul>
                  <li>
                    <code>SELECT_DISTINCT(String)</code>
                  </li>
                  <li>
                    <code>SELECT_DISTINCT(String...)</code>
                  </li>
                </ul>
              </td>
              <td>开始或插入到
                <code>SELECT</code>子句，
                也可以插入
                <code>DISTINCT</code>关键字到生成的查询语句中。
                可以被多次调用，参数也会添加到
                <code>SELECT</code>子句。
                 参数通常使用逗号分隔的列名和别名列表，但也可以是数据库驱动程序接受的任意类型。
              </td>
            </tr>
            <tr>
              <td>
                <ul>
                  <li>
                    <code>FROM(String)</code>
                  </li>
                  <li>
                    <code>FROM(String...)</code>
                  </li>
                </ul>
              </td>
              <td>开始或插入到
                <code>FROM</code>子句。
                可以被多次调用，参数也会添加到
                <code>FROM</code>子句。
                参数通常是表名或别名，也可以是数据库驱动程序接受的任意类型。
              </td>
            </tr>
            <tr>
              <td>
                <ul>
                  <li>
                    <code>JOIN(String)</code>
                  </li>
                  <li>
                    <code>JOIN(String...)</code>
                  </li>
                  <li>
                    <code>INNER_JOIN(String)</code>
                  </li>
                  <li>
                    <code>INNER_JOIN(String...)</code>
                  </li>
                  <li>
                    <code>LEFT_OUTER_JOIN(String)</code>
                  </li>
                  <li>
                    <code>LEFT_OUTER_JOIN(String...)</code>
                  </li>
                  <li>
                    <code>RIGHT_OUTER_JOIN(String)</code>
                  </li>
                  <li>
                    <code>RIGHT_OUTER_JOIN(String...)</code>
                  </li>
                </ul>
              </td>
              <td>基于调用的方法，添加新的合适类型的
                <code>JOIN</code>子句。
				参数可以包含由列命和join on条件组合成标准的join。
              </td>
            </tr>
            <tr>
              <td>
                <ul>
                  <li>
                    <code>WHERE(String)</code>
                  </li>
                  <li>
                    <code>WHERE(String...)</code>
                  </li>
                </ul>
              </td>
              <td>插入新的
                <code>WHERE</code>子句条件，
                由<code>AND</code>链接。可以多次被调用，每次都由<code>AND</code>来链接新条件。使用
                <code>OR()</code>
                来分隔<code>OR</code>。
              </td>
            </tr>
            <tr>
              <td>
                <code>OR()</code>
              </td>
              <td>使用<code>OR</code>来分隔当前的
                <code>WHERE</code>子句条件。
				可以被多次调用，但在一行中多次调用或生成不稳定的<code>SQL</code>。
              </td>
            </tr>
            <tr>
              <td>
                <code>AND()</code>
              </td>
              <td>使用<code>AND</code>来分隔当前的
                <code>WHERE</code>子句条件。
				可以被多次调用，但在一行中多次调用或生成不稳定的<code>SQL</code>。因为
                <code>WHERE</code>
                和
                <code>HAVING</code>
                二者都会自动链接
                <code>AND</code>, 这是非常罕见的方法，只是为了完整性才被使用。
              </td>
            </tr>
            <tr>
              <td>
                <ul>
                  <li>
                    <code>GROUP_BY(String)</code>
                  </li>
                  <li>
                    <code>GROUP_BY(String...)</code>
                  </li>
                </ul>
              </td>
              <td>插入新的
                <code>GROUP BY</code>子句元素，由逗号连接。
				可以被多次调用，每次都由逗号连接新的条件。
              </td>
            </tr>
            <tr>
              <td>
                <ul>
                  <li>
                    <code>HAVING(String)</code>
                  </li>
                  <li>
                    <code>HAVING(String...)</code>
                  </li>
                </ul>
              </td>
              <td>插入新的
                <code>HAVING</code>子句条件。
                由AND连接。可以被多次调用，每次都由<code>AND</code>来连接新的条件。使用
                <code>OR()</code>
                来分隔<code>OR</code>.
              </td>
            </tr>
            <tr>
              <td>
                <ul>
                  <li>
                    <code>ORDER_BY(String)</code>
                  </li>
                  <li>
                    <code>ORDER_BY(String...)</code>
                  </li>
                </ul>
              </td>
              <td>插入新的
                <code>ORDER BY</code>子句元素，
                由逗号连接。可以多次被调用，每次由逗号连接新的条件。
              </td>
            </tr>
            <tr>
              <td>
                <ul>
                  <li>
                    <code>LIMIT(String)</code>
                  </li>
                  <li>
                    <code>LIMIT(int)</code>
                  </li>
                </ul>
              </td>
              <td>
                Appends a <code>LIMIT</code> clause.
                This method valid when use together with SELECT(), UPDATE() and DELETE().
                And this method is designed to use together with OFFSET() when use SELECT(). (Available since 3.5.2)
              </td>
            </tr>
            <tr>
              <td>
                <ul>
                  <li>
                    <code>OFFSET(String)</code>
                  </li>
                  <li>
                    <code>OFFSET(long)</code>
                  </li>
                </ul>
              </td>
              <td>
                Appends a <code>OFFSET</code> clause.
                This method valid when use together with SELECT().
                And this method is designed to use together with LIMIT(). (Available since 3.5.2)
              </td>
            </tr>
            <tr>
              <td>
                <ul>
                  <li>
                    <code>OFFSET_ROWS(String)</code>
                  </li>
                  <li>
                    <code>OFFSET_ROWS(long)</code>
                  </li>
                </ul>
              </td>
              <td>
                Appends a <code>OFFSET n ROWS</code> clause.
                This method valid when use together with SELECT().
                And this method is designed to use together with FETCH_FIRST_ROWS_ONLY(). (Available since 3.5.2)
              </td>
            </tr>
            <tr>
              <td>
                <ul>
                  <li>
                    <code>FETCH_FIRST_ROWS_ONLY(String)</code>
                  </li>
                  <li>
                    <code>FETCH_FIRST_ROWS_ONLY(int)</code>
                  </li>
                </ul>
              </td>
              <td>
                Appends a <code>FETCH FIRST n ROWS ONLY</code> clause.
                This method valid when use together with SELECT().
                And this method is designed to use together with OFFSET_ROWS(). (Available since 3.5.2)
              </td>
            </tr>
            <tr>
              <td>
                <code>DELETE_FROM(String)</code>
              </td>
              <td>开始一个delete语句并指定需要从哪个表删除的表名。通常它后面都会跟着WHERE语句！
              </td>
            </tr>
            <tr>
              <td>
                <code>INSERT_INTO(String)</code>
              </td>
              <td>开始一个insert语句并指定需要插入数据的表名。后面都会跟着一个或者多个VALUES() or INTO_COLUMNS() and INTO_VALUES()。
              </td>
            </tr>
            <tr>
              <td>
                <ul>
                  <li>
                    <code>SET(String)</code>
                  </li>
                  <li>
                    <code>SET(String...)</code>
                  </li>
                </ul>
              </td>
              <td>针对update语句，插入到"set"列表中</td>
            </tr>
            <tr>
              <td>
                <code>UPDATE(String)</code>
              </td>
              <td>开始一个update语句并指定需要更新的表明。后面都会跟着一个或者多个SET()，通常也会有一个WHERE()。
              </td>
            </tr>
            <tr>
              <td>
                <code>VALUES(String, String)</code>
              </td>
              <td>插入到insert语句中。第一个参数是要插入的列名，第二个参数则是该列的值。
              </td>
            </tr>
            <tr>
              <td>
                <code>INTO_COLUMNS(String...)</code>
              </td>
              <td>
                Appends columns phrase to an insert statement.
                This should be call INTO_VALUES() with together.
              </td>
            </tr>
            <tr>
              <td>
                <code>INTO_VALUES(String...)</code>
              </td>
              <td>
                Appends values phrase to an insert statement.
                This should be call INTO_COLUMNS() with together.
              </td>
            </tr>
            <tr>
              <td>
                <code>ADD_ROW()</code>
              </td>
              <td>
                Add new row for bulk insert. (Available since 3.5.2)
              </td>
            </tr>
          </tbody>
        </table>

        <p>
          <span class="label important">NOTE</span>
          It is important to note that SQL class writes <code>LIMIT</code>, <code>OFFSET</code>, <code>OFFSET n ROWS</code> and <code>FETCH FIRST n ROWS ONLY</code> clauses into the generated statement as is.
          In other words, the library does not attempt to normalize those values for databases that don’t support these clauses directly.
          Therefore, it is very important for users to understand whether or not the target database supports these clauses.
          If the target database does not support these clauses, then it is likely that using this support will create SQL that has runtime errors.
        </p>

        <p>Since version 3.4.2, you can use variable-length arguments as follows:</p>

<source><![CDATA[
public String selectPersonSql() {
  return new SQL()
    .SELECT("P.ID", "A.USERNAME", "A.PASSWORD", "P.FULL_NAME", "D.DEPARTMENT_NAME", "C.COMPANY_NAME")
    .FROM("PERSON P", "ACCOUNT A")
    .INNER_JOIN("DEPARTMENT D on D.ID = P.DEPARTMENT_ID", "COMPANY C on D.COMPANY_ID = C.ID")
    .WHERE("P.ID = A.ID", "P.FULL_NAME like #{name}")
    .ORDER_BY("P.ID", "P.FULL_NAME")
    .toString();
}

public String insertPersonSql() {
  return new SQL()
    .INSERT_INTO("PERSON")
    .INTO_COLUMNS("ID", "FULL_NAME")
    .INTO_VALUES("#{id}", "#{fullName}")
    .toString();
}

public String updatePersonSql() {
  return new SQL()
    .UPDATE("PERSON")
    .SET("FULL_NAME = #{fullName}", "DATE_OF_BIRTH = #{dateOfBirth}")
    .WHERE("ID = #{id}")
    .toString();
}
]]></source>

        <p>Since version 3.5.2, you can create insert statement for bulk insert as follow:</p>

        <source><![CDATA[
public String insertPersonsSql() {
  // INSERT INTO PERSON (ID, FULL_NAME)
  //     VALUES (#{mainPerson.id}, #{mainPerson.fullName}) , (#{subPerson.id}, #{subPerson.fullName})
  return new SQL()
    .INSERT_INTO("PERSON")
    .INTO_COLUMNS("ID", "FULL_NAME")
    .INTO_VALUES("#{mainPerson.id}", "#{mainPerson.fullName}")
    .ADD_ROW()
    .INTO_VALUES("#{subPerson.id}", "#{subPerson.fullName}")
    .toString();
}
]]></source>

        <p>Since version 3.5.2, you can create select statement for limiting search result rows clause as follow:</p>

        <source><![CDATA[
public String selectPersonsWithOffsetLimitSql() {
  // SELECT id, name FROM PERSON
  //     LIMIT #{limit} OFFSET #{offset}
  return new SQL()
    .SELECT("id", "name")
    .FROM("PERSON")
    .LIMIT("#{limit}")
    .OFFSET("#{offset}")
    .toString();
}

public String selectPersonsWithFetchFirstSql() {
  // SELECT id, name FROM PERSON
  //     OFFSET #{offset} ROWS FETCH FIRST #{limit} ROWS ONLY
  return new SQL()
    .SELECT("id", "name")
    .FROM("PERSON")
    .OFFSET_ROWS("#{offset}")
    .FETCH_FIRST_ROWS_ONLY("#{limit}")
    .toString();
}
]]></source>

      </subsection>

      <subsection name="SqlBuilder 和 SelectBuilder (已经废弃)">
        <p>
          在3.2版本之前，我们使用了一点不同的做法，通过实现ThreadLocal变量来掩盖一些导致Java DSL麻烦的语言限制。但这种方式已经废弃了，现代的框架都欢迎人们使用构建器类型和匿名内部类的想法。因此，SelectBuilder 和 SqlBuilder 类都被废弃了。
        </p>
        <p>
          下面的方法仅仅适用于废弃的SqlBuilder 和 SelectBuilder 类。
        </p>
        <table>
        <thead>
          <tr>
            <th>方法</th>
            <th>描述</th>
          </tr>
        </thead>
        <tbody>
        <tr>
          <td>
            <code>BEGIN()</code>
            /
            <code>RESET()</code>
          </td>
          <td>这些方法清空SelectBuilder类的ThreadLocal状态，并且准备一个新的构建语句。开始新的语句时，
            <code>BEGIN()</code>读取得最好。
			由于一些原因（在某些条件下，也许是逻辑需要一个完全不同的语句），在执行中清理语句
            <code>RESET()</code>读取得最好。
          </td>
        </tr>
        <tr>
          <td>
            <code>SQL()</code>
          </td>
          <td>返回生成的
            <code>SQL()</code>
            并重置
            <code>SelectBuilder</code>
            状态 (好像
            <code>BEGIN()</code>
            或
            <code>RESET()</code>
            被调用了).
            因此，该方法只能被调用一次！
          </td>
        </tr>
        </tbody>
        </table>

        <p>
          SelectBuilder 和 SqlBuilder 类并不神奇，但是知道它们如何工作也是很重要的。
          SelectBuilder 使用 SqlBuilder 使用了静态导入和ThreadLocal变量的组合来开启整洁语法，可以很容易地和条件交错。使用它们，静态导入类的方法即可，就像这样(一个或其它，并非两者):
        </p>

        <source>import static org.apache.ibatis.jdbc.SelectBuilder.*;</source>
        <source>import static org.apache.ibatis.jdbc.SqlBuilder.*;</source>

        <p>这就允许像下面这样来创建方法：</p>

        <source><![CDATA[
/* DEPRECATED */
public String selectBlogsSql() {
  BEGIN(); // Clears ThreadLocal variable
  SELECT("*");
  FROM("BLOG");
  return SQL();
}
        ]]></source>

        <source><![CDATA[
/* DEPRECATED */
private String selectPersonSql() {
  BEGIN(); // Clears ThreadLocal variable
  SELECT("P.ID, P.USERNAME, P.PASSWORD, P.FULL_NAME");
  SELECT("P.LAST_NAME, P.CREATED_ON, P.UPDATED_ON");
  FROM("PERSON P");
  FROM("ACCOUNT A");
  INNER_JOIN("DEPARTMENT D on D.ID = P.DEPARTMENT_ID");
  INNER_JOIN("COMPANY C on D.COMPANY_ID = C.ID");
  WHERE("P.ID = A.ID");
  WHERE("P.FIRST_NAME like ?");
  OR();
  WHERE("P.LAST_NAME like ?");
  GROUP_BY("P.ID");
  HAVING("P.LAST_NAME like ?");
  OR();
  HAVING("P.FIRST_NAME like ?");
  ORDER_BY("P.ID");
  ORDER_BY("P.FULL_NAME");
  return SQL();
}
        ]]></source>

      </subsection>


    </section>
  </body>

</document>
