Fenix (fenix 1.1.0 API)

java.lang.Object
- com.blinkfox.fenix.core.Fenix

```
public final class Fenix
extends Object
```
使用 XML 或者 Java 链式写法来拼接 JPQL 或者 SQL 语句和对应命名参数的 SqlInfo 信息的核心 API 类.

作者:

blinkfox on 2019-08-11.

另请参阅:

FenixXmlBuilder

方法概要

所有方法静态方法实例方法具体方法
限定符和类型	方法和说明
`Fenix`	`and()` 拼接并带上 'AND' 关键字的字符串.
`Fenix`	`and(String text)` 拼接并带上 'AND' 关键字和其他文本的字符串.
`Fenix`	`andBetween(String field, Object startValue, Object endValue)` 生成带 " AND " 前缀的 BETWEEN 区间查询的 SQL 片段(当某一个值为 null 时，会是大于等于或小于等于的情形).
`Fenix`	`andBetween(String field, Object startValue, Object endValue, boolean match)` 生成带 " AND " 前缀的 BETWEEN 区间查询的 SQL 片段,如果 match 为 true 时则生成该条SQL片段，否则不生成(当某一个值为 null 时，会是大于等于或小于等于的情形).
`Fenix`	`andEndsWith(String field, Object value)` 生成带 " AND " 前缀的 LIKE 按后缀匹配查询的 SQL 片段.
`Fenix`	`andEndsWith(String field, Object value, boolean match)` 生成带 " AND " 前缀的 LIKE 按后缀匹配查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`andEqual(String field, Object value)` 生成带 " AND " 前缀等值查询的 SQL 片段.
`Fenix`	`andEqual(String field, Object value, boolean match)` 生成带 " AND " 前缀等值查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`andGreaterThan(String field, Object value)` 生成带 " AND " 前缀大于查询的 SQL 片段.
`Fenix`	`andGreaterThan(String field, Object value, boolean match)` 生成带 " AND " 前缀大于查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`andGreaterThanEqual(String field, Object value)` 生成带 " AND " 前缀大于等于查询的 SQL 片段.
`Fenix`	`andGreaterThanEqual(String field, Object value, boolean match)` 生成带 " AND " 前缀大于等于查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`andIn(String field, Collection<?> values)` 生成带 " AND " 前缀的 IN 范围查询的 SQL 片段.
`Fenix`	`andIn(String field, Collection<?> values, boolean match)` 生成带 " AND " 前缀的 IN 范围查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`andIn(String field, Object[] values)` 生成带 " AND " 前缀的 IN 范围查询的 SQL 片段.
`Fenix`	`andIn(String field, Object[] values, boolean match)` 生成带 " AND " 前缀的 IN 范围查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`andIsNotNull(String field)` 生成带 " AND " 前缀 " IS NOT NULL " 的 SQL 片段.
`Fenix`	`andIsNotNull(String field, boolean match)` 生成带 " AND " 前缀 " IS NOT NULL " 的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`andIsNull(String field)` 生成带 " AND " 前缀 " IS NULL " 的 SQL 片段.
`Fenix`	`andIsNull(String field, boolean match)` 生成带 " AND " 前缀 " IS NULL " 的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`andLessThan(String field, Object value)` 生成带 " AND " 前缀小于查询的 SQL 片段.
`Fenix`	`andLessThan(String field, Object value, boolean match)` 生成带 " AND " 前缀小于查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`andLessThanEqual(String field, Object value)` 生成带 " AND " 前缀小于等于查询的 SQL 片段.
`Fenix`	`andLessThanEqual(String field, Object value, boolean match)` 生成带 " AND " 前缀小于等于查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`andLike(String field, Object value)` 生成带 " AND " 前缀的 LIKE 模糊查询的 SQL 片段.
`Fenix`	`andLike(String field, Object value, boolean match)` 生成带 " AND " 前缀的 LIKE 模糊查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`andLikePattern(String field, String pattern)` 根据指定的模式字符串生成带 " AND " 前缀的 LIKE 模糊查询的 SQL 片段.
`Fenix`	`andLikePattern(String field, String pattern, boolean match)` 根据指定的模式字符串生成带 " AND " 前缀的 LIKE 模糊查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`andNotEndsWith(String field, Object value)` 生成带 " AND " 前缀的 " NOT LIKE " 按后缀匹配查询的 SQL 片段.
`Fenix`	`andNotEndsWith(String field, Object value, boolean match)` 生成带 " AND " 前缀的 " NOT LIKE " 按后缀匹配查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`andNotEqual(String field, Object value)` 生成带 " AND " 前缀不等查询的 SQL 片段.
`Fenix`	`andNotEqual(String field, Object value, boolean match)` 生成带 " AND " 前缀不等查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`andNotIn(String field, Collection<?> values)` 生成带 " AND " 前缀的 " NOT IN " 范围查询的 SQL 片段.
`Fenix`	`andNotIn(String field, Collection<?> values, boolean match)` 生成带 " AND " 前缀的 " NOT IN " 范围查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`andNotIn(String field, Object[] values)` 生成带 " AND " 前缀的 " NOT IN " 范围查询的 SQL 片段.
`Fenix`	`andNotIn(String field, Object[] values, boolean match)` 生成带 " AND " 前缀的 " NOT IN " 范围查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`andNotLike(String field, Object value)` 生成带 " AND " 前缀的 " NOT LIKE " 模糊查询的 SQL 片段.
`Fenix`	`andNotLike(String field, Object value, boolean match)` 生成带 " AND " 前缀的 " NOT LIKE " 模糊查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`andNotLikePattern(String field, String pattern)` 根据指定的模式字符串生成带 " AND " 前缀的 " NOT LIKE " 模糊查询的 SQL 片段.
`Fenix`	`andNotLikePattern(String field, String pattern, boolean match)` 根据指定的模式字符串生成带 " AND " 前缀的 " NOT LIKE " 模糊查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`andNotStartsWith(String field, Object value)` 生成带 " AND " 前缀的 " NOT LIKE " 按前缀匹配查询的 SQL 片段.
`Fenix`	`andNotStartsWith(String field, Object value, boolean match)` 生成带 " AND " 前缀的 " NOT LIKE " 按前缀匹配查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`andStartsWith(String field, Object value)` 生成带 " AND " 前缀的 LIKE 按前缀匹配查询的 SQL 片段.
`Fenix`	`andStartsWith(String field, Object value, boolean match)` 生成带 " AND " 前缀的 LIKE 按前缀匹配查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`as(String text)` 拼接并带上 'AS' 关键字的字符串.
`Fenix`	`asc()` 拼接并带上 'ASC' 关键字的字符串.
`Fenix`	`between(String field, Object startValue, Object endValue)` 生成 BETWEEN 区间查询的 SQL 片段(当某一个值为 null 时，会是大于等于或小于等于的情形).
`Fenix`	`between(String field, Object startValue, Object endValue, boolean match)` 生成 BETWEEN 区间查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成(当某一个值为 null 时，会是大于等于或小于等于的情形).
`Fenix`	`deleteFrom(String text)` 拼接并带上 'DELETE FROM' 关键字的字符串.
`Fenix`	`desc()` 拼接并带上 'DESC' 关键字的字符串.
`Fenix`	`doAny(boolean match, FenixAction action)` 当匹配 match 条件为 true 时，才执行自定义的任意 `FenixAction` 操作.
`Fenix`	`doAny(FenixAction action)` 基于 `FenixAction` 的函数式接口来执行任意的自定义操作.
`SqlInfo`	`end()` 结束 JPQL 或者 SQL 的拼接流程，并生成最终的 `SqlInfo` 信息.
`Fenix`	`endsWith(String field, Object value)` 生成 LIKE 按后缀匹配查询的 SQL 片段.
`Fenix`	`endsWith(String field, Object value, boolean match)` 生成 LIKE 按后缀匹配查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`equal(String field, Object value)` 生成等值查询的 SQL 片段.
`Fenix`	`equal(String field, Object value, boolean match)` 生成等值查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`from(String text)` 拼接并带上 'FROM' 关键字的字符串.
`Fenix`	`fullJoin(String text)` 拼接并带上 'FULL JOIN' 关键字的字符串.
`static SqlInfo`	`getXmlSqlInfo(String fullFenixId, Object context)` 通过传入 fullFenixId（命名空间和 Fenix 节点的 ID）和上下文参数，来简单快速的生成和获取 `SqlInfo` 信息(有参的SQL).
`static SqlInfo`	`getXmlSqlInfo(String namespace, String fenixId, Object context)` 通过传入 Fenix XML 文件对应的命名空间、Fenix 节点的 ID 以及上下文参数对象，来生成和获取 `SqlInfo` 信息(有参的SQL).
`Fenix`	`greaterThan(String field, Object value)` 生成大于查询的 SQL 片段.
`Fenix`	`greaterThan(String field, Object value, boolean match)` 生成大于查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`greaterThanEqual(String field, Object value)` 生成大于等于查询的 SQL 片段.
`Fenix`	`greaterThanEqual(String field, Object value, boolean match)` 生成大于等于查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`groupBy(String text)` 拼接并带上 'GROUP BY' 关键字的字符串.
`Fenix`	`having(String text)` 拼接并带上 'HAVING' 关键字的字符串.
`Fenix`	`in(String field, Collection<?> values)` 生成 IN 范围查询的 SQL 片段.
`Fenix`	`in(String field, Collection<?> values, boolean match)` 生成 IN 范围查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`in(String field, Object[] values)` 生成 IN 范围查询的 SQL 片段.
`Fenix`	`in(String field, Object[] values, boolean match)` 生成 IN 范围查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`innerJoin(String text)` 拼接并带上 'INNER JOIN' 关键字的字符串.
`Fenix`	`insertInto(String text)` 拼接并带上 'INSERT INTO' 关键字的字符串.
`Fenix`	`isNotNull(String field)` 生成 " IS NOT NULL " 的 SQL 片段.
`Fenix`	`isNotNull(String field, boolean match)` 生成 " IS NOT NULL " 的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`isNull(String field)` 生成 " IS NULL " 的 SQL 片段.
`Fenix`	`isNull(String field, boolean match)` 生成 " IS NULL " 的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`leftJoin(String text)` 拼接并带上 'LEFT JOIN' 关键字的字符串.
`Fenix`	`lessThan(String field, Object value)` 生成小于查询的 SQL 片段.
`Fenix`	`lessThan(String field, Object value, boolean match)` 生成小于查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`lessThanEqual(String field, Object value)` 生成小于等于查询的 SQL 片段.
`Fenix`	`lessThanEqual(String field, Object value, boolean match)` 生成小于等于查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`like(String field, Object value)` 生成 LIKE 模糊查询的 SQL 片段.
`Fenix`	`like(String field, Object value, boolean match)` 生成 LIKE 模糊查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`likePattern(String field, String pattern)` 根据指定的模式字符串生成 LIKE 模糊查询的 SQL 片段.
`Fenix`	`likePattern(String field, String pattern, boolean match)` 根据指定的模式字符串生成 LIKE 模糊查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`limit(String text)` 拼接并带上 'LIMIT' 关键字的字符串.
`Fenix`	`notEndsWith(String field, Object value)` 生成 " NOT LIKE " 按后缀匹配查询的 SQL 片段.
`Fenix`	`notEndsWith(String field, Object value, boolean match)` 生成 " NOT LIKE " 按后缀匹配查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`notEqual(String field, Object value)` 生成不等查询的 SQL 片段.
`Fenix`	`notEqual(String field, Object value, boolean match)` 生成不等查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`notIn(String field, Collection<?> values)` 生成 " NOT IN " 范围查询的 SQL 片段.
`Fenix`	`notIn(String field, Collection<?> values, boolean match)` 生成 " NOT IN " 范围查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`notIn(String field, Object[] values)` 生成 " NOT IN " 范围查询的 SQL 片段.
`Fenix`	`notIn(String field, Object[] values, boolean match)` 生成 " NOT IN " 范围查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`notLike(String field, Object value)` 生成 " NOT LIKE " 模糊查询的 SQL 片段.
`Fenix`	`notLike(String field, Object value, boolean match)` 生成 " NOT LIKE " 模糊查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`notLikePattern(String field, String pattern)` 根据指定的模式字符串生成 " NOT LIKE " 模糊查询的 SQL 片段.
`Fenix`	`notLikePattern(String field, String pattern, boolean match)` 根据指定的模式字符串生成 " NOT LIKE " 模糊查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`notStartsWith(String field, Object value)` 生成 " NOT LIKE " 按前缀匹配查询的 SQL 片段.
`Fenix`	`notStartsWith(String field, Object value, boolean match)` 生成 " NOT LIKE " 按前缀匹配查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`offset(String text)` 拼接并带上 'OFFSET' 关键字的字符串.
`Fenix`	`on(String text)` 拼接并带上 'ON' 关键字的字符串.
`Fenix`	`or()` 拼接并带上 'OR' 关键字的字符串.
`Fenix`	`or(String text)` 拼接并带上 'OR' 关键字和其他文本的字符串.
`Fenix`	`orBetween(String field, Object startValue, Object endValue)` 生成带 " OR " 前缀的 BETWEEN 区间查询的 SQL 片段(当某一个值为 null 时，会是大于等于或小于等于的情形).
`Fenix`	`orBetween(String field, Object startValue, Object endValue, boolean match)` 生成带 " OR " 前缀的 BETWEEN 区间查询的 SQL 片段,如果 match 为 true 时则生成该条SQL片段，否则不生成(当某一个值为 null 时，会是大于等于或小于等于的情形).
`Fenix`	`orderBy(String text)` 拼接并带上 'ORDER BY' 关键字的字符串.
`Fenix`	`orEndsWith(String field, Object value)` 生成带 " OR " 前缀的 LIKE 按后缀匹配查询的 SQL 片段.
`Fenix`	`orEndsWith(String field, Object value, boolean match)` 生成带 " OR " 前缀的 LIKE 按后缀匹配查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`orEqual(String field, Object value)` 生成带 " OR " 前缀等值查询的 SQL 片段.
`Fenix`	`orEqual(String field, Object value, boolean match)` 生成带 " OR " 前缀等值查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`orGreaterThan(String field, Object value)` 生成带 " OR " 前缀大于查询的 SQL 片段.
`Fenix`	`orGreaterThan(String field, Object value, boolean match)` 生成带 " OR " 前缀大于查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`orGreaterThanEqual(String field, Object value)` 生成带 " OR " 前缀大于等于查询的 SQL 片段.
`Fenix`	`orGreaterThanEqual(String field, Object value, boolean match)` 生成带 " OR " 前缀大于等于查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`orIn(String field, Collection<?> values)` 生成带 " OR " 前缀的 IN 范围查询的 SQL 片段.
`Fenix`	`orIn(String field, Collection<?> values, boolean match)` 生成带 " OR " 前缀的 IN 范围查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`orIn(String field, Object[] values)` 生成带 " OR " 前缀的 IN 范围查询的 SQL 片段.
`Fenix`	`orIn(String field, Object[] values, boolean match)` 生成带 " OR " 前缀的 IN 范围查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`orIsNotNull(String field)` 生成带 " OR " 前缀 " IS NOT NULL " 的 SQL 片段.
`Fenix`	`orIsNotNull(String field, boolean match)` 生成带 " OR " 前缀 " IS NOT NULL " 的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`orIsNull(String field)` 生成带 " OR " 前缀 " IS NULL " 的 SQL 片段.
`Fenix`	`orIsNull(String field, boolean match)` 生成带 " OR " 前缀" IS NULL "的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`orLessThan(String field, Object value)` 生成带 " OR " 前缀小于查询的 SQL 片段.
`Fenix`	`orLessThan(String field, Object value, boolean match)` 生成带 " OR " 前缀小于查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`orLessThanEqual(String field, Object value)` 生成带 " OR " 前缀小于等于查询的 SQL 片段.
`Fenix`	`orLessThanEqual(String field, Object value, boolean match)` 生成带 " OR " 前缀小于等于查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`orLike(String field, Object value)` 生成带 " OR " 前缀的 LIKE 模糊查询的 SQL 片段.
`Fenix`	`orLike(String field, Object value, boolean match)` 生成带 " OR " 前缀的 LIKE 模糊查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`orLikePattern(String field, String pattern)` 根据指定的模式字符串生成带 " OR " 前缀的 LIKE 模糊查询的 SQL 片段.
`Fenix`	`orLikePattern(String field, String pattern, boolean match)` 根据指定的模式字符串生成带 " OR " 前缀的 LIKE 模糊查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`orNotEndsWith(String field, Object value)` 生成带 " OR " 前缀的 " NOT LIKE " 按后缀匹配查询的 SQL 片段.
`Fenix`	`orNotEndsWith(String field, Object value, boolean match)` 生成带 " OR " 前缀的 " NOT LIKE " 按后缀匹配查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`orNotEqual(String field, Object value)` 生成带 " OR " 前缀不等查询的 SQL 片段.
`Fenix`	`orNotEqual(String field, Object value, boolean match)` 生成带 " OR " 前缀不等查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`orNotIn(String field, Collection<?> values)` 生成带 " OR " 前缀的 " NOT IN " 范围查询的 SQL 片段.
`Fenix`	`orNotIn(String field, Collection<?> values, boolean match)` 生成带 " OR " 前缀的 " NOT IN " 范围查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`orNotIn(String field, Object[] values)` 生成带 " OR " 前缀的 " NOT IN " 范围查询的 SQL 片段.
`Fenix`	`orNotIn(String field, Object[] values, boolean match)` 生成带 " OR " 前缀的 " NOT IN " 范围查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`orNotLike(String field, Object value)` 生成带 " OR " 前缀的" NOT LIKE "模糊查询的 SQL 片段.
`Fenix`	`orNotLike(String field, Object value, boolean match)` 生成带 " OR " 前缀的" NOT LIKE "模糊查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`orNotLikePattern(String field, String pattern)` 根据指定的模式字符串生成带 " OR " 前缀的 " NOT LIKE " 模糊查询的 SQL 片段.
`Fenix`	`orNotLikePattern(String field, String pattern, boolean match)` 根据指定的模式字符串生成带 " OR " 前缀的 " NOT LIKE " 模糊查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`orNotStartsWith(String field, Object value)` 生成带 " OR " 前缀的 " NOT LIKE " 按前缀匹配查询的 SQL 片段.
`Fenix`	`orNotStartsWith(String field, Object value, boolean match)` 生成带 " OR " 前缀的 " NOT LIKE " 按前缀匹配查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`orStartsWith(String field, Object value)` 生成带 " OR " 前缀的 LIKE 按前缀匹配查询的 SQL 片段.
`Fenix`	`orStartsWith(String field, Object value, boolean match)` 生成带 " OR " 前缀的 LIKE 按前缀匹配查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`param(String key, Object value)` 在 SQL 的参数集合中添加命名参数，其中 key 是 JPQL 中的命名参数名称，value 是该参数对应的值.
`Fenix`	`params(Map<String,Object> paramMap)` 在 SQL 的参数集合后添加 Map 集合中的命名参数，Map 中的 key 是 JPQL 中的命名参数名称，value 是该参数对应的值.
`Fenix`	`rightJoin(String text)` 拼接并带上 'RIGHT JOIN' 关键字的字符串.
`Fenix`	`select(String text)` 拼接并带上 'SELECT' 关键字的字符串.
`Fenix`	`set(String text)` 拼接并带上 'AS' 关键字的字符串.
`static Fenix`	`start()` 开始的方法，初始化 `Fenix` 实例.
`Fenix`	`startsWith(String field, Object value)` 生成 LIKE 按前缀匹配查询的 SQL 片段.
`Fenix`	`startsWith(String field, Object value, boolean match)` 生成 LIKE 按前缀匹配查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
`Fenix`	`text(boolean match, String text, Map<String,Object> paramMap)` 在 SQL 后追加任何文本字符串，后可追加 Map 型参数，如果 match 为 true 时，才生成此 SQL 文本和参数.
`Fenix`	`text(boolean match, String text, String key, Object value)` 在 SQL 后追加任何文本字符串，并设置该 SQL 字符串的命名参数，如果 match 为 true 时，才生成此 SQL 文本和参数.
`Fenix`	`text(String text)` 在 SQL 后追加任何文本字符串.
`Fenix`	`text(String text, Map<String,Object> paramMap)` 在 SQL 后追加任何文本字符串，后可追加 Map 型参数，Map 中的 key 为命名参数名称，value 为参数值.
`Fenix`	`text(String text, String key, Object value)` 在 SQL 后追加任何文本字符串，并设置该 SQL 字符串的命名参数，其中 key 为命名参数名称，value 为参数值.
`Fenix`	`union()` 拼接并带上 'UNION' 关键字的字符串.
`Fenix`	`unionAll()` 拼接并带上 'UNION ALL' 关键字的字符串.
`Fenix`	`update(String text)` 拼接并带上 'UPDATE' 关键字的字符串.
`Fenix`	`values(String text)` 拼接并带上 'VALUES' 关键字的字符串.
`Fenix`	`where()` 拼接并带上 'WHERE' 关键字的 SQL 字符串.
`Fenix`	`where(String text)` 拼接并带上 'WHERE' 关键字及之后的字符串.
`Fenix`	`where(String text, Map<String,Object> paramMap)` 拼接并带上 'WHERE' 关键字的字符串和动态参数.
`Fenix`	`where(String text, String key, Object value)` 拼接并带上 'WHERE' 关键字的字符串和动态参数.

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 方法详细资料
  - start
