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)); } }
@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); } }
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(" = ?"); } } }
Monoflop mf = Monoflop.create(); for (Property p : getProperties()) { if (mf.successiveCall()) { sql.append(", "); values.append(", ?"); if (mf.successiveCall()) { sql.append(", "); values.append(", ?");
@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 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(); }
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()); } }
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"); }
private void appendToSELECT(Compiler c, boolean applyAliases, Monoflop mf, Mapping field, boolean createJoinFetch, List<Mapping> requiredFieldsCollector) { if (mf.successiveCall()) { c.getSELECTBuilder().append(", "); } Tuple<String, EntityDescriptor> joinInfo = c.determineAlias(field.getParent()); c.getSELECTBuilder().append(joinInfo.getFirst()); c.getSELECTBuilder().append("."); String columnName = joinInfo.getSecond().getProperty(field.getName()).getPropertyName(); c.getSELECTBuilder().append(columnName); if (!c.defaultAlias.equals(joinInfo.getFirst())) { if (applyAliases) { c.getSELECTBuilder().append(" AS "); c.getSELECTBuilder().append(joinInfo.getFirst()); c.getSELECTBuilder().append("_"); c.getSELECTBuilder().append(columnName); } if (createJoinFetch) { c.createJoinFetch(field, fields, requiredFieldsCollector); } } }
/** * 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); }); }