#214

Committed 14 Oct 2026 08:20PM UTC coverage: 91.373% (-0.3%) from 91.667%

Build # #214

Build Type

push

Committed by

Commit Message

[maven-release-plugin] prepare release fluent-jdbc-0.8.1

Coverage Stats

1218 of 1333 relevant lines covered (91.37%)

0.91 hits per line

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

96.0

/src/main/java/org/fluentjdbc/DatabaseInsertBuilder.java

package org.fluentjdbc;

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

/**
 * Generate <code>INSERT</code> statements by collecting field names and parameters. Support
 * autogeneration of primary keys. Example:
 *
 * <pre>
 * Long id = table.insert()
 *    .setPrimaryKey("id", (Long)null)
 *    .setField("name", "Something")
 *    .setField("code", 102)
 *    .execute(connection);
 * </pre>
 */
@ParametersAreNonnullByDefault
public class DatabaseInsertBuilder implements DatabaseUpdatable<DatabaseInsertBuilder> {

    protected final DatabaseTable table;
    protected final LinkedHashMap<String, DatabaseQueryParameter> queryParameters = new LinkedHashMap<>();

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

    @CheckReturnValue
    Collection<Object> getParameters() {
        ArrayList<Object> parameters = new ArrayList<>();
        this.queryParameters.values().forEach(q -> parameters.addAll(q.getParameters()));
        return parameters;
    }

    /**
     * Adds a parameter to the <code>INSERT (fieldName) VALUES (expression)</code> and to the list of parameters
     */
    @Override
    public DatabaseInsertBuilder addParameter(DatabaseQueryParameter parameter) {
        this.queryParameters.put(parameter.getColumnName(), parameter);
        return this;
    }

    /**
     * Adds parameters to the <code>INSERT (fieldName) VALUES (expression)</code> and to the list of parameters
     */
    @Override
    public DatabaseInsertBuilder addParameters(List<DatabaseQueryParameter> queryParameters) {
        //noinspection ResultOfMethodCallIgnored
        queryParameters.forEach(this::addParameter);
        return this;
    }

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

    /**
     * Calls {@link #setField(String, Object)} for each fieldName and parameter
     */
    @Override
    public DatabaseInsertBuilder setFields(List<String> fieldNames, List<?> values) {
        for (int i = 0; i < fieldNames.size(); i++) {
            //noinspection ResultOfMethodCallIgnored
            setField(fieldNames.get(i), values.get(i));
        }
        return this;
    }

    /**
     * Executes the insert statement and returns the number of rows inserted. Calls
     * {@link #createInsertStatement()} to generate SQL and
     * {@link DatabaseStatement#executeUpdate(Connection)}
     * to bind parameters and execute statement
     */
    public int execute(Connection connection) {
        return getDatabaseStatement().executeUpdate(connection);
    }

    public DatabaseStatement getDatabaseStatement() {
        return table.newStatement("INSERT", createInsertStatement(), getParameters());
    }

    /**
     * Creates String for
     * <code>INSERT INTO tableName (fieldName, fieldName, ...) VALUES (?, ?, ...)</code>
     */
    @CheckReturnValue
    String createInsertStatement() {
        return "insert into " + table.getTableName() + " (" +
                queryParameters.values().stream().map(DatabaseQueryParameter::getColumnName).collect(Collectors.joining(", ")) +
                ") values (" +
                queryParameters.values().stream().map(DatabaseQueryParameter::getUpdateExpression).collect(Collectors.joining(", ")) +
                ")";
    }

    /**
     * Adds primary key to the <code>INSERT</code> statement if idValue is not null. If idValue is null
     * this will {@link java.sql.PreparedStatement#execute(String, String[])} to generate the primary
     * key using the underlying table autogeneration mechanism
     *
     * <p><strong>Bug: This doesn't work for Android when idValue is null</strong></p>
     */
    @CheckReturnValue
    public <T> DatabaseInsertWithPkBuilder<T> setPrimaryKey(String idField, @Nullable T idValue) {
        if (idValue != null) {
            //noinspection ResultOfMethodCallIgnored
            setField(idField, idValue);
        }
        return new DatabaseInsertWithPkBuilder<>(this, idField, idValue);
    }

    public DatabaseTable getTable() {
        return table;
    }
}