```
public static Fenix start()
```
    开始的方法，初始化 Fenix 实例.
    
    返回:
    
    Fenix 实例
  - end
```
public SqlInfo end()
```
    结束 JPQL 或者 SQL 的拼接流程，并生成最终的 SqlInfo 信息.
    
    返回:
    
    sqlInfo
  - getXmlSqlInfo
```
public static SqlInfo getXmlSqlInfo(String fullFenixId,
                                    Object context)
```
    通过传入 fullFenixId（命名空间和 Fenix 节点的 ID）和上下文参数，来简单快速的生成和获取 SqlInfo 信息(有参的SQL).
    
    参数:
    
    fullFenixId - XML 命名空间 'namespace' + '.' + 'fenixId' 的值，如: "student.queryStudentById".
    
    context - 上下文参数（一般是 Bean 或者 map）
    
    返回:
    
    返回 SqlInfo 对象
  - getXmlSqlInfo
```
public static SqlInfo getXmlSqlInfo(String namespace,
                                    String fenixId,
                                    Object context)
```
    通过传入 Fenix XML 文件对应的命名空间、Fenix 节点的 ID 以及上下文参数对象，来生成和获取 SqlInfo 信息(有参的SQL).
    
    参数:
    
    namespace - XML 命名空间
    
    fenixId - XML 中的 fenixId
    
    context - 上下文参数（一般是 Bean 或者 map）
    
    返回:
    
    返回 SqlInfo 对象
  - insertInto
