构建" IN "范围查询的SqlInfo信息.
@param fieldText 数据库字段文本
@param values 对象数组的值
@return 返回SqlInfo信息
335610
public SqlInfo buildInSql(String fieldText, Object[] values) {
        if (values == null || values.length == 0) {
            return sqlInfo;
        }

        // 遍历数组，并遍历添加in查询的替换符和参数
        this.suffix = StringHelper.isBlank(this.suffix) ? ZealotConst.IN_SUFFIX : this.suffix;
        join.append(prefix).append(fieldText).append(this.suffix).append("(");
        int len = values.length;
        for (int i = 0; i < len; i++) {
            if (i == len - 1) {
                join.append("?) ");
            } else {
                join.append("?, ");
            }
            params.add(values[i]);
        }

        return sqlInfo.setJoin(join).setParams(params);
    }
650909
public <S, R> AnimaQuery<T> in(TypeFunction<T, R> function, List<S> values) {
        String columnName = AnimaUtils.getLambdaColumnName(function);
        return this.in(columnName, values);
    }
576386
@XmlElement(name="field")
    public void setFieldInfos(final List<FieldInfo> fieldInfos) {
        if(fieldInfos == this.fieldInfos) {
            // Java7の場合、getterで取得したインスタンスをそのまま設定するため、スキップする。
            return;
        }
        
        this.fieldInfos.clear();
        for(FieldInfo item : fieldInfos) {
            addFieldInfo(item);
        }
    }
553403
public SqlInfo buildBetweenSql(String fieldText, String startText, String endText) {
        // 获取开始属性值和结束属性值,作区间查询
        Object startValue = ParseHelper.parseExpress(startText, context);
        Object endValue = ParseHelper.parseExpress(endText, context);
        return super.buildBetweenSql(fieldText, startValue, endValue);
    }
855552
public ZealotKhala text(String text, Object... values) {
        this.source.getSqlInfo().getJoin().append(text);
        this.appendParams(values, ZealotConst.OBJTYPE_ARRAY);
        return this;
    }
69573
public ZealotKhala where(String text, Object... value) {
        concat(SqlKeyConst.WHERE, text);
        return this.param(value);
    }
1101619
public static String in(Object[] args) {
		if (EmptyUtil.isEmpty(args) == true) {
			return "";
		}
		StringBuilder sql = new StringBuilder();
		Arrays.asList(args).forEach(arg -> {
			if (arg == null) {
				sql.append("NULL");
			} else if (arg instanceof CharSequence) {
				sql.append("'").append(arg).append("'");
			} else {
				sql.append(arg);
			}
			sql.append(", ");
		});
		sql.setLength(sql.length() - ", ".length());
		return sql.toString().trim();
	}
915035
public static Query withStrings(String field, String[] values, boolean caseInsensitive) {
        if (caseInsensitive) {
            List<Query> regexList = new ArrayList<Query>();
            for (String value : values) {
                regexList.add(withString(field, value, true));
            }
            return Query.or(regexList);
        } else {
            return Query.withValues(field, Query.in, Literal.values(values));
        }
    }
963137
def where_in(self, field_name, values, exact=False):
        
        field_name = Query.escape_if_needed(field_name)
        self._add_operator_if_needed()
        self.negate_if_needed(field_name)

        token = _Token(field_name=field_name, value=self.add_query_parameter(list(Utils.unpack_iterable(values))),
                       token="in", exact=exact)
        token.write = self.rql_where_write(token)
        self._where_tokens.append(token)

        return self