1	package org.fluentjdbc;
2
3	import javax.annotation.CheckReturnValue;
4	import javax.annotation.Nullable;
5	import javax.annotation.ParametersAreNonnullByDefault;
6	import java.sql.Connection;
7	import java.util.ArrayList;
8	import java.util.Collection;
9	import java.util.LinkedHashMap;
10	import java.util.List;
11	import java.util.Map;
12	import java.util.stream.Collectors;
13
14	/**
15	* Generate <code>INSERT</code> statements by collecting field names and parameters. Support
16	* autogeneration of primary keys. Example:
17	*
18	* <pre>
19	* Long id = table.insert()
20	* .setPrimaryKey("id", (Long)null)
21	* .setField("name", "Something")
22	* .setField("code", 102)
23	* .execute(connection);
24	* </pre>
25	*/
26	@ParametersAreNonnullByDefault
27	public class DatabaseInsertBuilder implements DatabaseUpdatable<DatabaseInsertBuilder> {
28
29	protected final DatabaseTable table;
30	protected final LinkedHashMap<String, DatabaseQueryParameter> queryParameters = new LinkedHashMap<>();	1 ✔
31
32	public DatabaseInsertBuilder(DatabaseTable table) {	1 ✔
33	this.table = table;	1 ✔
34	}	1 ✔
35
36	@CheckReturnValue
37	Collection<Object> getParameters() {
38	ArrayList<Object> parameters = new ArrayList<>();	1 ✔
39	this.queryParameters.values().forEach(q -> parameters.addAll(q.getParameters()));	1 ✔
40	return parameters;	1 ✔
41	}
42
43	/**
44	* Adds a parameter to the <code>INSERT (fieldName) VALUES (expression)</code> and to the list of parameters
45	*/
46	@Override
47	public DatabaseInsertBuilder addParameter(DatabaseQueryParameter parameter) {
48	this.queryParameters.put(parameter.getColumnName(), parameter);	1 ✔
49	return this;	1 ✔
50	}
51
52	/**
53	* Adds parameters to the <code>INSERT (fieldName) VALUES (expression)</code> and to the list of parameters
54	*/
55	@Override
56	public DatabaseInsertBuilder addParameters(List<DatabaseQueryParameter> queryParameters) {
57	//noinspection ResultOfMethodCallIgnored
58	queryParameters.forEach(this::addParameter);	1 ✔
59	return this;	1 ✔
60	}
61
62	/**
63	* Calls {@link #setField(String, Object)} for each key and value in the parameter map
64	*/
65	@Override
66	public DatabaseInsertBuilder setFields(Map<String, ?> fields) {
67	//noinspection ResultOfMethodCallIgnored
68	fields.forEach(this::setField);	1 ✔
69	return this;	1 ✔
70	}
71
72	/**
73	* Calls {@link #setField(String, Object)} for each fieldName and parameter
74	*/
75	@Override
76	public DatabaseInsertBuilder setFields(List<String> fieldNames, List<?> values) {
77	for (int i = 0; i < fieldNames.size(); i++) {	1 ✔
78	//noinspection ResultOfMethodCallIgnored
79	setField(fieldNames.get(i), values.get(i));	1 ✔
80	}
81	return this;	1 ✔
82	}
83
84	/**
85	* Executes the insert statement and returns the number of rows inserted. Calls
86	* {@link #createInsertStatement()} to generate SQL and
87	* {@link DatabaseStatement#executeUpdate(Connection)}
88	* to bind parameters and execute statement
89	*/
90	public int execute(Connection connection) {
91	return getDatabaseStatement().executeUpdate(connection);	1 ✔
92	}
93
94	public DatabaseStatement getDatabaseStatement() {
95	return table.newStatement("INSERT", createInsertStatement(), getParameters());	1 ✔
96	}
97
98	/**
99	* Creates String for
100	* <code>INSERT INTO tableName (fieldName, fieldName, ...) VALUES (?, ?, ...)</code>
101	*/
102	@CheckReturnValue
103	String createInsertStatement() {
104	return "insert into " + table.getTableName() + " (" +	1 ✔
105	queryParameters.values().stream().map(DatabaseQueryParameter::getColumnName).collect(Collectors.joining(", ")) +	1 ✔
106	") values (" +
107	queryParameters.values().stream().map(DatabaseQueryParameter::getUpdateExpression).collect(Collectors.joining(", ")) +	1 ✔
108	")";
109	}
110
111	/**
112	* Adds primary key to the <code>INSERT</code> statement if idValue is not null. If idValue is null
113	* this will {@link java.sql.PreparedStatement#execute(String, String[])} to generate the primary
114	* key using the underlying table autogeneration mechanism
115	*
116	* <p><strong>Bug: This doesn't work for Android when idValue is null</strong></p>
117	*/
118	@CheckReturnValue
119	public <T> DatabaseInsertWithPkBuilder<T> setPrimaryKey(String idField, @Nullable T idValue) {
120	if (idValue != null) {	1 ✔
121	//noinspection ResultOfMethodCallIgnored
122	setField(idField, idValue);	1 ✔
123	}
124	return new DatabaseInsertWithPkBuilder<>(this, idField, idValue);	1 ✔
125	}
126
127	public DatabaseTable getTable() {
128	return table;	×
129	}
130	}

jhannes / fluent-jdbc / #214

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