```
public Fenix insertInto(String text)
```
    拼接并带上 'INSERT INTO' 关键字的字符串.
    
    参数:
    
    text - 文本
    
    返回:
    
    Fenix 实例
  - values
```
public Fenix values(String text)
```
    拼接并带上 'VALUES' 关键字的字符串.
    
    参数:
    
    text - 文本
    
    返回:
    
    Fenix 实例
  - deleteFrom
```
public Fenix deleteFrom(String text)
```
    拼接并带上 'DELETE FROM' 关键字的字符串.
    
    参数:
    
    text - 文本
    
    返回:
    
    Fenix 实例
  - update
```
public Fenix update(String text)
```
    拼接并带上 'UPDATE' 关键字的字符串.
    
    参数:
    
    text - 文本
    
    返回:
    
    Fenix 实例
  - select
```
public Fenix select(String text)
```
    拼接并带上 'SELECT' 关键字的字符串.
    
    参数:
    
    text - 文本
    
    返回:
    
    Fenix 实例
  - from
```
public Fenix from(String text)
```
    拼接并带上 'FROM' 关键字的字符串.
    
    参数:
    
    text - 文本
    
    返回:
    
    Fenix 实例
  - where
```
public Fenix where()
```
    拼接并带上 'WHERE' 关键字的 SQL 字符串.
    
    返回:
    
    Fenix 实例
  - where
