#190

Committed 01 Sep 2025 11:48AM UTC coverage: 92.296% (-0.2%) from 92.457%

Build # #190

Build Type

push

Committed by

Commit Message

Introduce DataQueryParameter for more extensible queries

Run Details

72 of 85 new or added lines in 18 files covered. (84.71%)

1 existing line in 1 file now uncovered.

1186 of 1285 relevant lines covered (92.3%)

0.92 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.91

/src/main/java/org/fluentjdbc/DatabaseUpdateBuilder.java

package org.fluentjdbc;

import javax.annotation.CheckReturnValue;
import javax.annotation.Nonnull;
import javax.annotation.ParametersAreNonnullByDefault;
import java.sql.Connection;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * Generate <code>UPDATE</code> statements by collecting field names and parameters. Example:
 *
 * <pre>
 * int count = table
 *      .where("id", id)
 *      .update()
 *      .setField("name", "Something")
 *      .setField("code", 102)
 *      .execute(connection);
 * </pre>
 */
@ParametersAreNonnullByDefault
public class DatabaseUpdateBuilder implements DatabaseUpdatable<DatabaseUpdateBuilder> {

    @Nonnull
    private final DatabaseTable table;
    private final Map<String, DatabaseQueryParameter> updateParameters = new LinkedHashMap<>();
    private DatabaseWhereBuilder whereClause;

    public DatabaseUpdateBuilder(DatabaseTable table) {
        this.table = table;
    }

    /**
     * Adds parameters to the <code>UPDATE SET fieldName = (expression)</code> and to the list of parameters
     */
    public DatabaseUpdateBuilder addParameters(List<DatabaseQueryParameter> queryParameters) {
        //noinspection ResultOfMethodCallIgnored
        queryParameters.forEach(this::addParameter);
        return this;
    }

    /**
     * Adds a parameter to the <code>UPDATE SET fieldName = (expression)</code> and to the list of parameters
     */
    @CheckReturnValue
    public DatabaseUpdateBuilder addParameter(DatabaseQueryParameter parameter) {
        updateParameters.put(parameter.getColumnName(), parameter);
        return this;
    }
    /**
     * Calls {@link #setField(String, Object)} for each fieldName and parameter
     */
    @Override
    public DatabaseUpdateBuilder setFields(List<String> fields, List<?> values) {
        for (int i = 0; i < fields.size(); i++) {
            //noinspection ResultOfMethodCallIgnored
            setField(fields.get(i), values.get(i));
        }
        return this;
    }

    /**
     * Calls {@link #setField(String, Object)} for each key and value in the parameter map
     */
    @Override
    public DatabaseUpdateBuilder setFields(Map<String, ?> fields) {
        //noinspection ResultOfMethodCallIgnored
        fields.forEach(this::setField);
        return this;
    }

    /**
     * Will generate <code>UPDATE</code> statements, set parameters and execute to database
     */
    public int execute(Connection connection) {
        if (updateParameters.isEmpty()) {
            return 0;
        }
        List<Object> parameters = new ArrayList<>();
        updateParameters.values().forEach(p -> parameters.addAll(p.getParameters()));
        parameters.addAll(whereClause.getParameters());
        return table.newStatement("UPDATE", createUpdateStatement(), parameters).executeUpdate(connection);
    }

    private String createUpdateStatement() {
        return "update " + table.getTableName() + " set " + updateParameters.values().stream().map(p -> p.getColumnName() + " = " + p.getUpdateExpression()).collect(Collectors.joining(", ")) + whereClause.whereClause();
    }

    @CheckReturnValue
    public DatabaseUpdateBuilder where(DatabaseWhereBuilder whereClause) {
        this.whereClause = whereClause;
        return this;
    }
}

1	package org.fluentjdbc;
2
3	import javax.annotation.CheckReturnValue;
4	import javax.annotation.Nonnull;
5	import javax.annotation.ParametersAreNonnullByDefault;
6	import java.sql.Connection;
7	import java.util.ArrayList;
8	import java.util.LinkedHashMap;
9	import java.util.List;
10	import java.util.Map;
11	import java.util.stream.Collectors;
12
13	/**
14	* Generate <code>UPDATE</code> statements by collecting field names and parameters. Example:
15	*
16	* <pre>
17	* int count = table
18	* .where("id", id)
19	* .update()
20	* .setField("name", "Something")
21	* .setField("code", 102)
22	* .execute(connection);
23	* </pre>
24	*/
25	@ParametersAreNonnullByDefault
26	public class DatabaseUpdateBuilder implements DatabaseUpdatable<DatabaseUpdateBuilder> {
27
28	@Nonnull
29	private final DatabaseTable table;
30	private final Map<String, DatabaseQueryParameter> updateParameters = new LinkedHashMap<>();	1✔
31	private DatabaseWhereBuilder whereClause;
32
33	public DatabaseUpdateBuilder(DatabaseTable table) {	1✔
34	this.table = table;	1✔
35	}	1✔
36
37	/**
38	* Adds parameters to the <code>UPDATE SET fieldName = (expression)</code> and to the list of parameters
39	*/
40	public DatabaseUpdateBuilder addParameters(List<DatabaseQueryParameter> queryParameters) {
41	//noinspection ResultOfMethodCallIgnored
NEW 42	queryParameters.forEach(this::addParameter);	×
NEW 43	return this;	×
44	}
45
46	/**
47	* Adds a parameter to the <code>UPDATE SET fieldName = (expression)</code> and to the list of parameters
48	*/
49	@CheckReturnValue
50	public DatabaseUpdateBuilder addParameter(DatabaseQueryParameter parameter) {
51	updateParameters.put(parameter.getColumnName(), parameter);	1✔
52	return this;	1✔
53	}
54	/**
55	* Calls {@link #setField(String, Object)} for each fieldName and parameter
56	*/
57	@Override
58	public DatabaseUpdateBuilder setFields(List<String> fields, List<?> values) {
59	for (int i = 0; i < fields.size(); i++) {	1✔
60	//noinspection ResultOfMethodCallIgnored
61	setField(fields.get(i), values.get(i));	1✔
62	}
63	return this;	1✔
64	}
65
66	/**
67	* Calls {@link #setField(String, Object)} for each key and value in the parameter map
68	*/
69	@Override
70	public DatabaseUpdateBuilder setFields(Map<String, ?> fields) {
71	//noinspection ResultOfMethodCallIgnored
72	fields.forEach(this::setField);	1✔
73	return this;	1✔
74	}
75
76	/**
77	* Will generate <code>UPDATE</code> statements, set parameters and execute to database
78	*/
79	public int execute(Connection connection) {
80	if (updateParameters.isEmpty()) {	1✔
81	return 0;	1✔
82	}
83	List<Object> parameters = new ArrayList<>();	1✔
84	updateParameters.values().forEach(p -> parameters.addAll(p.getParameters()));	1✔
85	parameters.addAll(whereClause.getParameters());	1✔
86	return table.newStatement("UPDATE", createUpdateStatement(), parameters).executeUpdate(connection);	1✔
87	}
88
89	private String createUpdateStatement() {
90	return "update " + table.getTableName() + " set " + updateParameters.values().stream().map(p -> p.getColumnName() + " = " + p.getUpdateExpression()).collect(Collectors.joining(", ")) + whereClause.whereClause();	1✔
91	}
92
93	@CheckReturnValue
94	public DatabaseUpdateBuilder where(DatabaseWhereBuilder whereClause) {
95	this.whereClause = whereClause;	1✔
96	return this;	1✔
97	}
98	}

jhannes / fluent-jdbc / #190

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous