执行生成in范围查询SQL片段的方法.
@param prefix 前缀
@param field 数据库字段
@param values 数组的值
@param match 是否匹配
@param positive true则表示是in，否则是not in
@return ZealotKhala实例的当前实例
8842
private ZealotKhala doIn(String prefix, String field, Object[] values, boolean match, boolean positive) {
        return this.doInByType(prefix, field, values, match, ZealotConst.OBJTYPE_ARRAY, positive);
    }
610520
Map<String, Integer> getPrefixesIds(String field, List<String> prefixes) {
    LinkedHashMap<String, Long> refs = getPrefixRefs(field);
    if (refs != null) {
      List<String> list = new ArrayList<>(refs.keySet());
      Map<String, Integer> result = new HashMap<>();
      for (String prefix : prefixes) {
        int id = list.indexOf(prefix);
        if (id >= 0) {
          result.put(prefix, id + 1);
        }
      }
      return result;
    } else {
      return null;
    }
  }
1251648
public static Query withFieldValues(String field,
                                        NaryOp op,
                                        String rfield) {
        Query q = new Query(false);
        q.add("field", field).add("op", op.toString()).add("rfield", rfield);
        return q;
    }
1308895
public ZealotKhala andLessEqual(String field, Object value) {
        return this.doNormal(ZealotConst.AND_PREFIX, field, value, ZealotConst.LTE_SUFFIX, true);
    }
218910
public ZealotKhala orMoreEqual(String field, Object value) {
        return this.doNormal(ZealotConst.OR_PREFIX, field, value, ZealotConst.GTE_SUFFIX, true);
    }
1172107
public ZealotKhala andNotEqual(String field, Object value) {
        return this.doNormal(ZealotConst.AND_PREFIX, field, value, ZealotConst.NOT_EQUAL_SUFFIX, true);
    }
590740
public ZealotKhala orIsNull(String field) {
        return this.doIsNull(ZealotConst.OR_PREFIX, field, true,true);
    }
1002930
public ZealotKhala orLike(String field, Object value) {
        return this.doLike(ZealotConst.OR_PREFIX, field, value, true, true);
    }
371633
public static Predicate in(final String expr, final Object... values) {
        return in(expr, Arrays.asList(values));
    }
1083457
@SuppressWarnings("unchecked")
	public <T> SqlBuilder in(String field, T... values) {
		sql.append(wrapper.wrap(field)).append(" IN ").append("(").append(ArrayUtil.join(values, StrUtil.COMMA)).append(")");
		return this;
	}
1188851
public static Query withValue(String field,
                                  BinOp op,
                                  Literal value) {
        Query q = new Query(false);
        q.add("field", field).add("op", op.toString()).add("rvalue", value.toJson());
        return q;
    }
233102
public ZealotKhala andNotLikePattern(String field, String pattern) {
        return this.doLikePattern(ZealotConst.AND_PREFIX, field, pattern, true, false);
    }
943650
private LinkedHashMap<String, Num> mapValues(String infix, Object... values) {
        LinkedHashMap<String, Num> vNames = null;
        int remain = 0;
      
        Matcher mat = pVariableNames.matcher(infix);
        while (mat.find()) {
            if (vNames == null)
                vNames = new LinkedHashMap<String, Num>();

            String vName = mat.group();
            if (!vNames.containsKey(vName)) {
                remain++;
                Num num = findValue(vName, true, values);
                vNames.put(vName, num);

                if (num != null)
                    remain--;
            }
        }

        // pair names with values without name
        if (vNames != null) {
            int lastPos = 0;
            for (Entry<String, Num> entry : vNames.entrySet()) {
                if (entry.getValue() == null) {
                    for (int i = lastPos; i < values.length; i++) {
                        Object v = values[i];
                        if (v != null) {
                            if (v instanceof Num) {
                                Num n = (Num) v;
                                if (n.getName() == null)
                                    entry.setValue(n);
                                else if (n.getName().equals(entry.getValue()))
                                    entry.setValue(n);
                            }
                            else
                                entry.setValue(Num.toNum(v));

                            values[i] = null;
                            lastPos = i;
                            remain--;
                        }
                    }
                }
            }
        }

        if (remain > 0 && vNames != null) {
            StringBuilder sb = new StringBuilder();
            int c = 0;
            for (Entry<String, Num> entry : vNames.entrySet()) {
                if (entry.getValue() == null) {
                    if (c++ > 0)
                        sb.append(", ");
                    sb.append(entry.getKey());
                }
            }

            throw new CalculatorException("Undefined values for expression (" + infix + ") variables: " + sb.toString());
        }

        return vNames;
    }
32130
public SqlInfo buildLikeSql(String fieldText, String valueText, String patternText) {
        if (StringHelper.isNotBlank(valueText) && StringHelper.isBlank(patternText)) {
            return super.buildLikeSql(fieldText, ParseHelper.parseExpressWithException(valueText, context));
        } else if (StringHelper.isBlank(valueText) && StringHelper.isNotBlank(patternText)) {
            return super.buildLikePatternSql(fieldText, patternText);
        } else {
            throw new ValidFailException("<like /> 标签中的'value'属性和'pattern'属性不能同时为空或者同时不为空！");
        }
    }
1052436
public Expression<Boolean> in(Boolean[] value) {
		String listBooleanString = "";
		Boolean firstNumber = true;
		for (Boolean v : value) {
			if (firstNumber) {
				listBooleanString = listBooleanString.concat("(").concat(v.toString());
				firstNumber = false;
			} else {
				listBooleanString = listBooleanString.concat(", ").concat(v.toString());
			}
		}
		listBooleanString = listBooleanString.concat(")");
		return new Expression<Boolean>(this, Operation.in, listBooleanString);
	}
604184
public static Query regex(String field, Pattern regex) {
        return new Query().regex(field, regex);
    }
1206571
public static Builder pushAll(String field, Object... values) {
        return new Builder().pushAll(field, values);
    }