```
public Fenix where(String text)
```
    拼接并带上 'WHERE' 关键字及之后的字符串.
    
    参数:
    
    text - 文本
    
    返回:
    
    Fenix 实例
  - where
```
public Fenix where(String text,
                   Map<String,Object> paramMap)
```
    拼接并带上 'WHERE' 关键字的字符串和动态参数.
    
    参数:
    
    text - 文本
    
    paramMap - Map 型参数
    
    返回:
    
    Fenix 实例
  - where
```
public Fenix where(String text,
                   String key,
                   Object value)
```
    拼接并带上 'WHERE' 关键字的字符串和动态参数.
    
    参数:
    
    text - 文本
    
    key - 命名参数的 key
    
    value - 命名参数的 value
    
    返回:
    
    Fenix 实例
  - and
```
public Fenix and()
```
    拼接并带上 'AND' 关键字的字符串.
    
    返回:
    
    Fenix 实例
  - and
```
public Fenix and(String text)
```
    拼接并带上 'AND' 关键字和其他文本的字符串.
    
    参数:
    
    text - 文本
    
    返回:
    
    Fenix 实例
  - or
```
public Fenix or()
```
    拼接并带上 'OR' 关键字的字符串.
    
    返回:
    
    Fenix 实例
  - or
```
public Fenix or(String text)
```
    拼接并带上 'OR' 关键字和其他文本的字符串.
    
    参数:
    
    text - 文本
    
    返回:
    
    Fenix 实例
  - as
```
public Fenix as(String text)
```
    拼接并带上 'AS' 关键字的字符串.
    
    参数:
    
    text - 文本
    
    返回:
    
    Fenix 实例
  - set
```
public Fenix set(String text)
```
    拼接并带上 'AS' 关键字的字符串.
    
    参数:
    
    text - 文本
    
    返回:
    
    Fenix 实例
  - innerJoin
```
public Fenix innerJoin(String text)
```
    拼接并带上 'INNER JOIN' 关键字的字符串.
    
    参数:
    
    text - 文本
    
    返回:
    
    Fenix 实例
  - leftJoin
```
public Fenix leftJoin(String text)
```
    拼接并带上 'LEFT JOIN' 关键字的字符串.
    
    参数:
    
    text - 文本
    
    返回:
    
    Fenix 实例
  - rightJoin
```
public Fenix rightJoin(String text)
```
    拼接并带上 'RIGHT JOIN' 关键字的字符串.
    
    参数:
    
    text - 文本
    
    返回:
    
    Fenix 实例
  - fullJoin
```
public Fenix fullJoin(String text)
```
    拼接并带上 'FULL JOIN' 关键字的字符串.
    
    参数:
    
    text - 文本
    
    返回:
    
    Fenix 实例
  - on
```
public Fenix on(String text)
```
    拼接并带上 'ON' 关键字的字符串.
    
    参数:
    
    text - 文本
    
    返回:
    
    Fenix 实例
  - orderBy
```
public Fenix orderBy(String text)
```
    拼接并带上 'ORDER BY' 关键字的字符串.
    
    参数:
    
    text - 文本
    
    返回:
    
    Fenix 实例
  - groupBy
```
public Fenix groupBy(String text)
```
    拼接并带上 'GROUP BY' 关键字的字符串.
    
    参数:
    
    text - 文本
    
    返回:
    
    Fenix 实例
  - having
```
public Fenix having(String text)
```
    拼接并带上 'HAVING' 关键字的字符串.
    
    参数:
    
    text - 文本
    
    返回:
    
    Fenix 实例
  - limit
```
public Fenix limit(String text)
```
    拼接并带上 'LIMIT' 关键字的字符串.
    
    参数:
    
    text - 文本
    
    返回:
    
    Fenix 实例
  - offset
```
public Fenix offset(String text)
```
    拼接并带上 'OFFSET' 关键字的字符串.
    
    参数:
    
    text - 文本
    
    返回:
    
    Fenix 实例
  - asc
```
public Fenix asc()
```
    拼接并带上 'ASC' 关键字的字符串.
    
    返回:
    
    Fenix 实例
  - desc
```
public Fenix desc()
```
    拼接并带上 'DESC' 关键字的字符串.
    
    返回:
    
    Fenix 实例
  - union
```
public Fenix union()
```
    拼接并带上 'UNION' 关键字的字符串.
    
    返回:
    
    Fenix 实例
  - unionAll
```
public Fenix unionAll()
```
    拼接并带上 'UNION ALL' 关键字的字符串.
    
    返回:
    
    Fenix 实例
  - text
```
public Fenix text(String text)
```
    在 SQL 后追加任何文本字符串.
    
    参数:
    
    text - 文本
    
    返回:
    
    Fenix 实例
  - text
```
public Fenix text(String text,
                  String key,
                  Object value)
```
    在 SQL 后追加任何文本字符串，并设置该 SQL 字符串的命名参数，其中 key 为命名参数名称，value 为参数值.
    
    参数:
    
    text - 文本
    
    key - 命名参数 key
    
    value - 命名参数 value
    
    返回:
    
    Fenix 实例
  - text
```
public Fenix text(String text,
                  Map<String,Object> paramMap)
```
    在 SQL 后追加任何文本字符串，后可追加 Map 型参数，Map 中的 key 为命名参数名称，value 为参数值.
    
    参数:
    
    text - 文本
    
    paramMap - Map 型参数
    
    返回:
    
    Fenix 实例
  - text
```
public Fenix text(boolean match,
                  String text,
                  String key,
                  Object value)
```
    在 SQL 后追加任何文本字符串，并设置该 SQL 字符串的命名参数，如果 match 为 true 时，才生成此 SQL 文本和参数.
    
    参数:
    
    match - 匹配条件
    
    text - 文本
    
    key - 命名参数的 key
    
    value - 命名参数的 value
    
    返回:
    
    Fenix 实例
  - text
```
public Fenix text(boolean match,
                  String text,
                  Map<String,Object> paramMap)
```
    在 SQL 后追加任何文本字符串，后可追加 Map 型参数，如果 match 为 true 时，才生成此 SQL 文本和参数.
    
    参数:
    
    match - 匹配条件
    
    text - 文本
    
    paramMap - Map 型参数
    
    返回:
    
    Fenix 实例
  - param
