private void outputConstraints(boolean skipConstraintValues, StringBuilder sb) { if (constraints.isEmpty()) { return; } sb.append(" WHERE "); Monoflop mf = Monoflop.create(); for (Constraint constraint : constraints) { if (mf.successiveCall()) { sb.append(" AND "); } sb.append(constraint.toString(skipConstraintValues)); } }
private void appendFieldList(Compiler c, boolean applyAliases) { Monoflop mf = Monoflop.create(); List<Mapping> requiredFields = new ArrayList<>(); fields.forEach(field -> { appendToSELECT(c, applyAliases, mf, field, true, requiredFields); }); // make sure that the join fields are always fetched requiredFields.forEach(requiredField -> { appendToSELECT(c, applyAliases, mf, requiredField, false, null); }); }
@Override public void asString(StringBuilder builder) { Monoflop mf = Monoflop.create(); builder.append("("); inner.stream().filter(Objects::nonNull).forEach(c -> { if (mf.successiveCall()) { builder.append(getCombiner()); } c.asString(builder); }); builder.append(")"); }
@Override public void appendSQL(SmartQuery.Compiler compiler) { Monoflop mf = Monoflop.create(); compiler.getWHEREBuilder().append("("); inner.stream().filter(Objects::nonNull).forEach(c -> { if (mf.successiveCall()) { compiler.getWHEREBuilder().append(getCombiner()); } c.appendSQL(compiler); }); compiler.getWHEREBuilder().append(")"); }
private void where(Compiler compiler) { if (constaints.isEmpty()) { return; } compiler.getWHEREBuilder().append(" WHERE "); Monoflop mf = Monoflop.create(); for (SQLConstraint c : constaints) { if (mf.successiveCall()) { compiler.getWHEREBuilder().append(" AND "); } c.appendSQL(compiler); } }
/** * Creates a new constraint which queriess the given field. * * @param input the query to parse * @param defaultField the defaultField to search in * @param tokenizer the function to used for tokenization of the input * @param autoExpand should single token queries be auto expanded. That will put a "*" after the resulting token * but limits the number of expansions to the top 256 terms. */ public RobustQueryParser(String input, String defaultField, Function<String, Iterable<List<String>>> tokenizer, boolean autoExpand) { this.input = Value.of(input).trim(); this.defaultField = defaultField; this.tokenizer = tokenizer; this.autoExpand = autoExpand; this.parsed = Monoflop.create(); }
private static void reportUnknownType(Output output, String typeName) { output.line("Unknown type: " + typeName); Monoflop mf = Monoflop.create(); for (String name : index.getSchema().getTypeNames()) { if (name.toLowerCase().contains(typeName.toLowerCase())) { if (mf.firstCall()) { output.line("Did you mean one of those: "); } output.line(" * " + name); } } }
sql.append(getDescriptor().getRelationName()); sql.append(" ("); Monoflop mf = Monoflop.create(); for (Property p : getProperties()) { if (mf.successiveCall()) {
protected void buildWhere(StringBuilder sql, boolean addVersionConstraint) { String compareOperator = isNullSafeOperator() ? " <=> ?" : " = ?"; sql.append(" WHERE "); Monoflop mf = Monoflop.create(); for (Property p : getProperties()) { if (mf.successiveCall()) { sql.append(" AND "); } sql.append(p.getPropertyName()); sql.append(compareOperator); } if (!addVersionConstraint) { return; } if (descriptor.isVersioned()) { if (mf.successiveCall()) { sql.append(" AND "); } sql.append(BaseMapper.VERSION); sql.append(" = ?"); } } }
private void orderBy(Compiler compiler) { if (!orderBys.isEmpty()) { compiler.getWHEREBuilder().append(" ORDER BY "); Monoflop mf = Monoflop.create(); for (Tuple<Mapping, Boolean> e : orderBys) { if (mf.successiveCall()) { compiler.getWHEREBuilder().append(", "); } compiler.getWHEREBuilder().append(compiler.translateColumnName(e.getFirst())); compiler.getWHEREBuilder().append(e.getSecond() ? " ASC" : " DESC"); } } }
@Override public String generateCreateTable(Table table) { StringBuilder sb = new StringBuilder(); sb.append("CREATE TABLE `"); sb.append(table.getName()); sb.append("` (\n"); Monoflop mf = Monoflop.create(); for (TableColumn col : table.getColumns()) { if (shouldGenerateColumn(col)) { if (mf.successiveCall()) { sb.append(","); } sb.append(MessageFormat.format(" {0} {1} {2}\n", col.getName(), getTypeName(col), getDefaultValueAsString(col))); } } sb.append("\n) ENGINE="); sb.append(getEngine(table).asString("Log")); return sb.toString(); }
@Override protected void buildSQL() throws SQLException { StringBuilder sql = new StringBuilder("UPDATE "); sql.append(getDescriptor().getRelationName()); Monoflop mf = Monoflop.create(); sql.append(" SET "); for (Property p : getPropertiesToUpdate()) { if (mf.successiveCall()) { sql.append(", "); } sql.append(p.getPropertyName()); sql.append(" = ?"); } if (descriptor.isVersioned()) { if (mf.successiveCall()) { sql.append(", "); } sql.append(BaseMapper.VERSION); sql.append(" = ?"); } buildWhere(sql, true); createStmt(sql.toString(), false); } }
private void expectKeyword(String... keywords) throws ParseException { if (!in(keywords)) { StringBuilder allKeywords = new StringBuilder(); Monoflop mf = Monoflop.create(); for (String keyword : keywords) { if (mf.successiveCall()) { allKeywords.append(", "); } allKeywords.append("'"); allKeywords.append(keyword); allKeywords.append("'"); } throw new ParseException(NLS.fmtr("AdvancedDateParser.errUnexpectedKeyword") .set("token", tokenizer.toString()) .set("keywords", allKeywords) .format(), tokenizer.getTokenStart()); } }
protected QueryBuilder transformTokenList(String field, List<String> tokens) { if (tokens.size() == 1) { return QueryBuilders.termQuery(field, tokens.get(0)); } else { Monoflop monoflop = Monoflop.create(); SpanNearQueryBuilder builder = null; for (String token : tokens) { if (monoflop.firstCall()) { builder = QueryBuilders.spanNearQuery(QueryBuilders.spanTermQuery(field, token), 3); } else { builder.addClause(QueryBuilders.spanTermQuery(field, token)); } } return builder; } } }
@Override public SpanQueryBuilder createSpanQuery() { Monoflop mflop = Monoflop.create(); SpanOrQueryBuilder builder = null; for (Constraint constraint : constraints) { if (constraint instanceof SpanConstraint) { SpanConstraint spanConstraint = (SpanConstraint) constraint; if (mflop.firstCall()) { builder = QueryBuilders.spanOrQuery(spanConstraint.createSpanQuery()); } else { builder.addClause(spanConstraint.createSpanQuery()); } } else { throw new UnsupportedOperationException( "Or-Constraint contains a non span constraint, which is not allowed!"); } } return builder; }
private void appendCanonicalQueryString(WebContext ctx, StringBuilder canonicalRequest) { QueryStringDecoder qsd = new QueryStringDecoder(ctx.getRequest().uri(), Charsets.UTF_8); List<Tuple<String, List<String>>> queryString = Tuple.fromMap(qsd.parameters()); queryString.sort(Comparator.comparing(Tuple::getFirst)); Monoflop mf = Monoflop.create(); for (Tuple<String, List<String>> param : queryString) { if (param.getSecond().isEmpty()) { appendQueryStringValue(param.getFirst(), "", canonicalRequest, mf.successiveCall()); } else { for (String value : param.getSecond()) { appendQueryStringValue(param.getFirst(), value, canonicalRequest, mf.successiveCall()); } } } canonicalRequest.append("\n"); }
/** * Tries to apply the given changes and to save the resulting entity. * <p> * Tries to perform the given modifications and then to update the entity. If an optimistic lock error occurs, * the entity is refreshed and the modifications are re-executed along with another update. * * @param entity the entity to update * @param preSaveModifier the changes to perform on the entity * @param <E> the type of the entity to update * @throws HandledException if either any other exception occurs, or if all three attempts fail with an optimistic * lock error. */ public <E extends Entity> void retryUpdate(E entity, Callback<E> preSaveModifier) { Monoflop mf = Monoflop.create(); retry(() -> { E entityToUpdate = entity; if (mf.successiveCall()) { entityToUpdate = refreshIfPossible(entity); } preSaveModifier.invoke(entityToUpdate); tryUpdate(entityToUpdate); }); }
/** * Tries to apply the given changes and to save the resulting entity without running the entities save checks and handlers. * <p> * Tries to perform the given modifications and then to update the entity. If an optimistic lock error occurs, * the entity is refreshed and the modifications are re-executed along with another update. * * @param entity the entity to update * @param preSaveModifier the changes to perform on the entity * @param <E> the type of the entity to update * @throws HandledException if either any other exception occurs, or if all three attempts fail with an optimistic * lock error. */ public <E extends Entity> void retryUpdateUnchecked(E entity, Callback<E> preSaveModifier) { Monoflop mf = Monoflop.create(); retry(() -> { E entityToUpdate = entity; if (mf.successiveCall()) { entityToUpdate = refreshIfPossible(entity); } preSaveModifier.invoke(entityToUpdate); tryUpdateUnchecked(entityToUpdate); }); }
@Override public SpanNearQueryBuilder createQuery() { Monoflop mflop = Monoflop.create(); SpanNearQueryBuilder builder = null; for (SpanConstraint constraint : constraints) { if (mflop.firstCall()) { builder = QueryBuilders.spanNearQuery(constraint.createSpanQuery(), slop).inOrder(inOrder).boost(boost); } else { builder.addClause(constraint.createSpanQuery()).inOrder(inOrder).boost(boost); } } return builder; }
Monoflop mf = Monoflop.create(); for (Document doc : cur) { if (mf.firstCall()) {