Mybatis SQL构建器类 - SQL类

下面是一些例子：

// 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();
}

Method（方法）	Description（描述）
SELECT(String) SELECT(String...)	开始或追加一个`SELECT`子句。可以多次调用此方法，参数将追加到`SELECT`子句中。这些参数通常是逗号分隔的列和别名列表，但也可以是驱动程序接受的任何内容。
SELECT_DISTINCT(String) SELECT_DISTINCT(String...)	开始或追加一个`SELECT`子句，并在生成的查询中添加`DISTINCT`关键字。可以多次调用此方法，参数将追加到`SELECT`子句中。这些参数通常是逗号分隔的列和别名列表，但也可以是驱动程序接受的任何内容。
FROM(String) FROM(String...)	开始或追加一个`FROM`子句。可以多次调用此方法，参数将追加到`FROM`子句中。参数通常是表名和别名，或者是驱动程序接受的任何内容。
JOIN(String) JOIN(String...) INNER_JOIN(String) INNER_JOIN(String...) LEFT_OUTER_JOIN(String) LEFT_OUTER_JOIN(String...) RIGHT_OUTER_JOIN(String) RIGHT_OUTER_JOIN(String...)	根据调用的方法，添加一个适当类型的新的`JOIN`子句。参数可以包括由列和连接条件组成的标准联接。
WHERE(String) WHERE(String...)	追加一个新的`WHERE`子句条件，使用AND进行连接。可以多次调用此方法，每次都会将新的条件与AND进行连接。使用`OR()`可以用OR进行分隔。
OR()	用OR将当前的`WHERE`子句条件进行拆分。可以多次调用，但连续多次调用会生成不可预测的SQL语句。
AND()	用AND将当前的`WHERE`子句条件进行拆分。可以多次调用，但连续多次调用会生成不可预测的SQL语句。由于`WHERE`和`HAVING`都会自动使用AND进行连接，所以这个方法很少使用，实际上只是为了完整性而包含在内。
GROUP_BY(String) GROUP_BY(String...)	追加一个新的`GROUP BY`子句元素，使用逗号进行连接。可以多次调用此方法，每次都会将新的条件与逗号进行连接。
HAVING(String) HAVING(String...)	追加一个新的`HAVING`子句条件，使用AND进行连接。可以多次调用此方法，每次都会将新的条件与AND进行连接。使用`OR()`可以用OR进行分隔。
ORDER_BY(String) ORDER_BY(String...)	追加一个新的`ORDER BY`子句元素，使用逗号进行连接。可以多次调用此方法，每次都会将新的条件与逗号进行连接。
LIMIT(String) LIMIT(int)	追加一个 ​LIMIT​子句。该方法在与SELECT()、UPDATE()和DELETE()一起使用时有效。当使用SELECT()时，此方法设计为与OFFSET()一起使用。（自3.5.2版本起可用）
OFFSET(String) OFFSET(long)	追加一个`OFFSET`子句。该方法在与SELECT()一起使用时有效。此方法设计为与LIMIT()一起使用。（自3.5.2版本起可用）
OFFSET_ROWS(String) OFFSET_ROWS(long)	追加一个`OFFSET n ROWS`子句。该方法在与SELECT()一起使用时有效。此方法设计为与FETCH_FIRST_ROWS_ONLY()一起使用。（自3.5.2版本起可用）
FETCH_FIRST_ROWS_ONLY(String) FETCH_FIRST_ROWS_ONLY(int)	追加一个`FETCH FIRST n ROWS ONLY`子句。该方法在与SELECT()一起使用时有效。此方法设计为与OFFSET_ROWS()一起使用。（自3.5.2版本起可用）
DELETE_FROM(String)	开始一个删除语句，并指定要从中删除的表。通常应该跟随一个WHERE子句！
INSERT_INTO(String)	开始一个插入语句并指定要插入的表。这之后应该跟随一个或多个VALUES()、INTO_COLUMNS()和INTO_VALUES()方法的调用。
SET(String) SET(String...)	追加到更新语句的“set”列表中。
UPDATE(String)	开始一个更新语句并指定要更新的表。这之后应该跟随一个或多个SET()方法的调用，通常还有一个WHERE()方法的调用。
VALUES(String, String)	在插入语句中追加内容。第一个参数是要插入的列，第二个参数是对应的值。
INTO_COLUMNS(String...)	追加列短语到插入语句。应该与INTO_VALUES()一起调用。
INTO_VALUES(String...)	追加值短语到插入语句。应该与INTO_COLUMNS()一起调用。
ADD_ROW()	为批量插入添加新行。（自3.5.2版本起可用）

需要注意的是，SQL类会将LIMIT、OFFSET、OFFSET n ROWS和FETCH FIRST n ROWS ONLY子句按照原样写入生成的语句中。换句话说，该库不会尝试对不直接支持这些子句的数据库进行规范化处理。因此，用户需要非常重视是否目标数据库支持这些子句。如果目标数据库不支持这些子句，那么使用这些支持很可能会创建出运行时错误的SQL语句。

从3.4.2版本开始，您可以使用可变长度参数，示例如下：

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();
}

从3.5.2版本开始，您可以按照以下方式创建用于批量插入的插入语句：

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();
}

从3.5.2版本开始，您可以按照以下方式创建用于限制搜索结果行数的选择语句：

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();
}