```
public Fenix param(String key,
                   Object value)
```
    在 SQL 的参数集合中添加命名参数，其中 key 是 JPQL 中的命名参数名称，value 是该参数对应的值.
    
    参数:
    
    key - 命名参数名称
    
    value - 命名参数的值
    
    返回:
    
    Fenix 实例
  - params
```
public Fenix params(Map<String,Object> paramMap)
```
    在 SQL 的参数集合后添加 Map 集合中的命名参数，Map 中的 key 是 JPQL 中的命名参数名称，value 是该参数对应的值.
    
    参数:
    
    paramMap - 存放在 Map 中的参数键值对
    
    返回:
    
    Fenix 实例
  - doAny
```
public Fenix doAny(FenixAction action)
```
    基于 FenixAction 的函数式接口来执行任意的自定义操作.
    
    参数:
    
    action - FenixAction 的接口实现类实例
    
    返回:
    
    Fenix 实例
  - doAny
```
public Fenix doAny(boolean match,
                   FenixAction action)
```
    当匹配 match 条件为 true 时，才执行自定义的任意 FenixAction 操作.
    
    参数:
    
    match - 匹配条件
    
    action - FenixAction 的接口实现类实例
    
    返回:
    
    Fenix 实例
  - equal
```
public Fenix equal(String field,
                   Object value)
```
    生成等值查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - equal
```
public Fenix equal(String field,
                   Object value,
                   boolean match)
```
    生成等值查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - andEqual
```
public Fenix andEqual(String field,
                      Object value)
```
    生成带 " AND " 前缀等值查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - andEqual
```
public Fenix andEqual(String field,
                      Object value,
                      boolean match)
```
    生成带 " AND " 前缀等值查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - orEqual
```
public Fenix orEqual(String field,
                     Object value)
```
    生成带 " OR " 前缀等值查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - orEqual
```
public Fenix orEqual(String field,
                     Object value,
                     boolean match)
```
    生成带 " OR " 前缀等值查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - notEqual
```
public Fenix notEqual(String field,
                      Object value)
```
    生成不等查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - notEqual
```
public Fenix notEqual(String field,
                      Object value,
                      boolean match)
```
    生成不等查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - andNotEqual
```
public Fenix andNotEqual(String field,
                         Object value)
```
    生成带 " AND " 前缀不等查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - andNotEqual
```
public Fenix andNotEqual(String field,
                         Object value,
                         boolean match)
```
    生成带 " AND " 前缀不等查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - orNotEqual
```
public Fenix orNotEqual(String field,
                        Object value)
```
    生成带 " OR " 前缀不等查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - orNotEqual
```
public Fenix orNotEqual(String field,
                        Object value,
                        boolean match)
```
    生成带 " OR " 前缀不等查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - greaterThan
```
public Fenix greaterThan(String field,
                         Object value)
```
    生成大于查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - greaterThan
```
public Fenix greaterThan(String field,
                         Object value,
                         boolean match)
```
    生成大于查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - andGreaterThan
```
public Fenix andGreaterThan(String field,
                            Object value)
```
    生成带 " AND " 前缀大于查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - andGreaterThan
```
public Fenix andGreaterThan(String field,
                            Object value,
                            boolean match)
```
    生成带 " AND " 前缀大于查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - orGreaterThan
```
public Fenix orGreaterThan(String field,
                           Object value)
```
    生成带 " OR " 前缀大于查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - orGreaterThan
```
public Fenix orGreaterThan(String field,
                           Object value,
                           boolean match)
```
    生成带 " OR " 前缀大于查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - lessThan
```
public Fenix lessThan(String field,
                      Object value)
```
    生成小于查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - lessThan
```
public Fenix lessThan(String field,
                      Object value,
                      boolean match)
```
    生成小于查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - andLessThan
```
public Fenix andLessThan(String field,
                         Object value)
```
    生成带 " AND " 前缀小于查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - andLessThan
```
public Fenix andLessThan(String field,
                         Object value,
                         boolean match)
```
    生成带 " AND " 前缀小于查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - orLessThan
```
public Fenix orLessThan(String field,
                        Object value)
```
    生成带 " OR " 前缀小于查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - orLessThan
```
public Fenix orLessThan(String field,
                        Object value,
                        boolean match)
```
    生成带 " OR " 前缀小于查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - greaterThanEqual
```
public Fenix greaterThanEqual(String field,
                              Object value)
```
    生成大于等于查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - greaterThanEqual
```
public Fenix greaterThanEqual(String field,
                              Object value,
                              boolean match)
```
    生成大于等于查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - andGreaterThanEqual
```
public Fenix andGreaterThanEqual(String field,
                                 Object value)
```
    生成带 " AND " 前缀大于等于查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - andGreaterThanEqual
```
public Fenix andGreaterThanEqual(String field,
                                 Object value,
                                 boolean match)
```
    生成带 " AND " 前缀大于等于查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - orGreaterThanEqual
```
public Fenix orGreaterThanEqual(String field,
                                Object value)
```
    生成带 " OR " 前缀大于等于查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - orGreaterThanEqual
```
public Fenix orGreaterThanEqual(String field,
                                Object value,
                                boolean match)
```
    生成带 " OR " 前缀大于等于查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - lessThanEqual
```
public Fenix lessThanEqual(String field,
                           Object value)
```
    生成小于等于查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - lessThanEqual
```
public Fenix lessThanEqual(String field,
                           Object value,
                           boolean match)
```
    生成小于等于查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - andLessThanEqual
```
public Fenix andLessThanEqual(String field,
                              Object value)
```
    生成带 " AND " 前缀小于等于查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - andLessThanEqual
```
public Fenix andLessThanEqual(String field,
                              Object value,
                              boolean match)
```
    生成带 " AND " 前缀小于等于查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - orLessThanEqual
```
public Fenix orLessThanEqual(String field,
                             Object value)
```
    生成带 " OR " 前缀小于等于查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - orLessThanEqual
```
public Fenix orLessThanEqual(String field,
                             Object value,
                             boolean match)
```
    生成带 " OR " 前缀小于等于查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - like
```
public Fenix like(String field,
                  Object value)
```
    生成 LIKE 模糊查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - like
```
public Fenix like(String field,
                  Object value,
                  boolean match)
```
    生成 LIKE 模糊查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - andLike
```
public Fenix andLike(String field,
                     Object value)
```
    生成带 " AND " 前缀的 LIKE 模糊查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - andLike
```
public Fenix andLike(String field,
                     Object value,
                     boolean match)
```
    生成带 " AND " 前缀的 LIKE 模糊查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - orLike
```
public Fenix orLike(String field,
                    Object value)
```
    生成带 " OR " 前缀的 LIKE 模糊查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - orLike
```
public Fenix orLike(String field,
                    Object value,
                    boolean match)
```
    生成带 " OR " 前缀的 LIKE 模糊查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - notLike
```
public Fenix notLike(String field,
                     Object value)
```
    生成 " NOT LIKE " 模糊查询的 SQL 片段.
    示例：传入 {"b.title", "Spring"} 两个参数，生成的SQL片段为：" b.title NOT LIKE :b_title ", SQL参数为:{b_title: "%Spring%"}.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - notLike
```
public Fenix notLike(String field,
                     Object value,
                     boolean match)
```
    生成 " NOT LIKE " 模糊查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    示例：传入 {"b.title", "Spring", true} 三个参数，生成的SQL片段为：" b.title NOT LIKE :b_title ", SQL参数为:{b_title: "%Spring%"}.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - andNotLike
```
public Fenix andNotLike(String field,
                        Object value)
```
    生成带 " AND " 前缀的 " NOT LIKE " 模糊查询的 SQL 片段.
    示例：传入 {"b.title", "Spring"} 两个参数，生成的SQL片段为：" AND b.title NOT LIKE :b_title ", SQL参数为:{b_title: "%Spring%"}.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - andNotLike
