Plugin for setting parameters of custom types (eg. Joda time, etc..)
8 | *
9 | * Note: Support for java.time is implemented by Fluent-Jdbc by default
10 | */
11 | @FunctionalInterface
12 | public interface ParamSetter {
13 | void set(T param, PreparedStatement statement, Integer index) throws SQLException;
14 | }
15 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/api/integration/ConnectionProvider.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.api.integration;
2 |
3 | import java.sql.SQLException;
4 |
5 | /**
6 | *
7 | * Provides Connections to FluentJdbc Queries. It allows both acquiring and releasing a Connection.
8 | * This makes it possible to integrate FluentJdbc to most pooling / transaction management solutions.
9 | *
10 | *
11 | * Implementation pattern
12 | *
13 | * query -> {
14 | * Connection connection = ... // acquire a connection
15 | * query.receive(connection) // make the connection available to FluentJdbc queries
16 | * connection.close() // release connection - may not be needed if connection is already managed
17 | * }
18 | *
19 | *
20 | *
21 | * Example implementations:
22 | *
23 | *
24 | *
25 | * Getting connection from a datasource (provided in the library as DataSourceConnectionProvider):
26 | *
27 | *
28 | *
29 | * query -> {
30 | * try(Connection connection = dataSource.getConnection()) {
31 | * query.receive(connection);
32 | * }
33 | * }
34 | *
35 | *
36 | *
37 | * Getting connection from a callback mechanism (eg Spring JdbcOperations/JdbcTemplate):
38 | *
39 | *
40 | *
41 | * query -> {
42 | * jdbcTemplate.execute(connection -> {
43 | * query.receive(connection);
44 | * });
45 | * }
46 | *
47 | *
48 | */
49 | @FunctionalInterface
50 | public interface ConnectionProvider {
51 | void provide(QueryConnectionReceiver query) throws SQLException;
52 | }
53 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/api/integration/QueryConnectionReceiver.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.api.integration;
2 |
3 | import java.sql.Connection;
4 | import java.sql.SQLException;
5 |
6 | /**
7 | * Fluent-Jdbc queries receive the connections from this interface. Should be called in ConnectionProvider implementations,
8 | * no need to implement it for integrations.
9 | */
10 | @FunctionalInterface
11 | public interface QueryConnectionReceiver {
12 | void receive(Connection connection) throws SQLException;
13 | }
14 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/api/integration/providers/DataSourceConnectionProvider.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.api.integration.providers;
2 |
3 | import org.codejargon.fluentjdbc.api.integration.QueryConnectionReceiver;
4 | import org.codejargon.fluentjdbc.api.integration.ConnectionProvider;
5 |
6 | import javax.sql.DataSource;
7 | import java.sql.Connection;
8 | import java.sql.SQLException;
9 |
10 | /**
11 | * ConnectionProvider based on a DataSource.
12 | */
13 | public class DataSourceConnectionProvider implements ConnectionProvider {
14 | private final DataSource dataSource;
15 |
16 | public DataSourceConnectionProvider(DataSource dataSource) {
17 | this.dataSource = dataSource;
18 | }
19 |
20 | @Override
21 | public void provide(QueryConnectionReceiver query) throws SQLException {
22 | try(Connection connection = dataSource.getConnection()) {
23 | query.receive(connection);
24 | }
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/api/mapper/Mappers.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.api.mapper;
2 |
3 | import org.codejargon.fluentjdbc.api.query.Mapper;
4 |
5 | import java.math.BigDecimal;
6 | import java.sql.Blob;
7 | import java.sql.ResultSetMetaData;
8 | import java.util.Collections;
9 | import java.util.LinkedHashMap;
10 | import java.util.Map;
11 |
12 | /**
13 | * A set of common mappers for convenience.
14 | * @see org.codejargon.fluentjdbc.api.mapper.ObjectMappers
15 | */
16 | public abstract class Mappers {
17 | private static final Mapper singleInteger = (rs) -> rs.getInt(1);
18 | private static final Mapper singleLong = (rs) -> rs.getLong(1);
19 | private static final Mapper singleString = (rs) -> rs.getString(1);
20 | private static final Mapper singleBigDecimal = (rs) -> rs.getBigDecimal(1);
21 | private static final Mapper singleBoolean = (rs) -> rs.getBoolean(1);
22 | private static final Mapper> map = rs -> {
23 | ResultSetMetaData meta = rs.getMetaData();
24 | Map result = new LinkedHashMap<>(meta.getColumnCount());
25 | for(int column = 1; column <= meta.getColumnCount(); ++column) {
26 | result.put(meta.getColumnLabel(column), rs.getObject(column));
27 | }
28 | return Collections.unmodifiableMap(result);
29 | };
30 | private static final Mapper singleByteArray = (rs) -> {
31 | Blob blob = rs.getBlob(1);
32 | return blob.getBytes(1, (int) blob.length());
33 | };
34 |
35 |
36 | /**
37 | * Maps the first Integer column.
38 | * @return first Integer column
39 | */
40 | public static Mapper singleInteger() {
41 | return singleInteger;
42 | }
43 |
44 | /**
45 | * Maps the first Long column.
46 | * @return first Long column
47 | */
48 | public static Mapper singleLong() {
49 | return singleLong;
50 | }
51 |
52 | /**
53 | * Maps the first string column
54 | * @return first string column
55 | */
56 | public static Mapper singleString() {
57 | return singleString;
58 | }
59 |
60 | /**
61 | * Maps the first BigDecimal column
62 | * @return first BigDecimal column
63 | */
64 | public static Mapper singleBigDecimal() {
65 | return singleBigDecimal;
66 | }
67 |
68 | /**
69 | * Maps the first Boolean column
70 | * @return first Boolean column
71 | */
72 | public static Mapper singleBoolean() {
73 | return singleBoolean;
74 | }
75 |
76 | /**
77 | *
78 | * @return
79 | */
80 | public static Mapper> map() {
81 | return map;
82 | }
83 |
84 | public static Mapper singleByteArray() {
85 | return singleByteArray;
86 | }
87 | }
88 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/api/mapper/ObjectMapperRsExtractor.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.api.mapper;
2 |
3 | import java.sql.ResultSet;
4 | import java.sql.SQLException;
5 |
6 | /**
7 | * Plug-in for supporting custom types in ObjectMappers
8 | * @see org.codejargon.fluentjdbc.api.mapper.ObjectMappers
9 | */
10 | @FunctionalInterface
11 | public interface ObjectMapperRsExtractor {
12 | /**
13 | * Extracts an object from a ResultSet and converts it to the object of target class.
14 | * @param resultSet ResultSet containing the current row.
15 | * @param index column index in the ResultSet
16 | * @return Object of the required class - nullable
17 | * @throws SQLException
18 | */
19 | T extract(ResultSet resultSet, Integer index) throws SQLException;
20 | }
21 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/api/mapper/ObjectMappers.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.api.mapper;
2 |
3 | import java.util.Collections;
4 | import java.util.HashMap;
5 | import java.util.Map;
6 | import java.util.concurrent.ConcurrentHashMap;
7 | import java.util.function.Function;
8 |
9 | import org.codejargon.fluentjdbc.internal.mappers.ObjectMapper;
10 | import org.codejargon.fluentjdbc.api.query.Mapper;
11 | import org.codejargon.fluentjdbc.internal.mappers.DefaultObjectMapperRsExtractors;
12 | import org.codejargon.fluentjdbc.internal.support.Maps;
13 |
14 | /**
15 | * Constructs Mappers for mapping a ResultSet row into a plain java object based on object field vs ResultSet column
16 | * match. Default matching is case insensitive and ignores '_' characters in database fields. The target class must have
17 | * a no-arg constructor, fields can be private, no need for accessors.
18 | *
19 | * In addition to JDBC types, supports java.time types out of the box. Able to support any custom type.
20 | *
21 | * @see org.codejargon.fluentjdbc.api.query.Mapper
22 | */
23 | public class ObjectMappers {
24 | private final Map extractors;
25 | private final Map> mappers;
26 | private final Function converter;
27 |
28 | private ObjectMappers(Map extractors, Function converter) {
29 | this.extractors = Maps.merge(DefaultObjectMapperRsExtractors.extractors(), extractors);
30 | this.converter = converter;
31 | mappers = new ConcurrentHashMap<>();
32 | }
33 |
34 | @SuppressWarnings("unchecked")
35 | public Mapper forClass(Class clazz) {
36 | return (Mapper) mappers.computeIfAbsent(clazz, c -> new ObjectMapper<>(c, extractors, converter));
37 | }
38 |
39 | public static Builder builder() {
40 | return new Builder();
41 | }
42 |
43 | public static class Builder {
44 | private Map extractors = Collections.emptyMap();
45 | private Function converter = f -> f.toLowerCase().replace("_", "");
46 | private Builder() {
47 |
48 | }
49 |
50 | /**
51 | * Sets extractors to support custom (non-JDBC) fields.
52 | * @param extractors Map of field class / ResultSet extractors
53 | * @return this
54 | */
55 | public Builder extractors(Map extractors) {
56 | this.extractors = Maps.copyOf(extractors);
57 | return this;
58 | }
59 |
60 | /**
61 | * Sets custom converter for object field to ResultSet column matching.
62 | * @param converter function to convert field names
63 | * @return this
64 | */
65 | public Builder fieldNameConverter(Function converter) {
66 | this.converter = converter;
67 | return this;
68 | }
69 |
70 | public ObjectMappers build() {
71 | return new ObjectMappers(Maps.copyOf(extractors), converter);
72 | }
73 | }
74 | }
75 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/api/query/BatchQuery.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.api.query;
2 |
3 | import java.util.Iterator;
4 | import java.util.List;
5 | import java.util.Map;
6 | import java.util.stream.Stream;
7 |
8 | /**
9 | * Batch insert or update query for a SQL statement. Is a mutable object.
10 | */
11 | public interface BatchQuery {
12 | /**
13 | *
14 | * @param params Parameters used by the batch update
15 | * @return this
16 | */
17 | BatchQuery params(Iterator> params);
18 |
19 | /**
20 | *
21 | * @param params Parameters used by the batch update
22 | * @return this
23 | */
24 | BatchQuery params(Iterable> params);
25 |
26 | /**
27 | *
28 | * @param params Parameters used by the batch update
29 | * @return this
30 | */
31 | BatchQuery params(Stream> params);
32 |
33 | /**
34 | *
35 | * @param params Parameters used by the batch update
36 | * @return this
37 | */
38 | BatchQuery namedParams(Iterator> params);
39 |
40 | /**
41 | *
42 | * @param params Parameters used by the batch update
43 | * @return this
44 | */
45 | BatchQuery namedParams(Iterable> params);
46 |
47 | /**
48 | *
49 | * @param params Parameters used by the batch update
50 | * @return this
51 | */
52 | BatchQuery namedParams(Stream> params);
53 |
54 | /**
55 | * Sets size of a batch (database roundtrip)
56 | * @param batchSize size of a batch
57 | * @return this
58 | */
59 | BatchQuery batchSize(Integer batchSize);
60 |
61 | /**
62 | * Sets a custom error handler
63 | *
64 | * @param sqlErrorHandler
65 | * @return this
66 | */
67 | BatchQuery errorHandler(SqlErrorHandler sqlErrorHandler);
68 |
69 | /**
70 | * Runs the batch insert or update and returns the results (eg affected rows)
71 | *
72 | * @return List of update results
73 | */
74 | List run();
75 |
76 | /**
77 | * Runs the batch insert or update and returns the results (eg affected rows)
78 | *
79 | * @return List of update results
80 | */
81 | List> runFetchGenKeys(Mapper generatedKeyMapper);
82 | }
83 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/api/query/Mapper.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.api.query;
2 |
3 | import java.sql.ResultSet;
4 | import java.sql.SQLException;
5 |
6 | /**
7 | * Maps a row of a ResultSet to an object
8 | * @param target class
9 | */
10 | @FunctionalInterface
11 | public interface Mapper {
12 | /**
13 | *
14 | * @param rs ResultSet containing data of a table row. ResultSet should not be mutated in a Mapper implementation.
15 | * @return result object
16 | * @throws SQLException a Mapper is allowed to throw SQLException for implementation convenience
17 | */
18 | T map(ResultSet rs) throws SQLException;
19 | }
20 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/api/query/PlainConnectionQuery.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.api.query;
2 |
3 | import java.sql.Connection;
4 | import java.sql.SQLException;
5 |
6 | @FunctionalInterface
7 | public interface PlainConnectionQuery {
8 | T operation(Connection con) throws SQLException;
9 | }
10 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/api/query/Query.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.api.query;
2 |
3 | import org.codejargon.fluentjdbc.api.query.inspection.DatabaseInspection;
4 |
5 | import java.sql.Connection;
6 | import java.sql.SQLException;
7 | import java.util.function.Function;
8 |
9 | /**
10 | * FluentJdbc Query API to create select, update/insert, and batch update/insert queries. Immutable, thread-safe.
11 | * @see org.codejargon.fluentjdbc.api.integration.ConnectionProvider
12 | */
13 | public interface Query {
14 | /**
15 | * Creates a select query for a SQL statement
16 | *
17 | * @param sql SQL statement
18 | * @return Select query for the SQL statement
19 | */
20 | SelectQuery select(String sql);
21 |
22 | /**
23 | * Creates an update or insert query for a SQL statement
24 | *
25 | * @param sql SQL statement
26 | * @return Update query for the SQL statement
27 | */
28 | UpdateQuery update(String sql);
29 |
30 | /**
31 | * Creates a batch update or insert query for a SQL statement
32 | *
33 | * @param sql SQL statement
34 | * @return Batch update or insert query for the SQL statement
35 | */
36 | BatchQuery batch(String sql);
37 |
38 | /**
39 | * Transaction control
40 | *
41 | * @return Transaction control
42 | */
43 | Transaction transaction();
44 |
45 | /**
46 | * Provides access to a JDBC Connection managed by FluentJdbc for low level operations
47 | *
48 | * @param plainConnectionQuery operation on a managed connection
49 | * @param type of return value
50 | * @return value
51 | */
52 | T plainConnection(PlainConnectionQuery plainConnectionQuery);
53 |
54 | /**
55 | * Inspection of the database (tables, columns, etc..)
56 | *
57 | * @return databaseInspection
58 | */
59 | DatabaseInspection databaseInspection();
60 | }
61 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/api/query/SelectQuery.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.api.query;
2 |
3 | import java.sql.ResultSet;
4 | import java.util.List;
5 | import java.util.Map;
6 | import java.util.Optional;
7 | import java.util.Set;
8 | import java.util.function.Consumer;
9 | import java.util.function.Predicate;
10 |
11 | /**
12 | * Select query for a SQL statement. A SelectQuery is mutable, non-threadsafe.
13 | */
14 | public interface SelectQuery {
15 | /**
16 | * Adds positional query parameters.
17 | *
18 | * @param params additional query parameters
19 | * @return this
20 | */
21 | SelectQuery params(List params);
22 |
23 | /**
24 | * Adds positional query parameters.
25 | *
26 | * @param params additional query parameters
27 | * @return this
28 | */
29 | SelectQuery params(Object... params);
30 |
31 | /**
32 | * Adds named query paramaters.
33 | *
34 | * @param namedParams additional named query parameters
35 | * @return this
36 | */
37 | SelectQuery namedParams(Map namedParams);
38 |
39 | /**
40 | * Adds a named query parameter
41 | *
42 | * @param name name of parameter
43 | * @param parameter value of parameter
44 | * @return this
45 | */
46 | SelectQuery namedParam(String name, Object parameter);
47 |
48 |
49 | /**
50 | * Sets a result filter. Only results accepted by this Predicate will be returned by SelectQuery.
51 | *
52 | * @param predicate filter
53 | * @param result type
54 | * @return this
55 | */
56 | SelectQuery filter(Predicate predicate);
57 |
58 | /**
59 | * Sets fetch size of select statements - the number of rows returned in a single network round-trip.
60 | * FluentJdbc configured default or vendor default is used if not set. Note that vendor defaults
61 | * may be different. Eg MySQL default is 0 (no limit) which may lead to memory issues, Oracle DB's default
62 | * is 10 which may result in poor performance with large ResultSets.
63 | * @param rows Number of rows fetched by a select statement.
64 | * @return this
65 | */
66 | SelectQuery fetchSize(Integer rows);
67 |
68 | /**
69 | * Limits the number of rows returned by the database for a select statement.
70 | * If rows < Integer.MAX_VALUE, JDBC driver must support setLargeMaxRows()
71 | * @param rows number of rows
72 | * @return this
73 | */
74 | SelectQuery maxRows(Long rows);
75 |
76 | /**
77 | * Sets a custom error handler
78 | *
79 | * @param sqlErrorHandler
80 | * @return this
81 | */
82 | SelectQuery errorHandler(SqlErrorHandler sqlErrorHandler);
83 |
84 | /**
85 | * Runs the select query and returns first result - if any
86 | *
87 | * @param mapper ResultSet mapper
88 | * @param result type
89 | * @return Optional of the result (if there is one)
90 | */
91 | Optional firstResult(Mapper mapper);
92 |
93 | /**
94 | * Runs the select query and returns a single result.
95 | *
96 | * @param mapper ResultSet mapper
97 | * @param result type
98 | * @return exactly one result
99 | * @throws org.codejargon.fluentjdbc.api.FluentJdbcException if no result found
100 | */
101 | T singleResult(Mapper mapper);
102 |
103 | /**
104 | * Runs the select query and returns results as an immutable list
105 | *
106 | * @param mapper ResultSet mapper
107 | * @param result type
108 | * @return immutable List of results
109 | */
110 | List listResult(Mapper mapper);
111 |
112 | /**
113 | * Runs the select query and returns results as an immutable set
114 | *
115 | * @param mapper ResultSet mapper
116 | * @param result type
117 | * @return immutable Set of results
118 | */
119 | Set setResult(Mapper mapper);
120 |
121 | /**
122 | * Runs the select query and provides resultset to the given consumer
123 | *
124 | * @param consumer Consumer accepting the ResultSet
125 | */
126 | void iterateResult(SqlConsumer consumer);
127 |
128 | /**
129 | * Runs the select query and provides results to the given consumer
130 | *
131 | * @param mapper ResultSet mapper
132 | * @param consumer Consumer accepting the results
133 | * @param result type
134 | */
135 | void iterateResult(Mapper mapper, Consumer consumer);
136 |
137 |
138 | }
139 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/api/query/SqlConsumer.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.api.query;
2 |
3 | import java.sql.SQLException;
4 |
5 | @FunctionalInterface
6 | public interface SqlConsumer {
7 | void accept(T t) throws SQLException;
8 | }
9 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/api/query/SqlErrorHandler.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.api.query;
2 |
3 | import java.sql.SQLException;
4 | import java.util.Optional;
5 |
6 | public interface SqlErrorHandler {
7 | enum Action {
8 | RETRY
9 | }
10 |
11 | /**
12 | * Handles SQL errors, may implement logging, etc. The handler should always rethrow an exception in case of
13 | * a critical error. Otherwise retry action can be triggered. The handler is responsible to implement
14 | * delay or limitations for the retry.
15 | *
16 | * @param e the error
17 | * @param sql The sql query. Always present unless the error was thrown by direct plainConnection() usage.
18 | * @return In case no exception is thrown, otherwise action needs to be returned ( eg retry ).
19 | */
20 | Action handle(SQLException e, Optional sql) throws SQLException;
21 | }
22 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/api/query/SqlErrorHandling.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.api.query;
2 |
3 | public interface SqlErrorHandling {
4 | T errorHandler();
5 | }
6 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/api/query/Transaction.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.api.query;
2 |
3 | import java.sql.Connection;
4 | import java.util.function.Supplier;
5 |
6 | public interface Transaction {
7 | /**
8 | * Specifies transaction isolation
9 | * @param isolation transaction isolation level - must be supported by the JDBC driver
10 | * @return this
11 | */
12 | Transaction isolation(Isolation isolation);
13 |
14 | /**
15 | * Runs the function in a transaction, returns a result.
16 | * @param operation the operation to be executed in a transaction, returns a result
17 | * @param type of result
18 | * @return result
19 | */
20 | T in(Supplier operation);
21 |
22 | /**
23 | * Runs the specified Runnable in a transaction. No return result.
24 | * @param runnable Will be executed in transaction.
25 | */
26 | void inNoResult(Runnable runnable);
27 |
28 | enum Isolation {
29 | NONE(Connection.TRANSACTION_NONE),
30 | READ_COMMITTED(Connection.TRANSACTION_READ_COMMITTED),
31 | READ_UNCOMMITTED(Connection.TRANSACTION_READ_UNCOMMITTED),
32 | REPEATABLE_READ(Connection.TRANSACTION_REPEATABLE_READ),
33 | SERIALIZABLE(Connection.TRANSACTION_SERIALIZABLE);
34 |
35 | private final Integer jdbcIsolation;
36 |
37 | Isolation(Integer jdbcIsolation) {
38 | this.jdbcIsolation = jdbcIsolation;
39 | }
40 |
41 | public Integer jdbcIsolation() {
42 | return jdbcIsolation;
43 | }
44 | }
45 | }
46 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/api/query/UpdateQuery.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.api.query;
2 |
3 | import java.util.List;
4 | import java.util.Map;
5 |
6 | /**
7 | * Update or insert Query for a SQL statement. An UpdateQuery is mutable.
8 | */
9 | public interface UpdateQuery {
10 | /**
11 | * Adds positional query parameters
12 | *
13 | * @param params additional query parameters
14 | * @return this
15 | */
16 | UpdateQuery params(List params);
17 |
18 | /**
19 | * Adds positional query parameters
20 | *
21 | * @param params additional query parameters
22 | * @return this
23 | */
24 | UpdateQuery params(Object... params);
25 |
26 | /**
27 | * Adds named query paramaters
28 | *
29 | * @param namedParams additional named query parameters
30 | * @return this
31 | */
32 | UpdateQuery namedParams(Map namedParams);
33 |
34 | /**
35 | * Adds a named query parameter
36 | *
37 | * @param name name of parameter
38 | * @param parameter value of parameter
39 | * @return this
40 | */
41 | UpdateQuery namedParam(String name, Object parameter);
42 |
43 | /**
44 | * Sets custom error handler
45 | *
46 | * @param sqlErrorHandler
47 | * @return this
48 | */
49 | UpdateQuery errorHandler(SqlErrorHandler sqlErrorHandler);
50 |
51 | /**
52 | * Runs the update query
53 | *
54 | * @return result of the update (eg affected rows)
55 | */
56 | UpdateResult run();
57 |
58 | /**
59 | * Runs the update query and fetches the generated keys
60 | *
61 | * @param generatedKeyMapper maps generated key(s) to an object
62 | * @param type of a single key or an object containing multiple keys
63 | * @return result of the update including generated keys
64 | */
65 | UpdateResultGenKeys runFetchGenKeys(Mapper generatedKeyMapper);
66 |
67 | /**
68 | * Runs the update query and fetches the generated keys
69 | *
70 | * @param generatedKeyMapper maps generated key(s) to an object
71 | * @param type of a single key or an object containing multiple keys
72 | * @param columns names of columns containing generated values. mandatory using some vendors, like oracle
73 | * @return result of the update including generated keys
74 | */
75 | UpdateResultGenKeys runFetchGenKeys(Mapper generatedKeyMapper, String[] columns);
76 |
77 | }
78 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/api/query/UpdateResult.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.api.query;
2 |
3 | /**
4 | * Results of an update / insert
5 | */
6 | public interface UpdateResult {
7 | long affectedRows();
8 | }
9 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/api/query/UpdateResultGenKeys.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.api.query;
2 |
3 | import java.util.List;
4 | import java.util.Optional;
5 |
6 | /**
7 | * Result of an update / insert including generated keys
8 | * @param Type of generated key(s) for a single row inserted
9 | */
10 | public interface UpdateResultGenKeys extends UpdateResult {
11 | /**
12 | * @return generated key(s) for each row inserted by the statement
13 | */
14 | List generatedKeys();
15 | Optional firstKey();
16 | }
17 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/api/query/inspection/DatabaseInspection.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.api.query.inspection;
2 |
3 | /**
4 | * Inspection of the Database schema
5 | */
6 | public interface DatabaseInspection {
7 | /**
8 | * Provides access to a DatabaseMetaData instance
9 | * @see java.sql.DatabaseMetaData
10 | *
11 | * @param access Callback with access to DatabaseMetaData
12 | * @param Return object type
13 | * @return Information extracted from DatabaseMetaData
14 | */
15 | T accessMetaData(MetaDataAccess access);
16 |
17 | /**
18 | * Selects from DatabaseMetaData - for methods returning a ResultSet
19 | * @see java.sql.DatabaseMetaData
20 | * @see java.sql.ResultSet
21 | *
22 | * @param select Function calling a method on DatabaseMetaData that returns ResultSet
23 | * @return MetaData select
24 | */
25 | MetaDataSelect selectFromMetaData(MetaDataResultSet select);
26 | }
27 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/api/query/inspection/MetaDataAccess.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.api.query.inspection;
2 |
3 | import java.sql.DatabaseMetaData;
4 | import java.sql.SQLException;
5 |
6 | @FunctionalInterface
7 | public interface MetaDataAccess {
8 | T access(DatabaseMetaData meta) throws SQLException;
9 | }
10 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/api/query/inspection/MetaDataResultSet.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.api.query.inspection;
2 |
3 |
4 | import java.sql.DatabaseMetaData;
5 | import java.sql.ResultSet;
6 | import java.sql.SQLException;
7 |
8 | @FunctionalInterface
9 | public interface MetaDataResultSet {
10 | ResultSet select(DatabaseMetaData metaData) throws SQLException;
11 | }
12 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/api/query/inspection/MetaDataSelect.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.api.query.inspection;
2 |
3 | import org.codejargon.fluentjdbc.api.query.Mapper;
4 |
5 | import java.util.List;
6 |
7 | public interface MetaDataSelect {
8 | /**
9 | * Provides results as a list
10 | *
11 | * @param mapper ResultSet mapper
12 | * @param Target object type
13 | * @return List of results
14 | */
15 | List listResult(Mapper mapper);
16 | }
17 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/api/query/listen/AfterQueryListener.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.api.query.listen;
2 |
3 | /**
4 | * This listener callback will be called after each SQL operation made through FluentJdbc.
5 | */
6 | @FunctionalInterface
7 | public interface AfterQueryListener {
8 | void listen(ExecutionDetails executionDetails);
9 | }
10 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/api/query/listen/ExecutionDetails.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.api.query.listen;
2 |
3 | import java.sql.SQLException;
4 | import java.util.Optional;
5 |
6 | public interface ExecutionDetails {
7 | Boolean success();
8 | String sql();
9 | Long executionTimeMs();
10 | Optional sqlException();
11 | }
12 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/internal/FluentJdbcInternal.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.internal;
2 |
3 | import org.codejargon.fluentjdbc.api.FluentJdbc;
4 | import org.codejargon.fluentjdbc.api.FluentJdbcException;
5 | import org.codejargon.fluentjdbc.api.ParamSetter;
6 | import org.codejargon.fluentjdbc.api.integration.ConnectionProvider;
7 | import org.codejargon.fluentjdbc.api.query.Query;
8 | import org.codejargon.fluentjdbc.api.query.Transaction;
9 | import org.codejargon.fluentjdbc.api.query.listen.AfterQueryListener;
10 | import org.codejargon.fluentjdbc.internal.query.QueryConfig;
11 | import org.codejargon.fluentjdbc.internal.query.QueryInternal;
12 |
13 | import java.sql.Connection;
14 | import java.util.Map;
15 | import java.util.Optional;
16 |
17 | public class FluentJdbcInternal implements FluentJdbc {
18 |
19 | private final Optional connectionProvider;
20 | private final QueryConfig queryConfig;
21 |
22 | public FluentJdbcInternal(
23 | Optional connectionProvider,
24 | QueryConfig queryConfig
25 | ) {
26 | this.connectionProvider = connectionProvider;
27 | this.queryConfig = queryConfig;
28 | }
29 |
30 | @Override
31 | public Query query() {
32 | if (!connectionProvider.isPresent()) {
33 | throw new FluentJdbcException("ConnectionProvider is not set.");
34 | }
35 | return new QueryInternal(connectionProvider.get(), queryConfig);
36 | }
37 |
38 |
39 |
40 | @Override
41 | public Query queryOn(Connection connection) {
42 | return new QueryInternal(
43 | query -> query.receive(connection),
44 | queryConfig
45 | );
46 | }
47 | }
48 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/internal/integration/QueryConnectionReceiverInternal.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.internal.integration;
2 |
3 | import org.codejargon.fluentjdbc.api.integration.QueryConnectionReceiver;
4 | import org.codejargon.fluentjdbc.internal.query.QueryRunnerConnection;
5 |
6 | import java.sql.Connection;
7 | import java.sql.SQLException;
8 |
9 | public class QueryConnectionReceiverInternal implements QueryConnectionReceiver {
10 | private final QueryRunnerConnection runner;
11 | private T returnValue;
12 |
13 | public QueryConnectionReceiverInternal(QueryRunnerConnection runner) {
14 | this.runner = runner;
15 | }
16 |
17 | @Override
18 | public void receive(Connection connection) throws SQLException {
19 | returnValue = runner.run(connection);
20 | }
21 |
22 | public T returnValue() {
23 | return returnValue;
24 | }
25 | }
26 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/internal/mappers/DefaultObjectMapperRsExtractors.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.internal.mappers;
2 |
3 | import java.math.BigDecimal;
4 | import java.nio.ByteBuffer;
5 | import java.sql.*;
6 | import java.time.Instant;
7 | import java.time.LocalDate;
8 | import java.time.LocalDateTime;
9 | import java.time.LocalTime;
10 | import java.time.Year;
11 | import java.time.YearMonth;
12 | import java.util.Collections;
13 | import java.util.HashMap;
14 | import java.util.Map;
15 |
16 | import org.codejargon.fluentjdbc.api.mapper.ObjectMapperRsExtractor;
17 |
18 | public class DefaultObjectMapperRsExtractors {
19 | private static boolean attemptBlobFree = true;
20 | private static final Map extractors;
21 |
22 | static {
23 | Map> exs = new HashMap<>();
24 | basicTypes(exs);
25 | javaDate(exs);
26 | javaTimeTypes(exs);
27 | binaryTypes(exs);
28 | extractors = Collections.unmodifiableMap(exs);
29 | }
30 |
31 | private static void javaDate(Map> exs) {
32 | reg(exs, java.util.Date.class, ResultSet::getTimestamp);
33 | }
34 |
35 | private static void javaTimeTypes(Map> exs) {
36 | reg(exs, LocalDate.class, (rs, i) -> {
37 | Date date = rs.getDate(i);
38 | return date != null ? date.toLocalDate() : null;
39 | });
40 | reg(exs, LocalDateTime.class, (rs, i) -> {
41 | Timestamp stamp = rs.getTimestamp(i);
42 | return stamp != null ? stamp.toLocalDateTime() : null;
43 | });
44 | reg(exs, LocalTime.class, (rs, i) -> {
45 | Time time = rs.getTime(i);
46 | return time != null ? time.toLocalTime() : null;
47 | });
48 | reg(exs, Year.class, (rs, i) -> {
49 | Date date = rs.getDate(i);
50 | return date != null ? Year.from(date.toLocalDate()) : null;
51 | });
52 | reg(exs, YearMonth.class, (rs, i) -> {
53 | Date date = rs.getDate(i);
54 | return date != null ? YearMonth.from(date.toLocalDate()) : null;
55 | });
56 | reg(exs, Instant.class, (rs, i) -> {
57 | Timestamp stamp = rs.getTimestamp(i);
58 | return stamp != null ? stamp.toInstant() : null;
59 | });
60 | }
61 |
62 | private static void basicTypes(Map> exs) {
63 | reg(exs, Boolean.class, ResultSet::getBoolean);
64 | reg(exs, boolean.class, ResultSet::getBoolean);
65 | reg(exs, Short.class, ResultSet::getShort);
66 | reg(exs, short.class, ResultSet::getShort);
67 | reg(exs, Integer.class, ResultSet::getInt);
68 | reg(exs, int.class, ResultSet::getInt);
69 | reg(exs, Long.class, ResultSet::getLong);
70 | reg(exs, long.class, ResultSet::getLong);
71 | reg(exs, Float.class, ResultSet::getFloat);
72 | reg(exs, float.class, ResultSet::getFloat);
73 | reg(exs, Double.class, ResultSet::getDouble);
74 | reg(exs, double.class, ResultSet::getDouble);
75 | reg(exs, BigDecimal.class, ResultSet::getBigDecimal);
76 | reg(exs, Timestamp.class, ResultSet::getTimestamp);
77 | reg(exs, Time.class, ResultSet::getTime);
78 | reg(exs, Date.class, ResultSet::getDate);
79 | reg(exs, String.class, ResultSet::getString);
80 | }
81 |
82 | private static void binaryTypes(Map> exs) {
83 | reg(exs, byte[].class, (rs, i) -> rs.getBytes(i));
84 |
85 | reg(exs, ByteBuffer.class, (rs, i) -> {
86 | Blob blob = rs.getBlob(i);
87 | if (blob == null) {
88 | return null;
89 | }
90 | ByteBuffer data = ByteBuffer.wrap(blob.getBytes(1, (int) blob.length()));
91 | freeBlob(blob);
92 | return data;
93 | });
94 | }
95 |
96 | private static void freeBlob(Blob blob) throws SQLException {
97 | if(attemptBlobFree) {
98 | try {
99 | blob.free();
100 | } catch (SQLFeatureNotSupportedException e) {
101 | attemptBlobFree = false;
102 | }
103 | }
104 | }
105 |
106 | public static Map extractors() {
107 | return extractors;
108 | }
109 |
110 | private static void reg(
111 | Map> exs,
112 | Class clazz,
113 | ObjectMapperRsExtractor extractor
114 | ) {
115 | exs.put(clazz, extractor);
116 | }
117 | }
118 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/internal/mappers/ObjectMapper.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.internal.mappers;
2 |
3 | import java.lang.reflect.Constructor;
4 | import java.lang.reflect.Field;
5 | import java.lang.reflect.InvocationTargetException;
6 | import java.lang.reflect.ParameterizedType;
7 | import java.sql.ResultSet;
8 | import java.sql.ResultSetMetaData;
9 | import java.sql.SQLException;
10 | import java.util.HashMap;
11 | import java.util.Map;
12 | import java.util.Optional;
13 | import java.util.concurrent.ConcurrentHashMap;
14 | import java.util.concurrent.ConcurrentMap;
15 | import java.util.function.Function;
16 |
17 | import org.codejargon.fluentjdbc.api.FluentJdbcException;
18 | import org.codejargon.fluentjdbc.api.mapper.ObjectMapperRsExtractor;
19 | import org.codejargon.fluentjdbc.api.query.Mapper;
20 | import org.codejargon.fluentjdbc.internal.support.Arrs;
21 | import org.codejargon.fluentjdbc.internal.support.Maps;
22 |
23 | public class ObjectMapper implements Mapper {
24 |
25 | private final Map extractors;
26 | private final Class type;
27 | private final Map fields;
28 | private final Constructor noargConstructor;
29 |
30 | private final Function converter;
31 | private final ConcurrentMap converterCache = new ConcurrentHashMap<>();
32 |
33 | public ObjectMapper(Class type, Map extractors, Function converter) {
34 | this.extractors = extractors;
35 | this.type = type;
36 | this.converter = converter;
37 | this.fields = discoverFields(type);
38 | noargConstructor = noargConstructor();
39 | }
40 |
41 | private String convert(String field){
42 | return converterCache.computeIfAbsent(field, converter);
43 | }
44 |
45 | private Map discoverFields(Class aType) throws SecurityException {
46 | Map allFields = new HashMap<>();
47 | Class inspectedClass = aType;
48 | while (inspectedClass != null) {
49 | Arrs.stream(inspectedClass.getDeclaredFields()).forEach(
50 | field -> {
51 | field.setAccessible(true);
52 | allFields.put(convert(field.getName()), field);
53 | }
54 | );
55 | inspectedClass = inspectedClass.getSuperclass();
56 | }
57 | return Maps.copyOf(allFields);
58 | }
59 |
60 | @Override
61 | public T map(ResultSet rs) throws SQLException {
62 | T result = newInstance();
63 | ResultSetMetaData metadata = rs.getMetaData();
64 | for (int i = 1; i <= metadata.getColumnCount(); ++i) {
65 | mapColumn(convert(metadata.getColumnLabel(i)), i, rs, result);
66 | }
67 | return result;
68 |
69 | }
70 |
71 | private void mapColumn(String fieldName, int i, ResultSet rs, T result) throws IllegalArgumentException, FluentJdbcException, SQLException {
72 | Field field = fields.get(fieldName);
73 | if (field != null) {
74 | Object value = value(typeOfField(field), rs, i);
75 | setField(field, result, value);
76 | }
77 | }
78 |
79 | private void setField(Field field, T result, Object value) {
80 | try {
81 | Object valueToBeSet = (field.getType().equals(Optional.class)) ?
82 | optionalOf(field, value) :
83 | value;
84 | field.set(result, valueToBeSet);
85 | } catch (IllegalAccessException e) {
86 | throw new FluentJdbcException(
87 | String.format(
88 | "Unable to set field %s in %s with value %s",
89 | field.getName(),
90 | field.getDeclaringClass(),
91 | value != null ? value.getClass().getName() : "null"
92 | ),
93 | e
94 | );
95 | }
96 | }
97 |
98 | private Object optionalOf(Field field, Object value) {
99 | if (value == null) {
100 | return Optional.empty();
101 | } else {
102 | Class typeOfField = typeOfField(field);
103 | if (!typeOfField.isAssignableFrom(value.getClass())) {
104 | throw new FluentJdbcException(String.format("Can't map value of class %s to Optional<%s>", value.getClass(), field));
105 | }
106 | return Optional.of(value);
107 | }
108 | }
109 |
110 | private Object value(Class fieldType, ResultSet rs, Integer index) throws SQLException {
111 | ObjectMapperRsExtractor converter = extractors.get(fieldType);
112 | Object value = converter != null ? converter.extract(rs, index) : rs.getObject(index);
113 | return (rs.wasNull() && !fieldType.isPrimitive()) ? null : value;
114 | }
115 |
116 | private T newInstance() throws IllegalArgumentException {
117 | try {
118 | return noargConstructor.newInstance();
119 | } catch (InstantiationException | IllegalAccessException | InvocationTargetException ex) {
120 | throw new FluentJdbcException(
121 | String.format("Cannot instantiate %s with the no-arg constructor", type.getName()),
122 | ex
123 | );
124 | }
125 | }
126 |
127 | private Constructor noargConstructor() {
128 | try {
129 | Constructor constructor = type.getDeclaredConstructor();
130 | constructor.setAccessible(true);
131 | return constructor;
132 | } catch (NoSuchMethodException ex) {
133 | throw new FluentJdbcException(
134 | String.format("Cannot find no-arg constructor in %s", type.getName()),
135 | ex
136 | );
137 | }
138 |
139 | }
140 |
141 | private Class typeOfField(Field field) {
142 | return field.getType().equals(Optional.class) ?
143 | (Class) ((ParameterizedType) field.getGenericType()).getActualTypeArguments()[0] :
144 | field.getType();
145 | }
146 | }
147 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/internal/query/DatabaseInspectionInternal.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.internal.query;
2 |
3 | import org.codejargon.fluentjdbc.api.query.inspection.DatabaseInspection;
4 | import org.codejargon.fluentjdbc.api.query.inspection.MetaDataAccess;
5 | import org.codejargon.fluentjdbc.api.query.inspection.MetaDataResultSet;
6 | import org.codejargon.fluentjdbc.api.query.inspection.MetaDataSelect;
7 |
8 | import java.util.Optional;
9 |
10 | class DatabaseInspectionInternal implements DatabaseInspection {
11 | private final QueryInternal query;
12 |
13 | DatabaseInspectionInternal(QueryInternal query) {
14 | this.query = query;
15 | }
16 |
17 | @Override
18 | public T accessMetaData(MetaDataAccess access) {
19 | return query.query(
20 | connection -> access.access(connection.getMetaData()),
21 | Optional.of("JDBC Database Inspection"),
22 | query.config.defaultSqlErrorHandler.get()
23 | );
24 | }
25 |
26 | @Override
27 | public MetaDataSelect selectFromMetaData(MetaDataResultSet select) {
28 | return new MetaDataSelectInternal(query, select);
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/internal/query/DefaultParamSetters.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.internal.query;
2 |
3 | import org.codejargon.fluentjdbc.api.ParamSetter;
4 |
5 | import java.time.*;
6 | import java.util.Collections;
7 | import java.util.Date;
8 | import java.util.HashMap;
9 | import java.util.Map;
10 |
11 | class DefaultParamSetters {
12 |
13 | private static final Map setters;
14 |
15 | static {
16 | Map ss = new HashMap<>();
17 | javaDate(ss);
18 | javaTime(ss);
19 | javaBinary(ss);
20 | setters = Collections.unmodifiableMap(ss);
21 | }
22 |
23 | private static void javaTime(Map ss) {
24 | reg(ss, Instant.class, (param, ps, i) -> ps.setTimestamp(i, timestamp(param)));
25 | reg(ss, OffsetDateTime.class, (param, ps, i) -> ps.setTimestamp(i, timestamp(param.toInstant())));
26 | reg(ss, ZonedDateTime.class, (param, ps, i) -> ps.setTimestamp(i, timestamp(param.toInstant())));
27 | reg(ss, LocalDate.class, (param, ps, i) -> ps.setDate(i, java.sql.Date.valueOf(param)));
28 | reg(ss, LocalTime.class, (param, ps, i) -> ps.setTime(i, java.sql.Time.valueOf(param)));
29 | reg(ss, LocalDateTime.class, (param, ps, i) -> ps.setTimestamp(i, java.sql.Timestamp.valueOf(param)));
30 | reg(ss, Year.class, (param, ps, i) -> ps.setDate(i, java.sql.Date.valueOf(LocalDate.of(param.getValue(), Month.JANUARY, 1))));
31 | reg(ss, YearMonth.class, (param, ps, i) -> ps.setDate(i, java.sql.Date.valueOf(LocalDate.of(param.getYear(), param.getMonth(), 1))));
32 | }
33 |
34 | private static void javaDate(Map ss) {
35 | reg(ss, Date.class, (param, ps, i) -> {
36 | ps.setTimestamp(i, new java.sql.Timestamp(param.getTime()));
37 | });
38 | }
39 |
40 | private static void javaBinary(Map ss) {
41 | reg(ss, byte[].class, (param, ps, i) -> ps.setBytes(i, param));
42 | }
43 |
44 | static Map setters() {
45 | return setters;
46 | }
47 |
48 | private static java.sql.Timestamp timestamp(Instant instant) {
49 | return java.sql.Timestamp.from(instant);
50 | }
51 |
52 | private static void reg(
53 | Map setters,
54 | Class clazz,
55 | ParamSetter setter
56 | ) {
57 | setters.put(clazz, setter);
58 | }
59 | }
60 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/internal/query/DefaultSqlHandler.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.internal.query;
2 |
3 | import org.codejargon.fluentjdbc.api.query.SqlErrorHandler;
4 |
5 | import java.sql.SQLException;
6 | import java.util.Optional;
7 |
8 | public class DefaultSqlHandler implements SqlErrorHandler {
9 | @Override
10 | public Action handle(SQLException e, Optional sql) throws SQLException {
11 | throw e;
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/internal/query/ExecutionDetailsInternal.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.internal.query;
2 |
3 | import org.codejargon.fluentjdbc.api.query.listen.ExecutionDetails;
4 |
5 | import java.sql.SQLException;
6 | import java.util.Optional;
7 |
8 | class ExecutionDetailsInternal implements ExecutionDetails {
9 | private final String sql;
10 | private final Long executionTimeMs;
11 | private final Optional sqlException;
12 |
13 | public ExecutionDetailsInternal(
14 | String sql,
15 | Long executionTimeMs,
16 | Optional sqlException) {
17 | this.sql = sql;
18 | this.executionTimeMs = executionTimeMs;
19 | this.sqlException = sqlException;
20 | }
21 |
22 | @Override
23 | public Boolean success() {
24 | return !sqlException.isPresent();
25 | }
26 |
27 | @Override
28 | public String sql() {
29 | return sql;
30 | }
31 |
32 | @Override
33 | public Long executionTimeMs() {
34 | return executionTimeMs;
35 | }
36 |
37 | @Override
38 | public Optional sqlException() {
39 | return sqlException;
40 | }
41 | }
42 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/internal/query/FetchGenKey.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.internal.query;
2 |
3 | import org.codejargon.fluentjdbc.api.FluentJdbcException;
4 | import org.codejargon.fluentjdbc.api.query.Mapper;
5 | import org.codejargon.fluentjdbc.api.query.UpdateResultGenKeys;
6 |
7 | import java.sql.PreparedStatement;
8 | import java.sql.ResultSet;
9 | import java.sql.SQLException;
10 | import java.util.*;
11 |
12 | class FetchGenKey {
13 | final Optional> mapper;
14 |
15 | static FetchGenKey no() {
16 | return new FetchGenKey(Optional.empty());
17 | }
18 |
19 | static FetchGenKey yes(Mapper mapper) {
20 | return new FetchGenKey(Optional.of(mapper));
21 | }
22 |
23 | private FetchGenKey(Optional> mapper) {
24 | this.mapper = mapper;
25 | }
26 |
27 | boolean fetch() {
28 | return mapper.isPresent();
29 | }
30 |
31 | UpdateResultGenKeys genKeys(PreparedStatement ps, Integer affected) throws SQLException {
32 | List keys = generatedKeys(ps);
33 | if(keys.size() != affected) {
34 | throw new FluentJdbcException("Can't fetch generated keys properly, does the jdbc driver support it?");
35 | }
36 | return new UpdateResultGenKeysInternal<>((long) affected, keys);
37 | }
38 |
39 | private List generatedKeys(PreparedStatement ps) throws SQLException {
40 | try (ResultSet keySet = ps.getGeneratedKeys()) {
41 | List keys = new ArrayList<>(1);
42 | while (keySet.next()) {
43 | keys.add(mapper.get().map(keySet));
44 | }
45 | return Collections.unmodifiableList(keys);
46 | }
47 | }
48 | }
49 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/internal/query/MetaDataSelectInternal.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.internal.query;
2 |
3 | import org.codejargon.fluentjdbc.api.query.Mapper;
4 | import org.codejargon.fluentjdbc.api.query.SqlErrorHandler;
5 | import org.codejargon.fluentjdbc.api.query.inspection.MetaDataResultSet;
6 | import org.codejargon.fluentjdbc.api.query.inspection.MetaDataSelect;
7 |
8 | import java.sql.ResultSet;
9 | import java.util.ArrayList;
10 | import java.util.List;
11 | import java.util.Optional;
12 |
13 | public class MetaDataSelectInternal implements MetaDataSelect {
14 | private final QueryInternal query;
15 | private final MetaDataResultSet select;
16 |
17 | public MetaDataSelectInternal(QueryInternal query, MetaDataResultSet select) {
18 | this.query = query;
19 | this.select = select;
20 | }
21 |
22 | @Override
23 | public List listResult(Mapper mapper) {
24 | return query.query(
25 | connection -> {
26 | List results = new ArrayList<>();
27 | try(ResultSet rs = select.select(connection.getMetaData())) {
28 | while(rs.next()) {
29 | results.add(mapper.map(rs));
30 | }
31 | }
32 | return results;
33 | },
34 | Optional.empty(),
35 | query.config.defaultSqlErrorHandler.get()
36 | );
37 | }
38 | }
39 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/internal/query/ParamAssigner.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.internal.query;
2 |
3 | import org.codejargon.fluentjdbc.api.FluentJdbcSqlException;
4 | import org.codejargon.fluentjdbc.api.ParamSetter;
5 |
6 | import java.sql.PreparedStatement;
7 | import java.sql.SQLException;
8 | import java.util.List;
9 | import java.util.Map;
10 | import java.util.Optional;
11 |
12 | class ParamAssigner {
13 | private volatile boolean trySqlTypeForNull = true;
14 |
15 | private static final ParamSetter fallbackParamSetter =
16 | (param, statement, index) -> {
17 | if (!param.getClass().isEnum()) {
18 | statement.setObject(index, param);
19 | } else {
20 | statement.setString(index, param.toString());
21 | }
22 | };
23 |
24 | private final Map paramSetters;
25 |
26 | ParamAssigner(Map paramSetters) {
27 | this.paramSetters = paramSetters;
28 | }
29 |
30 | void assignParams(PreparedStatement statement, List params) {
31 | int i = 1;
32 | for (Object param : params) {
33 | assignParam(
34 | statement,
35 | i,
36 | param instanceof Optional ? ((Optional) param).orElse(null) : param
37 | );
38 | ++i;
39 | }
40 | }
41 |
42 | private void assignParam(PreparedStatement statement, Integer index, Object param) {
43 | try {
44 | if (param != null) {
45 | assignNonNull(param, statement, index);
46 | } else {
47 | assignNull(statement, index);
48 | }
49 | } catch (SQLException e) {
50 | throw new FluentJdbcSqlException(String.format("Error assigning parameter index %s, object %s", index, param != null ? param.getClass().getName() : "null"), e);
51 | }
52 | }
53 |
54 | private void assignNull(PreparedStatement statement, Integer index) throws SQLException {
55 | Optional sqlType = sqlTypeForNull(statement, index);
56 | if(sqlType.isPresent()) {
57 | statement.setNull(index, sqlType.get());
58 | } else {
59 | statement.setObject(index, null);
60 | }
61 | }
62 |
63 | private Optional sqlTypeForNull(PreparedStatement statement, Integer index) {
64 | if(trySqlTypeForNull) {
65 | try {
66 | return Optional.of(statement.getParameterMetaData().getParameterType(index));
67 | } catch (SQLException e) {
68 | trySqlTypeForNull = false;
69 | return Optional.empty();
70 | }
71 | } else {
72 | return Optional.empty();
73 | }
74 | }
75 |
76 | @SuppressWarnings("unchecked")
77 | private void assignNonNull(Object param, PreparedStatement statement, Integer index) throws SQLException {
78 | paramSetter(param).set(param, statement, index);
79 | }
80 |
81 | private ParamSetter paramSetter(Object param) {
82 | ParamSetter customSetter = paramSetters.get(param.getClass());
83 | return customSetter != null ? customSetter : fallbackParamSetter;
84 | }
85 |
86 |
87 | }
88 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/internal/query/PreparedStatementFactory.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.internal.query;
2 |
3 | import java.sql.Connection;
4 | import java.sql.PreparedStatement;
5 | import java.sql.SQLException;
6 | import java.sql.Statement;
7 | import java.util.List;
8 |
9 | class PreparedStatementFactory {
10 | public static final String[] emptyGenColumns = new String[]{};
11 | private final QueryConfig config;
12 |
13 | PreparedStatementFactory(QueryConfig config) {
14 | this.config = config;
15 | }
16 |
17 | PreparedStatement createSingle(Connection con, SingleQueryBase singleQueryBase, boolean fetchGenerated, String[] genColumns) throws SQLException {
18 | SqlAndParams sqlAndParams = singleQueryBase.sqlAndParams(config);
19 | PreparedStatement statement = prepareStatement(con, sqlAndParams.sql(), fetchGenerated, genColumns);
20 | singleQueryBase.customizeQuery(statement, config);
21 | assignParams(statement, sqlAndParams.params());
22 | return statement;
23 | }
24 |
25 | PreparedStatement createBatch(Connection con, Boolean fetchGenerated, String sql) throws SQLException {
26 | return prepareStatement(con, sql, fetchGenerated, emptyGenColumns);
27 | }
28 |
29 | void assignParams(PreparedStatement statement, List params) throws SQLException {
30 | config.paramAssigner.assignParams(statement, params);
31 | }
32 |
33 | private PreparedStatement prepareStatement(Connection con, String sql, Boolean fetchGenerated, String[] genColumns) throws SQLException {
34 | return fetchGenerated ?
35 | (genColumns.length > 0 ?
36 | con.prepareStatement(sql, genColumns) :
37 | con.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)
38 | ) :
39 | con.prepareStatement(sql);
40 | }
41 |
42 |
43 |
44 |
45 | }
46 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/internal/query/QueryConfig.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.internal.query;
2 |
3 | import org.codejargon.fluentjdbc.api.ParamSetter;
4 | import org.codejargon.fluentjdbc.api.query.SqlErrorHandler;
5 | import org.codejargon.fluentjdbc.api.query.Transaction;
6 | import org.codejargon.fluentjdbc.api.query.listen.AfterQueryListener;
7 | import org.codejargon.fluentjdbc.internal.query.namedparameter.NamedTransformedSqlFactory;
8 | import org.codejargon.fluentjdbc.internal.support.Maps;
9 |
10 | import java.util.Map;
11 | import java.util.Optional;
12 | import java.util.function.Supplier;
13 |
14 | public class QueryConfig {
15 | final ParamAssigner paramAssigner;
16 |
17 | private final Optional defaultFetchSize;
18 | final Optional defaultBatchSize;
19 | final Optional afterQueryListener;
20 | final NamedTransformedSqlFactory namedTransformedSqlFactory;
21 | final Optional defaultTransactionIsolation;
22 | final Supplier defaultSqlErrorHandler;
23 |
24 | public QueryConfig(
25 | Optional defaultFetchSize,
26 | Optional defaultBatchSize,
27 | Map paramSetters,
28 | Optional afterQueryListener,
29 | Optional defaultTransactionIsolation,
30 | Supplier defaultSqlErrorHandler
31 | ) {
32 | this.paramAssigner = new ParamAssigner(
33 | Maps.merge(DefaultParamSetters.setters(), paramSetters)
34 | );
35 | this.namedTransformedSqlFactory = new NamedTransformedSqlFactory();
36 | this.defaultFetchSize = defaultFetchSize;
37 | this.defaultBatchSize = defaultBatchSize;
38 | this.afterQueryListener = afterQueryListener;
39 | this.defaultTransactionIsolation = defaultTransactionIsolation;
40 | this.defaultSqlErrorHandler = defaultSqlErrorHandler;
41 | }
42 |
43 |
44 | Optional fetchSize(Optional selectFetchSize) {
45 | return selectFetchSize.isPresent() ? selectFetchSize : defaultFetchSize;
46 | }
47 | }
48 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/internal/query/QueryInternal.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.internal.query;
2 |
3 | import org.codejargon.fluentjdbc.api.FluentJdbcException;
4 | import org.codejargon.fluentjdbc.api.FluentJdbcSqlException;
5 | import org.codejargon.fluentjdbc.api.integration.ConnectionProvider;
6 | import org.codejargon.fluentjdbc.api.query.*;
7 | import org.codejargon.fluentjdbc.api.query.inspection.DatabaseInspection;
8 | import org.codejargon.fluentjdbc.internal.integration.QueryConnectionReceiverInternal;
9 |
10 | import java.sql.Connection;
11 | import java.sql.PreparedStatement;
12 | import java.sql.SQLException;
13 | import java.util.List;
14 | import java.util.Optional;
15 | import java.util.function.Function;
16 |
17 | import static org.codejargon.fluentjdbc.internal.support.Preconditions.checkNotNull;
18 |
19 | public class QueryInternal implements Query {
20 |
21 | final ConnectionProvider connectionProvider;
22 | final QueryConfig config;
23 | final PreparedStatementFactory preparedStatementFactory;
24 |
25 | public QueryInternal(
26 | ConnectionProvider connectionProvider,
27 | QueryConfig config
28 | ) {
29 | this.connectionProvider = connectionProvider;
30 | this.config = config;
31 | preparedStatementFactory = new PreparedStatementFactory(config);
32 | }
33 |
34 | @Override
35 | public SelectQuery select(String sql) {
36 | return new SelectQueryInternal(sql, this);
37 | }
38 |
39 | @Override
40 | public UpdateQuery update(String sql) {
41 | return new UpdateQueryInternal(sql, this);
42 | }
43 |
44 | @Override
45 | public BatchQuery batch(String sql) {
46 | return new BatchQueryInternal(sql, this);
47 | }
48 |
49 | @Override
50 | public Transaction transaction() {
51 | return new TransactionInternal(this);
52 | }
53 |
54 |
55 | @Override
56 | public DatabaseInspection databaseInspection() {
57 | return new DatabaseInspectionInternal(this);
58 | }
59 |
60 | T query(QueryRunnerConnection runner, Optional sql, SqlErrorHandler sqlErrorHandler) {
61 | AttemptResult ret = new AttemptResult<>(null, false);
62 | while(!ret.success) {
63 | ret = attemptQuery(runner, sql, sqlErrorHandler);
64 | }
65 | return ret.result;
66 | }
67 |
68 | @Override
69 | public T plainConnection(PlainConnectionQuery plainConnectionQuery) {
70 | return query(plainConnectionQuery::operation, Optional.empty(), config.defaultSqlErrorHandler.get());
71 | }
72 |
73 | FluentJdbcException queryException(String sql, Optional reason, Optional e) {
74 | String message = String.format(
75 | "Error running query" + (reason.isPresent() ? ": " + reason.get() : "") + ", %s", sql
76 | );
77 | return e.isPresent() ? new FluentJdbcSqlException(message, e.get()) : new FluentJdbcException(message);
78 | }
79 |
80 | private AttemptResult attemptQuery(QueryRunnerConnection runner, Optional sql, SqlErrorHandler sqlErrorHandler) {
81 | long start = System.currentTimeMillis();
82 | try {
83 | T returnValue = doQuery(runner);
84 | listen(sql, start, Optional.empty());
85 | return new AttemptResult<>(returnValue, true);
86 | } catch (SQLException e) {
87 | handleError(sql, sqlErrorHandler, start, e);
88 | return new AttemptResult<>(null, false);
89 | }
90 | }
91 |
92 | private T doQuery(QueryRunnerConnection runner) throws SQLException {
93 | QueryConnectionReceiverInternal receiver = new QueryConnectionReceiverInternal<>(runner);
94 | Optional transactionedConnection = TransactionInternal.transactionedConnection(connectionProvider);
95 | if (!transactionedConnection.isPresent()) {
96 | connectionProvider.provide(receiver);
97 | } else {
98 | receiver.receive(transactionedConnection.get());
99 | }
100 | return receiver.returnValue();
101 | }
102 |
103 |
104 | void assignParams(PreparedStatement statement, List params) throws SQLException {
105 | preparedStatementFactory.assignParams(statement, params);
106 | }
107 |
108 | private void listen(Optional sql, long start, Optional e) {
109 | config.afterQueryListener.ifPresent(
110 | afterQueryListener ->
111 | sql.ifPresent(sqlQuery -> afterQueryListener.listen(
112 | new ExecutionDetailsInternal(sqlQuery, System.currentTimeMillis() - start, e)
113 | ))
114 | );
115 | }
116 |
117 | private void handleError(Optional sql, SqlErrorHandler sqlErrorHandler, long start, SQLException e) {
118 | try {
119 | checkNotNull(sqlErrorHandler.handle(e, sql), "Action in SqlErrorHandler");
120 | } catch(SQLException sqle) {
121 | listen(sql, start, Optional.of(e));
122 | throw queryException(sql.orElse(""), Optional.empty(), Optional.of(e));
123 | }
124 | }
125 |
126 | private static class AttemptResult {
127 | private final T result;
128 | private final Boolean success;
129 |
130 | public AttemptResult(T result, Boolean success) {
131 | this.result = result;
132 | this.success = success;
133 | }
134 | }
135 | }
136 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/internal/query/QueryRunnerConnection.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.internal.query;
2 |
3 | import java.sql.Connection;
4 | import java.sql.SQLException;
5 |
6 | @FunctionalInterface
7 | public interface QueryRunnerConnection {
8 | T run(Connection c) throws SQLException;
9 | }
10 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/internal/query/QueryRunnerPreparedStatement.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.internal.query;
2 |
3 | import java.sql.PreparedStatement;
4 | import java.sql.SQLException;
5 |
6 | @FunctionalInterface
7 | public interface QueryRunnerPreparedStatement {
8 | T run(PreparedStatement c) throws SQLException;
9 | }
10 |
--------------------------------------------------------------------------------
/fluent-jdbc/src/main/java/org/codejargon/fluentjdbc/internal/query/SelectQueryInternal.java:
--------------------------------------------------------------------------------
1 | package org.codejargon.fluentjdbc.internal.query;
2 |
3 | import org.codejargon.fluentjdbc.api.FluentJdbcException;
4 | import org.codejargon.fluentjdbc.api.query.Mapper;
5 | import org.codejargon.fluentjdbc.api.query.SelectQuery;
6 | import org.codejargon.fluentjdbc.api.query.SqlConsumer;
7 | import org.codejargon.fluentjdbc.api.query.SqlErrorHandler;
8 | import org.codejargon.fluentjdbc.internal.support.Predicates;
9 |
10 | import java.sql.PreparedStatement;
11 | import java.sql.ResultSet;
12 | import java.sql.SQLException;
13 | import java.util.*;
14 | import java.util.function.Consumer;
15 | import java.util.function.Predicate;
16 |
17 | import static java.util.Optional.empty;
18 | import static org.codejargon.fluentjdbc.internal.support.Preconditions.checkArgument;
19 | import static org.codejargon.fluentjdbc.internal.support.Preconditions.checkNotNull;
20 |
21 | class SelectQueryInternal extends SingleQueryBase implements SelectQuery {
22 |
23 | private Predicate filter = Predicates.alwaysTrue();
24 | private Optional fetchSize = empty();
25 | private Optional maxRows = empty();
26 |
27 | SelectQueryInternal(String sql, QueryInternal query) {
28 | super(query, sql);
29 | }
30 |
31 | @Override
32 | public SelectQuery filter(Predicate filter) {
33 | this.filter = filter;
34 | return this;
35 | }
36 |
37 | @Override
38 | public SelectQuery fetchSize(Integer rows) {
39 | checkNotNull(rows, "rows");
40 | checkArgument(rows >= 0, "Fetch size rows must be >= 0");
41 | this.fetchSize = Optional.of(rows);
42 | return this;
43 | }
44 |
45 | @Override
46 | public SelectQuery maxRows(Long rows) {
47 | checkNotNull(rows, "rows");
48 | checkArgument(rows >= 0, "Max results rows must be >= 0");
49 | this.maxRows = Optional.of(rows);
50 | return this;
51 | }
52 |
53 | @Override
54 | public SelectQuery params(List params) {
55 | addParameters(params);
56 | return this;
57 | }
58 |
59 | @Override
60 | public SelectQuery params(Object... params) {
61 | addParameters(params);
62 | return this;
63 | }
64 |
65 | @Override
66 | public SelectQuery namedParams(Map namedParams) {
67 | addNamedParameters(namedParams);
68 | return this;
69 | }
70 |
71 | @Override
72 | public SelectQuery namedParam(String name, Object parameter) {
73 | addNamedParameter(name, parameter);
74 | return this;
75 | }
76 |
77 | @Override
78 | public SelectQuery errorHandler(SqlErrorHandler sqlErrorHandler ) {
79 | this.sqlErrorHandler = () -> sqlErrorHandler;
80 | return this;
81 | }
82 |
83 |
84 | @Override
85 | @SuppressWarnings("unchecked")
86 | public Optional firstResult(Mapper mapper) {
87 | return runQuery(
88 | ps -> {
89 | try (ResultSet rs = ps.executeQuery()) {
90 | Optional result = empty();
91 | while (rs.next() && !result.isPresent()) {
92 | T candidate = mapper.map(rs);
93 | if (filter.test(candidate)) {
94 | result = Optional.of(candidate);
95 | }
96 | }
97 | return result;
98 | }
99 | },
100 | sqlErrorHandler.get());
101 | }
102 |
103 | @Override
104 | @SuppressWarnings("unchecked")
105 | public T singleResult(Mapper mapper) {
106 | Optional firstResult = firstResult(mapper);
107 | if (!firstResult.isPresent()) {
108 | throw query.queryException(sql, Optional.of("At least one result expected"), empty());
109 | }
110 | return firstResult.get();
111 | }
112 |
113 |
114 | @Override
115 | public List listResult(Mapper mapper) {
116 | List results = new ArrayList<>();
117 | iterateResult(mapper, results::add);
118 | return Collections.unmodifiableList(results);
119 | }
120 |
121 | @Override
122 | public Set setResult(Mapper mapper) {
123 | Set results = new HashSet<>();
124 | iterateResult(mapper, results::add);
125 | return Collections.unmodifiableSet(results);
126 | }
127 |
128 | @Override
129 | @SuppressWarnings("unchecked")
130 | public void iterateResult(Mapper mapper, Consumer