812938
public String translate(final Values values) {
        final ArrayList<Values.Row> rows = new ArrayList<>(values.getRows());
        final String[] aliases = values.getAliases();

        // If aliases does not exist, throw an exception.
        // Otherwise, apply them to the columns.
        if (aliases == null || aliases.length == 0) {
            throw new DatabaseEngineRuntimeException("Values requires aliases to avoid ambiguous columns names.");
        } else {
            rows.forEach(row -> {
                final List<Expression> expressions = row.getExpressions();
                for (int i = 0; i < expressions.size() && i < aliases.length; i++) {
                    // DISCLAIMER : May have side-effects because will change the state of the row's expressions.
                    expressions.get(i).alias(aliases[i]);
                }
            });
        }

        // Put each row on a select for union operator to work.
        final List<Expression> rowsWithSelect = rows.stream()
                .map(SqlBuilder::select)
                .collect(Collectors.toList());

        // By default, use UNION ALL to express VALUES.
        // This way, only engines that support VALUES will implement it.
        // Since the amount of values can be quite large, a linear UNION can cause Stack Overflow.
        // To avoid it, we model this UNION as a binary tree.
        final Union union = rowsToUnion(rowsWithSelect);

        if (values.isEnclosed()) {
            union.enclose();
        }

        return translate(union);
    }
32142
public static void cursorStringToContentValues(Cursor cursor, String field,
            ContentValues values) {
        cursorStringToContentValues(cursor, field, values, field);
    }
215470
public static StringBuilder in(String column, String[] values) {
		return in(column, values, new StringBuilder(64));
	}
991056
public static Query withValues(String field,
                                   NaryOp op,
                                   Literal... values) {
        Query q = new Query(false);
        q.add("field", field).add("op", op.toString()).add("values", Literal.toJson(values));
        return q;
    }
345962
public static long insert(Connection connection, String table,
			ContentValues values) {
		try {
			return insertOrThrow(connection, table, values);
		} catch (Exception e) {
			log.log(Level.WARNING, "Error inserting into table: " + table
					+ ", Values: " + values, e);
			return -1;
		}
	}
41468
public SqlInfo buildNormalSql(String fieldText, String valueText, String suffix) {
        Object value = ParseHelper.parseExpressWithException(valueText, context);
        return super.buildNormalSql(fieldText, value, suffix);
    }
239006
public static long insertOrThrow(Connection connection, String table,
			ContentValues values) {

		StringBuilder insert = new StringBuilder();
		insert.append("insert into ").append(CoreSQLUtils.quoteWrap(table))
				.append("(");

		Object[] args = null;
		int size = (values != null && values.size() > 0) ? values.size() : 0;

		args = new Object[size];
		int i = 0;
		for (String colName : values.keySet()) {
			insert.append((i > 0) ? "," : "");
			insert.append(CoreSQLUtils.quoteWrap(colName));
			args[i++] = values.get(colName);
		}
		insert.append(')');
		insert.append(" values (");
		for (i = 0; i < size; i++) {
			insert.append((i > 0) ? ",?" : "?");
		}
		insert.append(')');

		String sql = insert.toString();

		PreparedStatement statement = null;

		long id = 0;
		try {
			statement = connection.prepareStatement(sql);
			setArguments(statement, args);
			int count = statement.executeUpdate();

			if (count == 0) {
				throw new GeoPackageException(
						"Failed to execute SQL insert statement: " + sql
								+ ". No rows added from execution.");
			}

			try (ResultSet generatedKeys = statement.getGeneratedKeys()) {
				if (generatedKeys.next()) {
					id = generatedKeys.getLong(1);
				} else {
					throw new GeoPackageException(
							"Failed to execute SQL insert statement: " + sql
									+ ". No row id was found.");
				}
			}
		} catch (SQLException e) {
			throw new GeoPackageException(
					"Failed to execute SQL insert statement: " + sql, e);
		} finally {
			closeStatement(statement, sql);
		}

		return id;
	}
978827
public SqlInfo buildLikeSql(String fieldText, Object value) {
        // 由于默认配置的suffix的值只是" LIKE "和" NOT LIKE "两个关键字，生成的LIKE SQL片段需要加上" ? "占位符.
        this.suffix = StringHelper.isBlank(this.suffix) ? ZealotConst.LIKE_KEY : this.suffix;
        join.append(prefix).append(fieldText).append(suffix).append("? ");
        params.add("%" + value + "%");
        return sqlInfo.setJoin(join).setParams(params);
    }