```
public Fenix andNotLike(String field,
                        Object value,
                        boolean match)
```
    生成带 " AND " 前缀的 " NOT LIKE " 模糊查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    示例：传入 {"b.title", "Spring", true} 三个参数，生成的SQL片段为：" AND b.title NOT LIKE :b_title ", SQL参数为:{b_title: "%Spring%"}.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - orNotLike
```
public Fenix orNotLike(String field,
                       Object value)
```
    生成带 " OR " 前缀的" NOT LIKE "模糊查询的 SQL 片段.
    示例：传入 {"b.title", "Spring"} 两个参数，生成的SQL片段为：" OR b.title NOT LIKE :b_title ", SQL参数为:{b_title: "%Spring%"}.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - orNotLike
```
public Fenix orNotLike(String field,
                       Object value,
                       boolean match)
```
    生成带 " OR " 前缀的" NOT LIKE "模糊查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    示例：传入 {"b.title", "Spring", true} 三个参数，生成的SQL片段为：" OR b.title NOT LIKE :b_title ", SQL参数为:{b_title: "%Spring%"}.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - startsWith
```
public Fenix startsWith(String field,
                        Object value)
```
    生成 LIKE 按前缀匹配查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - startsWith
```
public Fenix startsWith(String field,
                        Object value,
                        boolean match)
```
    生成 LIKE 按前缀匹配查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - andStartsWith
```
public Fenix andStartsWith(String field,
                           Object value)
```
    生成带 " AND " 前缀的 LIKE 按前缀匹配查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - andStartsWith
```
public Fenix andStartsWith(String field,
                           Object value,
                           boolean match)
```
    生成带 " AND " 前缀的 LIKE 按前缀匹配查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - orStartsWith
```
public Fenix orStartsWith(String field,
                          Object value)
```
    生成带 " OR " 前缀的 LIKE 按前缀匹配查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - orStartsWith
```
public Fenix orStartsWith(String field,
                          Object value,
                          boolean match)
```
    生成带 " OR " 前缀的 LIKE 按前缀匹配查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - notStartsWith
```
public Fenix notStartsWith(String field,
                           Object value)
```
    生成 " NOT LIKE " 按前缀匹配查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - notStartsWith
```
public Fenix notStartsWith(String field,
                           Object value,
                           boolean match)
```
    生成 " NOT LIKE " 按前缀匹配查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - andNotStartsWith
```
public Fenix andNotStartsWith(String field,
                              Object value)
```
    生成带 " AND " 前缀的 " NOT LIKE " 按前缀匹配查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - andNotStartsWith
```
public Fenix andNotStartsWith(String field,
                              Object value,
                              boolean match)
```
    生成带 " AND " 前缀的 " NOT LIKE " 按前缀匹配查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - orNotStartsWith
```
public Fenix orNotStartsWith(String field,
                             Object value)
```
    生成带 " OR " 前缀的 " NOT LIKE " 按前缀匹配查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - orNotStartsWith
```
public Fenix orNotStartsWith(String field,
                             Object value,
                             boolean match)
```
    生成带 " OR " 前缀的 " NOT LIKE " 按前缀匹配查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - endsWith
```
public Fenix endsWith(String field,
                      Object value)
```
    生成 LIKE 按后缀匹配查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - endsWith
```
public Fenix endsWith(String field,
                      Object value,
                      boolean match)
```
    生成 LIKE 按后缀匹配查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - andEndsWith
```
public Fenix andEndsWith(String field,
                         Object value)
```
    生成带 " AND " 前缀的 LIKE 按后缀匹配查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - andEndsWith
```
public Fenix andEndsWith(String field,
                         Object value,
                         boolean match)
```
    生成带 " AND " 前缀的 LIKE 按后缀匹配查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - orEndsWith
```
public Fenix orEndsWith(String field,
                        Object value)
```
    生成带 " OR " 前缀的 LIKE 按后缀匹配查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - orEndsWith
```
public Fenix orEndsWith(String field,
                        Object value,
                        boolean match)
```
    生成带 " OR " 前缀的 LIKE 按后缀匹配查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - notEndsWith
```
public Fenix notEndsWith(String field,
                         Object value)
```
    生成 " NOT LIKE " 按后缀匹配查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - notEndsWith
```
public Fenix notEndsWith(String field,
                         Object value,
                         boolean match)
```
    生成 " NOT LIKE " 按后缀匹配查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - andNotEndsWith
```
public Fenix andNotEndsWith(String field,
                            Object value)
```
    生成带 " AND " 前缀的 " NOT LIKE " 按后缀匹配查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - andNotEndsWith
```
public Fenix andNotEndsWith(String field,
                            Object value,
                            boolean match)
```
    生成带 " AND " 前缀的 " NOT LIKE " 按后缀匹配查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - orNotEndsWith
```
public Fenix orNotEndsWith(String field,
                           Object value)
```
    生成带 " OR " 前缀的 " NOT LIKE " 按后缀匹配查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    返回:
    
    Fenix 实例
  - orNotEndsWith
```
public Fenix orNotEndsWith(String field,
                           Object value,
                           boolean match)
```
    生成带 " OR " 前缀的 " NOT LIKE " 按后缀匹配查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    value - 值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - likePattern
```
public Fenix likePattern(String field,
                         String pattern)
```
    根据指定的模式字符串生成 LIKE 模糊查询的 SQL 片段.
    示例：传入 {"b.title", "Java%"} 两个参数，生成的SQL片段为：" b.title LIKE 'Java%' "
    
    参数:
    
    field - 数据库字段
    
    pattern - 模式字符串
    
    返回:
    
    Fenix 实例
  - likePattern
```
public Fenix likePattern(String field,
                         String pattern,
                         boolean match)
```
    根据指定的模式字符串生成 LIKE 模糊查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    示例：传入 {"b.title", "Java%", true} 三个参数，生成的SQL片段为：" b.title LIKE 'Java%' "
    
    示例：传入 {"b.title", "Java%", false} 三个参数，生成的SQL片段为空字符串.
    
    参数:
    
    field - 数据库字段
    
    pattern - 模式字符串
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - andLikePattern
```
public Fenix andLikePattern(String field,
                            String pattern)
```
    根据指定的模式字符串生成带 " AND " 前缀的 LIKE 模糊查询的 SQL 片段.
    示例：传入 {"b.title", "Java%"} 两个参数，生成的SQL片段为：" AND b.title LIKE 'Java%' "
    
    参数:
    
    field - 数据库字段
    
    pattern - 模式字符串
    
    返回:
    
    Fenix 实例
  - andLikePattern
```
public Fenix andLikePattern(String field,
                            String pattern,
                            boolean match)
```
    根据指定的模式字符串生成带 " AND " 前缀的 LIKE 模糊查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    示例：传入 {"b.title", "Java%", true} 三个参数，生成的SQL片段为：" AND b.title LIKE 'Java%' "
    
    示例：传入 {"b.title", "Java%", false} 三个参数，生成的SQL片段为空字符串.
    
    参数:
    
    field - 数据库字段
    
    pattern - 模式字符串
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - orLikePattern
```
public Fenix orLikePattern(String field,
                           String pattern)
```
    根据指定的模式字符串生成带 " OR " 前缀的 LIKE 模糊查询的 SQL 片段.
    示例：传入 {"b.title", "Java%"} 两个参数，生成的SQL片段为：" OR b.title LIKE 'Java%' "
    
    参数:
    
    field - 数据库字段
    
    pattern - 模式字符串
    
    返回:
    
    Fenix 实例
  - orLikePattern
