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

你可能感兴趣的:(Mybatis,mybatis)