```
public Fenix orLikePattern(String field,
                           String pattern,
                           boolean match)
```
    根据指定的模式字符串生成带 " OR " 前缀的 LIKE 模糊查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    示例：传入 {"b.title", "Java%", true} 三个参数，生成的SQL片段为：" OR b.title LIKE 'Java%' "
    
    示例：传入 {"b.title", "Java%", false} 三个参数，生成的SQL片段为空字符串.
    
    参数:
    
    field - 数据库字段
    
    pattern - 模式字符串
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - notLikePattern
```
public Fenix notLikePattern(String field,
                            String pattern)
```
    根据指定的模式字符串生成 " NOT LIKE " 模糊查询的 SQL 片段.
    示例：传入 {"b.title", "Java%"} 两个参数，生成的SQL片段为：" b.title NOT LIKE 'Java%' "
    
    参数:
    
    field - 数据库字段
    
    pattern - 模式字符串
    
    返回:
    
    Fenix 实例
  - notLikePattern
```
public Fenix notLikePattern(String field,
                            String pattern,
                            boolean match)
```
    根据指定的模式字符串生成 " NOT LIKE " 模糊查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    示例：传入 {"b.title", "Java%", true} 三个参数，生成的SQL片段为：" b.title NOT LIKE 'Java%' "
    
    示例：传入 {"b.title", "Java%", false} 三个参数，生成的SQL片段为空字符串.
    
    参数:
    
    field - 数据库字段
    
    pattern - 模式字符串
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - andNotLikePattern
```
public Fenix andNotLikePattern(String field,
                               String pattern)
```
    根据指定的模式字符串生成带 " AND " 前缀的 " NOT LIKE " 模糊查询的 SQL 片段.
    示例：传入 {"b.title", "Java%"} 两个参数，生成的SQL片段为：" AND b.title NOT LIKE 'Java%' "
    
    参数:
    
    field - 数据库字段
    
    pattern - 模式字符串
    
    返回:
    
    Fenix 实例
  - andNotLikePattern
```
public Fenix andNotLikePattern(String field,
                               String pattern,
                               boolean match)
```
    根据指定的模式字符串生成带 " AND " 前缀的 " NOT LIKE " 模糊查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    示例：传入 {"b.title", "Java%", true} 三个参数，生成的SQL片段为：" AND b.title NOT LIKE 'Java%' "
    
    示例：传入 {"b.title", "Java%", false} 三个参数，生成的SQL片段为空字符串.
    
    参数:
    
    field - 数据库字段
    
    pattern - 模式字符串
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - orNotLikePattern
```
public Fenix orNotLikePattern(String field,
                              String pattern)
```
    根据指定的模式字符串生成带 " OR " 前缀的 " NOT LIKE " 模糊查询的 SQL 片段.
    示例：传入 {"b.title", "Java%"} 两个参数，生成的SQL片段为：" OR b.title NOT LIKE 'Java%' "
    
    参数:
    
    field - 数据库字段
    
    pattern - 模式字符串
    
    返回:
    
    Fenix 实例
  - orNotLikePattern
```
public Fenix orNotLikePattern(String field,
                              String pattern,
                              boolean match)
```
    根据指定的模式字符串生成带 " OR " 前缀的 " NOT LIKE " 模糊查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    示例：传入 {"b.title", "Java%", true} 三个参数，生成的SQL片段为：" OR b.title NOT LIKE 'Java%' "
    
    示例：传入 {"b.title", "Java%", false} 三个参数，生成的SQL片段为空字符串.
    
    参数:
    
    field - 数据库字段
    
    pattern - 模式字符串
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - between
```
public Fenix between(String field,
                     Object startValue,
                     Object endValue)
```
    生成 BETWEEN 区间查询的 SQL 片段(当某一个值为 null 时，会是大于等于或小于等于的情形).
    
    参数:
    
    field - 数据库字段
    
    startValue - 开始值
    
    endValue - 结束值
    
    返回:
    
    Fenix 实例
  - between
```
public Fenix between(String field,
                     Object startValue,
                     Object endValue,
                     boolean match)
```
    生成 BETWEEN 区间查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成(当某一个值为 null 时，会是大于等于或小于等于的情形).
    
    参数:
    
    field - 数据库字段
    
    startValue - 开始值
    
    endValue - 结束值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - andBetween
```
public Fenix andBetween(String field,
                        Object startValue,
                        Object endValue)
```
    生成带 " AND " 前缀的 BETWEEN 区间查询的 SQL 片段(当某一个值为 null 时，会是大于等于或小于等于的情形).
    
    参数:
    
    field - 数据库字段
    
    startValue - 开始值
    
    endValue - 结束值
    
    返回:
    
    Fenix 实例
  - andBetween
```
public Fenix andBetween(String field,
                        Object startValue,
                        Object endValue,
                        boolean match)
```
    生成带 " AND " 前缀的 BETWEEN 区间查询的 SQL 片段,如果 match 为 true 时则生成该条SQL片段，否则不生成(当某一个值为 null 时，会是大于等于或小于等于的情形).
    
    参数:
    
    field - 数据库字段
    
    startValue - 开始值
    
    endValue - 结束值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - orBetween
```
public Fenix orBetween(String field,
                       Object startValue,
                       Object endValue)
```
    生成带 " OR " 前缀的 BETWEEN 区间查询的 SQL 片段(当某一个值为 null 时，会是大于等于或小于等于的情形).
    
    参数:
    
    field - 数据库字段
    
    startValue - 开始值
    
    endValue - 结束值
    
    返回:
    
    Fenix 实例
  - orBetween
```
public Fenix orBetween(String field,
                       Object startValue,
                       Object endValue,
                       boolean match)
```
    生成带 " OR " 前缀的 BETWEEN 区间查询的 SQL 片段,如果 match 为 true 时则生成该条SQL片段，否则不生成(当某一个值为 null 时，会是大于等于或小于等于的情形).
    
    参数:
    
    field - 数据库字段
    
    startValue - 开始值
    
    endValue - 结束值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - in
```
public Fenix in(String field,
                Object[] values)
```
    生成 IN 范围查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    values - 数组的值
    
    返回:
    
    Fenix 实例
  - in
```
public Fenix in(String field,
                Object[] values,
                boolean match)
```
    生成 IN 范围查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    values - 数组的值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - in
```
public Fenix in(String field,
                Collection<?> values)
```
    生成 IN 范围查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    values - 集合的值
    
    返回:
    
    Fenix 实例
  - in
```
public Fenix in(String field,
                Collection<?> values,
                boolean match)
```
    生成 IN 范围查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    values - 集合的值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - andIn
```
public Fenix andIn(String field,
                   Object[] values)
```
    生成带 " AND " 前缀的 IN 范围查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    values - 数组的值
    
    返回:
    
    Fenix 实例
  - andIn
```
public Fenix andIn(String field,
                   Object[] values,
                   boolean match)
```
    生成带 " AND " 前缀的 IN 范围查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    values - 数组的值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - andIn
```
public Fenix andIn(String field,
                   Collection<?> values)
```
    生成带 " AND " 前缀的 IN 范围查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    values - 集合的值
    
    返回:
    
    Fenix 实例
  - andIn
```
public Fenix andIn(String field,
                   Collection<?> values,
                   boolean match)
```
    生成带 " AND " 前缀的 IN 范围查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    values - 集合的值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - orIn
```
public Fenix orIn(String field,
                  Object[] values)
```
    生成带 " OR " 前缀的 IN 范围查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    values - 数组的值
    
    返回:
    
    Fenix 实例
  - orIn
```
public Fenix orIn(String field,
                  Object[] values,
                  boolean match)
```
    生成带 " OR " 前缀的 IN 范围查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    values - 数组的值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - orIn
```
public Fenix orIn(String field,
                  Collection<?> values)
```
    生成带 " OR " 前缀的 IN 范围查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    values - 集合的值
    
    返回:
    
    Fenix 实例
  - orIn
```
public Fenix orIn(String field,
                  Collection<?> values,
                  boolean match)
```
    生成带 " OR " 前缀的 IN 范围查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    values - 集合的值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - notIn
```
public Fenix notIn(String field,
                   Object[] values)
```
    生成 " NOT IN " 范围查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    values - 数组的值
    
    返回:
    
    Fenix 实例
  - notIn
```
public Fenix notIn(String field,
                   Object[] values,
                   boolean match)
```
    生成 " NOT IN " 范围查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    values - 数组的值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - notIn
```
public Fenix notIn(String field,
                   Collection<?> values)
```
    生成 " NOT IN " 范围查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    values - 集合的值
    
    返回:
    
    Fenix 实例
  - notIn
```
public Fenix notIn(String field,
                   Collection<?> values,
                   boolean match)
```
    生成 " NOT IN " 范围查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    values - 集合的值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - andNotIn
```
public Fenix andNotIn(String field,
                      Object[] values)
```
    生成带 " AND " 前缀的 " NOT IN " 范围查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    values - 数组的值
    
    返回:
    
    Fenix 实例
  - andNotIn
```
public Fenix andNotIn(String field,
                      Object[] values,
                      boolean match)
```
    生成带 " AND " 前缀的 " NOT IN " 范围查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    values - 数组的值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - andNotIn
```
public Fenix andNotIn(String field,
                      Collection<?> values)
```
    生成带 " AND " 前缀的 " NOT IN " 范围查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    values - 集合的值
    
    返回:
    
    Fenix 实例
  - andNotIn
```
public Fenix andNotIn(String field,
                      Collection<?> values,
                      boolean match)
```
    生成带 " AND " 前缀的 " NOT IN " 范围查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    values - 集合的值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - orNotIn
```
public Fenix orNotIn(String field,
                     Object[] values)
```
    生成带 " OR " 前缀的 " NOT IN " 范围查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    values - 数组的值
    
    返回:
    
    Fenix 实例
  - orNotIn
```
public Fenix orNotIn(String field,
                     Object[] values,
                     boolean match)
```
    生成带 " OR " 前缀的 " NOT IN " 范围查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    values - 数组的值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - orNotIn
```
public Fenix orNotIn(String field,
                     Collection<?> values)
```
    生成带 " OR " 前缀的 " NOT IN " 范围查询的 SQL 片段.
    
    参数:
    
    field - 数据库字段
    
    values - 集合的值
    
    返回:
    
    Fenix 实例
  - orNotIn
```
public Fenix orNotIn(String field,
                     Collection<?> values,
                     boolean match)
```
    生成带 " OR " 前缀的 " NOT IN " 范围查询的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    
    参数:
    
    field - 数据库字段
    
    values - 集合的值
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - isNull
```
public Fenix isNull(String field)
```
    生成 " IS NULL " 的 SQL 片段.
    示例：传入 {"a.name"} 参数，生成的 SQL 片段为：" a.name IS NULL "
    
    参数:
    
    field - 数据库字段
    
    返回:
    
    Fenix 实例
  - isNull
```
public Fenix isNull(String field,
                    boolean match)
```
    生成 " IS NULL " 的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    示例：传入 {"a.name", true} 两个参数，生成的SQL片段为：" a.name IS NULL "
    
    参数:
    
    field - 数据库字段
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - andIsNull
```
public Fenix andIsNull(String field)
```
    生成带 " AND " 前缀 " IS NULL " 的 SQL 片段.
    示例：传入 {"a.name"} 参数，生成的SQL片段为：" AND a.name IS NULL "
    
    参数:
    
    field - 数据库字段
    
    返回:
    
    Fenix 实例
  - andIsNull
```
public Fenix andIsNull(String field,
                       boolean match)
```
    生成带 " AND " 前缀 " IS NULL " 的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    示例：传入 {"a.name", true} 两个参数，生成的SQL片段为：" AND a.name IS NULL "
    
    参数:
    
    field - 数据库字段
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - orIsNull
```
public Fenix orIsNull(String field)
```
    生成带 " OR " 前缀 " IS NULL " 的 SQL 片段.
    示例：传入 {"a.name"} 参数，生成的SQL片段为：" OR a.name IS NULL "
    
    参数:
    
    field - 数据库字段
    
    返回:
    
    Fenix 实例
  - orIsNull
```
public Fenix orIsNull(String field,
                      boolean match)
```
    生成带 " OR " 前缀" IS NULL "的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    示例：传入 {"a.name", true} 两个参数，生成的SQL片段为：" OR a.name IS NULL "
    
    参数:
    
    field - 数据库字段
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - isNotNull
```
public Fenix isNotNull(String field)
```
    生成 " IS NOT NULL " 的 SQL 片段.
    示例：传入 {"a.name"} 参数，生成的SQL片段为：" a.name IS NOT NULL "
    
    参数:
    
    field - 数据库字段
    
    返回:
    
    Fenix 实例
  - isNotNull
```
public Fenix isNotNull(String field,
                       boolean match)
```
    生成 " IS NOT NULL " 的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    示例：传入 {"a.name", true} 两个参数，生成的SQL片段为：" a.name IS NOT NULL "
    
    参数:
    
    field - 数据库字段
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - andIsNotNull
```
public Fenix andIsNotNull(String field)
```
    生成带 " AND " 前缀 " IS NOT NULL " 的 SQL 片段.
    示例：传入 {"a.name"} 参数，生成的SQL片段为：" AND a.name IS NOT NULL "
    
    参数:
    
    field - 数据库字段
    
    返回:
    
    Fenix 实例
  - andIsNotNull
```
public Fenix andIsNotNull(String field,
                          boolean match)
```
    生成带 " AND " 前缀 " IS NOT NULL " 的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    示例：传入 {"a.name", true} 两个参数，生成的SQL片段为：" AND a.name IS NOT NULL "
    
    参数:
    
    field - 数据库字段
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例
  - orIsNotNull
```
public Fenix orIsNotNull(String field)
```
    生成带 " OR " 前缀 " IS NOT NULL " 的 SQL 片段.
    示例：传入 {"a.name"} 参数，生成的SQL片段为：" OR a.name IS NOT NULL "
    
    参数:
    
    field - 数据库字段
    
    返回:
    
    Fenix 实例
  - orIsNotNull
```
public Fenix orIsNotNull(String field,
                         boolean match)
```
    生成带 " OR " 前缀 " IS NOT NULL " 的 SQL 片段,如果 match 为 true 时则生成该条 SQL 片段，否则不生成.
    示例：传入 {"a.name", true} 两个参数，生成的SQL片段为：" OR a.name IS NOT NULL "
    
    参数:
    
    field - 数据库字段
    
    match - 是否匹配
    
    返回:
    
    Fenix 实例

类 Fenix

方法概要

从类继承的方法 java.lang.Object

方法详细资料

start

end

getXmlSqlInfo

getXmlSqlInfo

insertInto

values

deleteFrom

update

select

from

where

where

where

where

and

and

or

or

as

set

innerJoin

leftJoin

rightJoin

fullJoin

on

orderBy

groupBy

having

limit

offset

asc

desc

union

unionAll

text

text

text

text

text

param

params

doAny

doAny

equal

equal

andEqual

andEqual

orEqual

orEqual

notEqual

notEqual

andNotEqual

andNotEqual

orNotEqual

orNotEqual

greaterThan

greaterThan

andGreaterThan

andGreaterThan

orGreaterThan

orGreaterThan

lessThan

lessThan

andLessThan

andLessThan

orLessThan

orLessThan

greaterThanEqual

greaterThanEqual

andGreaterThanEqual

andGreaterThanEqual

orGreaterThanEqual

orGreaterThanEqual

lessThanEqual

lessThanEqual

andLessThanEqual