diff --git a/build.gradle.kts b/build.gradle.kts index afcf7764..d1d7e909 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -15,7 +15,7 @@ plugins { publishData { useEldoNexusRepos(false) - publishingVersion = "2.2.1" + publishingVersion = "2.2.2" } group = "de.chojo.sadu" diff --git a/sadu-mariadb/src/test/java/de/chojo/sadu/mapper/MariaDbMapperTest.java b/sadu-mariadb/src/test/java/de/chojo/sadu/mapper/MariaDbMapperTest.java index c020c696..f1c25273 100644 --- a/sadu-mariadb/src/test/java/de/chojo/sadu/mapper/MariaDbMapperTest.java +++ b/sadu-mariadb/src/test/java/de/chojo/sadu/mapper/MariaDbMapperTest.java @@ -9,8 +9,8 @@ import de.chojo.sadu.datasource.DataSourceCreator; import de.chojo.sadu.mariadb.databases.MariaDb; import de.chojo.sadu.mariadb.mapper.MariaDbMapper; +import de.chojo.sadu.queries.api.configuration.QueryConfiguration; import de.chojo.sadu.queries.api.query.Query; -import de.chojo.sadu.queries.configuration.QueryConfiguration; import org.intellij.lang.annotations.Language; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.Assertions; diff --git a/sadu-postgresql/src/test/java/de/chojo/sadu/mapper/PostgresqlMapperTest.java b/sadu-postgresql/src/test/java/de/chojo/sadu/mapper/PostgresqlMapperTest.java index 1214b0bd..c051b2c6 100644 --- a/sadu-postgresql/src/test/java/de/chojo/sadu/mapper/PostgresqlMapperTest.java +++ b/sadu-postgresql/src/test/java/de/chojo/sadu/mapper/PostgresqlMapperTest.java @@ -9,8 +9,8 @@ import de.chojo.sadu.datasource.DataSourceCreator; import de.chojo.sadu.postgresql.databases.PostgreSql; import de.chojo.sadu.postgresql.mapper.PostgresqlMapper; +import de.chojo.sadu.queries.api.configuration.QueryConfiguration; import de.chojo.sadu.queries.api.query.Query; -import de.chojo.sadu.queries.configuration.QueryConfiguration; import org.intellij.lang.annotations.Language; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.Assertions; diff --git a/sadu-queries/src/main/java/de/chojo/sadu/queries/api/base/QueryProvider.java b/sadu-queries/src/main/java/de/chojo/sadu/queries/api/base/QueryProvider.java index 7c8e6116..9f4c46a7 100644 --- a/sadu-queries/src/main/java/de/chojo/sadu/queries/api/base/QueryProvider.java +++ b/sadu-queries/src/main/java/de/chojo/sadu/queries/api/base/QueryProvider.java @@ -8,7 +8,7 @@ import de.chojo.sadu.core.base.DataSourceProvider; import de.chojo.sadu.core.exceptions.ThrowingFunction; -import de.chojo.sadu.queries.configuration.QueryConfiguration; +import de.chojo.sadu.queries.api.configuration.QueryConfiguration; import de.chojo.sadu.queries.query.QueryImpl; import javax.sql.DataSource; diff --git a/sadu-queries/src/main/java/de/chojo/sadu/queries/api/configuration/ActiveQueryConfiguration.java b/sadu-queries/src/main/java/de/chojo/sadu/queries/api/configuration/ActiveQueryConfiguration.java new file mode 100644 index 00000000..1d5f5824 --- /dev/null +++ b/sadu-queries/src/main/java/de/chojo/sadu/queries/api/configuration/ActiveQueryConfiguration.java @@ -0,0 +1,23 @@ +/* + * SPDX-License-Identifier: LGPL-3.0-or-later + * + * Copyright (C) RainbowDashLabs and Contributor + */ + +package de.chojo.sadu.queries.api.configuration; + +import de.chojo.sadu.queries.api.configuration.context.QueryContext; + +import java.sql.SQLException; + +public interface ActiveQueryConfiguration extends QueryConfiguration { + /** + * Handles a SQLException by invoking the exceptionHandler consumer, logging the exception, + * and potentially throwing a WrappedQueryExecutionException. + * + * @param e the SQLException to handle + */ + void handleException(SQLException e); + + QueryContext context(); +} diff --git a/sadu-queries/src/main/java/de/chojo/sadu/queries/api/configuration/ConnectedQueryConfiguration.java b/sadu-queries/src/main/java/de/chojo/sadu/queries/api/configuration/ConnectedQueryConfiguration.java new file mode 100644 index 00000000..647074a5 --- /dev/null +++ b/sadu-queries/src/main/java/de/chojo/sadu/queries/api/configuration/ConnectedQueryConfiguration.java @@ -0,0 +1,13 @@ +/* + * SPDX-License-Identifier: LGPL-3.0-or-later + * + * Copyright (C) RainbowDashLabs and Contributor + */ + +package de.chojo.sadu.queries.api.configuration; + +import java.sql.Connection; + +public interface ConnectedQueryConfiguration extends ActiveQueryConfiguration, AutoCloseable { + Connection connection(); +} diff --git a/sadu-queries/src/main/java/de/chojo/sadu/queries/api/configuration/QueryConfiguration.java b/sadu-queries/src/main/java/de/chojo/sadu/queries/api/configuration/QueryConfiguration.java new file mode 100644 index 00000000..d364bce0 --- /dev/null +++ b/sadu-queries/src/main/java/de/chojo/sadu/queries/api/configuration/QueryConfiguration.java @@ -0,0 +1,104 @@ +/* + * SPDX-License-Identifier: LGPL-3.0-or-later + * + * Copyright (C) RainbowDashLabs and Contributor + */ + +package de.chojo.sadu.queries.api.configuration; + +import de.chojo.sadu.mapper.RowMapperRegistry; +import de.chojo.sadu.queries.api.query.ParsedQuery; +import de.chojo.sadu.queries.configuration.ConnectedQueryConfigurationImpl; +import de.chojo.sadu.queries.configuration.QueryConfigurationBuilder; +import de.chojo.sadu.queries.api.configuration.context.QueryContext; +import org.intellij.lang.annotations.Language; + +import javax.sql.DataSource; +import java.util.Objects; +import java.util.concurrent.atomic.AtomicReference; + +@SuppressWarnings("removal") +public interface QueryConfiguration extends de.chojo.sadu.queries.configuration.QueryConfiguration{ + AtomicReference DEFAULT = new AtomicReference<>(null); + + /** + * Retrieves the default QueryConfiguration. + * + * @return the default QueryConfiguration + */ + static QueryConfiguration getDefault() { + return Objects.requireNonNull(DEFAULT.get(), "You need to configure the configuration first by calling QueryConfiguration.setDefault()"); + } + + /** + * Sets the default query configuration. + * + * @param configuration the query configuration to set as default + */ + static void setDefault(QueryConfiguration configuration) { + DEFAULT.set(configuration); + } + + /** + * Creates a new QueryConfigurationBuilder instance with the given DataSource. + * + * @param source the DataSource to use for QueryConfiguration + * @return a QueryConfigurationBuilder instance + */ + static QueryConfigurationBuilder builder(DataSource source) { + return new QueryConfigurationBuilder(source); + } + + /** + * Returns a new QueryConfiguration object with the provided query and other configuration settings. + * + * @param context the query to be associated with the configuration + * @return the new QueryConfiguration object + */ + ActiveQueryConfiguration forQuery(QueryContext context); + + /** + * Retrieves the value of the atomic flag. + * + * @return {@code true} if atomic flag is set; {@code false} otherwise. + */ + boolean atomic(); + + /** + * Retrieves the value of the throwExceptions field. + * + * @return the value of the throwExceptions field + */ + boolean throwExceptions(); + + /** + * Retrieves the {@link RowMapperRegistry} object from the QueryConfiguration. + * + * @return The {@link RowMapperRegistry} object from the QueryConfiguration. + */ + RowMapperRegistry rowMapperRegistry(); + + /** + * Returns the DataSource object associated with this QueryConfiguration. + * + * @return the DataSource object + */ + DataSource dataSource(); + + /** + * Executes a SQL query with the given SQL statement and format arguments. + * + * @param sql the SQL statement to be executed + * @param format the format arguments to be applied to the SQL statement + * @return a parsed query ready for execution + */ + ParsedQuery query(@Language("sql") String sql, Object... format); + + /** + * Returns a new instance of the ConnectedQueryConfiguration class with the "single transaction" configuration applied. + * This means that a single transaction will be used for the queries executed using this configuration. + * + * @return A new instance of the ConnectedQueryConfiguration class with the "single transaction" configuration applied. + */ + ConnectedQueryConfigurationImpl withSingleTransaction(); +} diff --git a/sadu-queries/src/main/java/de/chojo/sadu/queries/api/configuration/context/QueryContext.java b/sadu-queries/src/main/java/de/chojo/sadu/queries/api/configuration/context/QueryContext.java new file mode 100644 index 00000000..c1ff71be --- /dev/null +++ b/sadu-queries/src/main/java/de/chojo/sadu/queries/api/configuration/context/QueryContext.java @@ -0,0 +1,12 @@ +/* + * SPDX-License-Identifier: LGPL-3.0-or-later + * + * Copyright (C) RainbowDashLabs and Contributor + */ + +package de.chojo.sadu.queries.api.configuration.context; + +import de.chojo.sadu.queries.api.exception.ExceptionHolder; + +public interface QueryContext extends ExceptionHolder { +} diff --git a/sadu-queries/src/main/java/de/chojo/sadu/queries/api/exception/ExceptionHolder.java b/sadu-queries/src/main/java/de/chojo/sadu/queries/api/exception/ExceptionHolder.java new file mode 100644 index 00000000..10a894d0 --- /dev/null +++ b/sadu-queries/src/main/java/de/chojo/sadu/queries/api/exception/ExceptionHolder.java @@ -0,0 +1,15 @@ +/* + * SPDX-License-Identifier: LGPL-3.0-or-later + * + * Copyright (C) RainbowDashLabs and Contributor + */ + +package de.chojo.sadu.queries.api.exception; + +import java.util.List; + +public interface ExceptionHolder { + List exceptions(); + + void logException(Exception e); +} diff --git a/sadu-queries/src/main/java/de/chojo/sadu/queries/api/query/Query.java b/sadu-queries/src/main/java/de/chojo/sadu/queries/api/query/Query.java index c3920d1d..7ce2a578 100644 --- a/sadu-queries/src/main/java/de/chojo/sadu/queries/api/query/Query.java +++ b/sadu-queries/src/main/java/de/chojo/sadu/queries/api/query/Query.java @@ -6,7 +6,7 @@ package de.chojo.sadu.queries.api.query; -import de.chojo.sadu.queries.configuration.QueryConfiguration; +import de.chojo.sadu.queries.api.configuration.QueryConfiguration; import de.chojo.sadu.queries.query.ParsedQueryImpl; import de.chojo.sadu.queries.query.QueryImpl; import org.intellij.lang.annotations.Language; diff --git a/sadu-queries/src/main/java/de/chojo/sadu/queries/configuration/ActiveQueryConfigurationImpl.java b/sadu-queries/src/main/java/de/chojo/sadu/queries/configuration/ActiveQueryConfigurationImpl.java new file mode 100644 index 00000000..44ba70aa --- /dev/null +++ b/sadu-queries/src/main/java/de/chojo/sadu/queries/configuration/ActiveQueryConfigurationImpl.java @@ -0,0 +1,39 @@ +/* + * SPDX-License-Identifier: LGPL-3.0-or-later + * + * Copyright (C) RainbowDashLabs and Contributor + */ + +package de.chojo.sadu.queries.configuration; + +import de.chojo.sadu.mapper.RowMapperRegistry; +import de.chojo.sadu.queries.api.configuration.ActiveQueryConfiguration; +import de.chojo.sadu.queries.api.configuration.context.QueryContext; +import de.chojo.sadu.queries.exception.WrappedQueryExecutionException; +import org.jetbrains.annotations.NotNull; + +import javax.sql.DataSource; +import java.sql.SQLException; +import java.util.function.Consumer; + +public class ActiveQueryConfigurationImpl extends QueryConfigurationImpl implements ActiveQueryConfiguration { + protected final @NotNull QueryContext context; + + public ActiveQueryConfigurationImpl(@NotNull DataSource dataSource, boolean atomic, boolean throwExceptions, Consumer exceptionHandler, RowMapperRegistry rowMapperRegistry, @NotNull QueryContext context) { + super(dataSource, atomic, throwExceptions, exceptionHandler, rowMapperRegistry); + this.context = context; + } + + @Override + public void handleException(SQLException e) { + exceptionHandler.accept(e); + context.logException(e); + if (throwExceptions) { + throw (WrappedQueryExecutionException) new WrappedQueryExecutionException(e.getMessage()).initCause(e); + } + } + + public @NotNull QueryContext context() { + return context; + } +} diff --git a/sadu-queries/src/main/java/de/chojo/sadu/queries/configuration/ConnectedQueryConfiguration.java b/sadu-queries/src/main/java/de/chojo/sadu/queries/configuration/ConnectedQueryConfiguration.java deleted file mode 100644 index bf8f4653..00000000 --- a/sadu-queries/src/main/java/de/chojo/sadu/queries/configuration/ConnectedQueryConfiguration.java +++ /dev/null @@ -1,58 +0,0 @@ -/* - * SPDX-License-Identifier: LGPL-3.0-or-later - * - * Copyright (C) RainbowDashLabs and Contributor - */ - -package de.chojo.sadu.queries.configuration; - -import de.chojo.sadu.mapper.RowMapperRegistry; -import de.chojo.sadu.queries.exception.WrappedQueryExecutionException; -import de.chojo.sadu.queries.query.QueryImpl; - -import javax.sql.DataSource; -import java.sql.Connection; -import java.sql.SQLException; -import java.util.function.Consumer; - -public class ConnectedQueryConfiguration extends QueryConfiguration implements AutoCloseable { - private Connection connection = null; - - ConnectedQueryConfiguration(QueryImpl query, DataSource dataSource, boolean atomic, boolean throwExceptions, Consumer exceptionHandler, RowMapperRegistry rowMapperRegistry) { - super(query, dataSource, atomic, throwExceptions, exceptionHandler, rowMapperRegistry); - } - - public ConnectedQueryConfiguration forQuery(QueryImpl query) { - return new ConnectedQueryConfiguration(query, dataSource, atomic, throwExceptions, exceptionHandler, rowMapperRegistry); - } - - @Override - public void close() { - try { - if (connection != null && !connection.isClosed()) { - //noinspection DataFlowIssue - if (query.exceptions().isEmpty()) { - if (atomic()) { - connection.commit(); - } - } - connection.close(); - } - } catch (SQLException e) { - handleException(e); - } - } - - public Connection connection() { - if (connection == null) { - try { - connection = dataSource.getConnection(); - connection.setAutoCommit(!atomic); - } catch (SQLException e) { - handleException(e); - throw (WrappedQueryExecutionException) new WrappedQueryExecutionException(e.getMessage()).initCause(e); - } - } - return connection; - } -} diff --git a/sadu-queries/src/main/java/de/chojo/sadu/queries/configuration/ConnectedQueryConfigurationImpl.java b/sadu-queries/src/main/java/de/chojo/sadu/queries/configuration/ConnectedQueryConfigurationImpl.java new file mode 100644 index 00000000..a2db8e7b --- /dev/null +++ b/sadu-queries/src/main/java/de/chojo/sadu/queries/configuration/ConnectedQueryConfigurationImpl.java @@ -0,0 +1,61 @@ +/* + * SPDX-License-Identifier: LGPL-3.0-or-later + * + * Copyright (C) RainbowDashLabs and Contributor + */ + +package de.chojo.sadu.queries.configuration; + +import de.chojo.sadu.mapper.RowMapperRegistry; +import de.chojo.sadu.queries.api.configuration.ConnectedQueryConfiguration; +import de.chojo.sadu.queries.api.configuration.context.QueryContext; +import de.chojo.sadu.queries.exception.WrappedQueryExecutionException; +import org.jetbrains.annotations.Nullable; + +import javax.sql.DataSource; +import java.sql.Connection; +import java.sql.SQLException; +import java.util.function.Consumer; + +public class ConnectedQueryConfigurationImpl extends ActiveQueryConfigurationImpl implements ConnectedQueryConfiguration { + private Connection connection; + + ConnectedQueryConfigurationImpl(QueryContext context, DataSource dataSource, @Nullable Connection connection, boolean atomic, boolean throwExceptions, Consumer exceptionHandler, RowMapperRegistry rowMapperRegistry) { + super(dataSource, atomic, throwExceptions, exceptionHandler, rowMapperRegistry, context); + this.connection = connection; + } + + @Override + public ConnectedQueryQueryConfigurationDelegate forQuery(QueryContext context) { + // TODO: Maybe store the different query instances from the context in the future. + return new ConnectedQueryQueryConfigurationDelegate(this); + } + + @Override + public void close() { + if (connection == null) return; + try (var conn = connection) { + if (context.exceptions().isEmpty()) { + if (atomic()) { + conn.commit(); + } + } + } catch (SQLException e) { + handleException(e); + } + } + + @Override + public Connection connection() { + if (connection == null) { + try { + connection = dataSource.getConnection(); + connection.setAutoCommit(!atomic); + } catch (SQLException e) { + handleException(e); + throw (WrappedQueryExecutionException) new WrappedQueryExecutionException(e.getMessage()).initCause(e); + } + } + return connection; + } +} diff --git a/sadu-queries/src/main/java/de/chojo/sadu/queries/configuration/ConnectedQueryQueryConfigurationDelegate.java b/sadu-queries/src/main/java/de/chojo/sadu/queries/configuration/ConnectedQueryQueryConfigurationDelegate.java new file mode 100644 index 00000000..d0081ba1 --- /dev/null +++ b/sadu-queries/src/main/java/de/chojo/sadu/queries/configuration/ConnectedQueryQueryConfigurationDelegate.java @@ -0,0 +1,79 @@ +/* + * SPDX-License-Identifier: LGPL-3.0-or-later + * + * Copyright (C) RainbowDashLabs and Contributor + */ + +package de.chojo.sadu.queries.configuration; + +import de.chojo.sadu.mapper.RowMapperRegistry; +import de.chojo.sadu.queries.api.configuration.ConnectedQueryConfiguration; +import de.chojo.sadu.queries.api.query.ParsedQuery; +import de.chojo.sadu.queries.api.configuration.context.QueryContext; + +import javax.sql.DataSource; +import java.sql.Connection; +import java.sql.SQLException; + +public class ConnectedQueryQueryConfigurationDelegate implements ConnectedQueryConfiguration { + private final ConnectedQueryConfigurationImpl configuration; + + ConnectedQueryQueryConfigurationDelegate(ConnectedQueryConfigurationImpl configuration) { + this.configuration = configuration; + } + + @Override + public Connection connection() { + return configuration.connection(); + } + + @Override + public void close() { + configuration.close(); + } + + @Override + public ConnectedQueryQueryConfigurationDelegate forQuery(QueryContext exceptionHolder) { + return configuration.forQuery(exceptionHolder); + } + + @Override + public ParsedQuery query(String sql, Object... format) { + return configuration.query(sql, format); + } + + @Override + public DataSource dataSource() { + return configuration.dataSource(); + } + + @Override + public RowMapperRegistry rowMapperRegistry() { + return configuration.rowMapperRegistry(); + } + + @Override + public boolean throwExceptions() { + return configuration.throwExceptions(); + } + + @Override + public boolean atomic() { + return configuration.atomic(); + } + + @Override + public void handleException(SQLException e) { + configuration.handleException(e); + } + + @Override + public QueryContext context() { + return configuration.context(); + } + + @Override + public ConnectedQueryConfigurationImpl withSingleTransaction() { + return configuration.withSingleTransaction(); + } +} diff --git a/sadu-queries/src/main/java/de/chojo/sadu/queries/configuration/QueryConfiguration.java b/sadu-queries/src/main/java/de/chojo/sadu/queries/configuration/QueryConfiguration.java index 5c569e35..2d92b645 100644 --- a/sadu-queries/src/main/java/de/chojo/sadu/queries/configuration/QueryConfiguration.java +++ b/sadu-queries/src/main/java/de/chojo/sadu/queries/configuration/QueryConfiguration.java @@ -7,53 +7,26 @@ package de.chojo.sadu.queries.configuration; import de.chojo.sadu.mapper.RowMapperRegistry; +import de.chojo.sadu.queries.api.configuration.ActiveQueryConfiguration; import de.chojo.sadu.queries.api.query.ParsedQuery; -import de.chojo.sadu.queries.api.query.Query; -import de.chojo.sadu.queries.exception.WrappedQueryExecutionException; -import de.chojo.sadu.queries.query.QueryImpl; +import de.chojo.sadu.queries.api.configuration.context.QueryContext; import org.intellij.lang.annotations.Language; -import org.jetbrains.annotations.NotNull; import javax.sql.DataSource; -import java.sql.SQLException; import java.util.Objects; -import java.util.concurrent.atomic.AtomicReference; -import java.util.function.Consumer; - -public class QueryConfiguration { - static final AtomicReference DEFAULT = new AtomicReference<>(null); - protected final QueryImpl query; - protected final @NotNull DataSource dataSource; - protected final boolean atomic; - protected final boolean throwExceptions; - protected final Consumer exceptionHandler; - protected final RowMapperRegistry rowMapperRegistry; - - QueryConfiguration(@NotNull DataSource dataSource, boolean atomic, boolean throwExceptions, Consumer exceptionHandler, RowMapperRegistry rowMapperRegistry) { - query = null; - this.dataSource = dataSource; - this.atomic = atomic; - this.throwExceptions = throwExceptions; - this.exceptionHandler = exceptionHandler; - this.rowMapperRegistry = rowMapperRegistry; - } - - QueryConfiguration(QueryImpl query, @NotNull DataSource dataSource, boolean atomic, boolean throwExceptions, Consumer exceptionHandler, RowMapperRegistry rowMapperRegistry) { - this.query = query; - this.dataSource = dataSource; - this.atomic = atomic; - this.throwExceptions = throwExceptions; - this.exceptionHandler = exceptionHandler; - this.rowMapperRegistry = rowMapperRegistry; - } +/** + * Replaced by equal interface at {@link de.chojo.sadu.queries.api.configuration.QueryConfiguration} + */ +@Deprecated(forRemoval = true) +public interface QueryConfiguration { /** * Retrieves the default QueryConfiguration. * * @return the default QueryConfiguration */ - public static QueryConfiguration getDefault() { - return Objects.requireNonNull(DEFAULT.get(), "You need to configure the configuration first by calling QueryConfiguration.setDefault()"); + static de.chojo.sadu.queries.api.configuration.QueryConfiguration getDefault() { + return Objects.requireNonNull(de.chojo.sadu.queries.api.configuration.QueryConfiguration.DEFAULT.get(), "You need to configure the configuration first by calling QueryConfiguration.setDefault()"); } /** @@ -61,8 +34,8 @@ public static QueryConfiguration getDefault() { * * @param configuration the query configuration to set as default */ - public static void setDefault(QueryConfiguration configuration) { - DEFAULT.set(configuration); + static void setDefault(de.chojo.sadu.queries.api.configuration.QueryConfiguration configuration) { + de.chojo.sadu.queries.api.configuration.QueryConfiguration.DEFAULT.set(configuration); } /** @@ -71,70 +44,45 @@ public static void setDefault(QueryConfiguration configuration) { * @param source the DataSource to use for QueryConfiguration * @return a QueryConfigurationBuilder instance */ - public static QueryConfigurationBuilder builder(DataSource source) { + static QueryConfigurationBuilder builder(DataSource source) { return new QueryConfigurationBuilder(source); } /** * Returns a new QueryConfiguration object with the provided query and other configuration settings. * - * @param query the query to be associated with the configuration + * @param context the query to be associated with the configuration * @return the new QueryConfiguration object */ - public QueryConfiguration forQuery(QueryImpl query) { - return new QueryConfiguration(query, dataSource, atomic, throwExceptions, exceptionHandler, rowMapperRegistry); - } - - /** - * Handles a SQLException by invoking the exceptionHandler consumer, logging the exception, - * and potentially throwing a WrappedQueryExecutionException. - * - * @param e the SQLException to handle - */ - public void handleException(SQLException e) { - exceptionHandler.accept(e); - //noinspection DataFlowIssue - query.logException(e); - if (throwExceptions) { - throw (WrappedQueryExecutionException) new WrappedQueryExecutionException(e.getMessage()).initCause(e); - } - } + ActiveQueryConfiguration forQuery(QueryContext context); /** * Retrieves the value of the atomic flag. * * @return {@code true} if atomic flag is set; {@code false} otherwise. */ - public boolean atomic() { - return atomic; - } + boolean atomic(); /** * Retrieves the value of the throwExceptions field. * * @return the value of the throwExceptions field */ - public boolean throwExceptions() { - return throwExceptions; - } + boolean throwExceptions(); /** * Retrieves the {@link RowMapperRegistry} object from the QueryConfiguration. * * @return The {@link RowMapperRegistry} object from the QueryConfiguration. */ - public RowMapperRegistry rowMapperRegistry() { - return rowMapperRegistry; - } + RowMapperRegistry rowMapperRegistry(); /** * Returns the DataSource object associated with this QueryConfiguration. * * @return the DataSource object */ - public DataSource dataSource() { - return dataSource; - } + DataSource dataSource(); /** * Executes a SQL query with the given SQL statement and format arguments. @@ -143,9 +91,7 @@ public DataSource dataSource() { * @param format the format arguments to be applied to the SQL statement * @return a parsed query ready for execution */ - public ParsedQuery query(@Language("sql") String sql, Object... format) { - return Query.query(this, sql, format); - } + ParsedQuery query(@Language("sql") String sql, Object... format); /** * Returns a new instance of the ConnectedQueryConfiguration class with the "single transaction" configuration applied. @@ -153,7 +99,5 @@ public ParsedQuery query(@Language("sql") String sql, Object... format) { * * @return A new instance of the ConnectedQueryConfiguration class with the "single transaction" configuration applied. */ - public ConnectedQueryConfiguration withSingleTransaction() { - return new ConnectedQueryConfiguration(query, dataSource, true, throwExceptions, exceptionHandler, rowMapperRegistry); - } + ConnectedQueryConfigurationImpl withSingleTransaction(); } diff --git a/sadu-queries/src/main/java/de/chojo/sadu/queries/configuration/QueryConfigurationBuilder.java b/sadu-queries/src/main/java/de/chojo/sadu/queries/configuration/QueryConfigurationBuilder.java index 1faa68d3..db74f693 100644 --- a/sadu-queries/src/main/java/de/chojo/sadu/queries/configuration/QueryConfigurationBuilder.java +++ b/sadu-queries/src/main/java/de/chojo/sadu/queries/configuration/QueryConfigurationBuilder.java @@ -8,6 +8,7 @@ import de.chojo.sadu.core.exceptions.ExceptionTransformer; import de.chojo.sadu.mapper.RowMapperRegistry; +import de.chojo.sadu.queries.api.configuration.QueryConfiguration; import org.jetbrains.annotations.NotNull; import javax.sql.DataSource; @@ -71,7 +72,7 @@ public QueryConfigurationBuilder setExceptionHandler(Consumer exce } /** - * Sets the {@link RowMapperRegistry} for the {@link QueryConfiguration}. + * Sets the {@link RowMapperRegistry} for the {@link QueryConfigurationImpl}. * * @param rowMapperRegistry the RowMapperRegistry to set * @return the QueryConfigurationBuilder instance @@ -82,11 +83,11 @@ public QueryConfigurationBuilder setRowMapperRegistry(RowMapperRegistry rowMappe } /** - * Returns a new {@link QueryConfiguration} object based on the current configuration settings. + * Returns a new {@link QueryConfigurationImpl} object based on the current configuration settings. * - * @return a new {@link QueryConfiguration} object + * @return a new {@link QueryConfigurationImpl} object */ public QueryConfiguration build() { - return new QueryConfiguration(dataSource, atomic, throwExceptions, exceptionHandler, rowMapperRegistry); + return new QueryConfigurationImpl(dataSource, atomic, throwExceptions, exceptionHandler, rowMapperRegistry); } } diff --git a/sadu-queries/src/main/java/de/chojo/sadu/queries/configuration/QueryConfigurationImpl.java b/sadu-queries/src/main/java/de/chojo/sadu/queries/configuration/QueryConfigurationImpl.java new file mode 100644 index 00000000..0ddd9c70 --- /dev/null +++ b/sadu-queries/src/main/java/de/chojo/sadu/queries/configuration/QueryConfigurationImpl.java @@ -0,0 +1,72 @@ +/* + * SPDX-License-Identifier: LGPL-3.0-or-later + * + * Copyright (C) RainbowDashLabs and Contributor + */ + +package de.chojo.sadu.queries.configuration; + +import de.chojo.sadu.mapper.RowMapperRegistry; +import de.chojo.sadu.queries.api.configuration.ActiveQueryConfiguration; +import de.chojo.sadu.queries.api.configuration.QueryConfiguration; +import de.chojo.sadu.queries.api.query.ParsedQuery; +import de.chojo.sadu.queries.api.query.Query; +import de.chojo.sadu.queries.api.configuration.context.QueryContext; +import de.chojo.sadu.queries.configuration.context.SimpleQueryContext; +import org.intellij.lang.annotations.Language; +import org.jetbrains.annotations.NotNull; + +import javax.sql.DataSource; +import java.sql.SQLException; +import java.util.function.Consumer; + +public class QueryConfigurationImpl implements QueryConfiguration { + protected final @NotNull DataSource dataSource; + protected final boolean atomic; + protected final boolean throwExceptions; + protected final Consumer exceptionHandler; + protected final RowMapperRegistry rowMapperRegistry; + + QueryConfigurationImpl(@NotNull DataSource dataSource, boolean atomic, boolean throwExceptions, Consumer exceptionHandler, RowMapperRegistry rowMapperRegistry) { + this.dataSource = dataSource; + this.atomic = atomic; + this.throwExceptions = throwExceptions; + this.exceptionHandler = exceptionHandler; + this.rowMapperRegistry = rowMapperRegistry; + } + + @Override + public ActiveQueryConfiguration forQuery(QueryContext context) { + return new ActiveQueryConfigurationImpl(dataSource, atomic, throwExceptions, exceptionHandler, rowMapperRegistry, context); + } + + @Override + public boolean atomic() { + return atomic; + } + + @Override + public boolean throwExceptions() { + return throwExceptions; + } + + @Override + public RowMapperRegistry rowMapperRegistry() { + return rowMapperRegistry; + } + + @Override + public DataSource dataSource() { + return dataSource; + } + + @Override + public ParsedQuery query(@Language("sql") String sql, Object... format) { + return Query.query(this, sql, format); + } + + @Override + public ConnectedQueryConfigurationImpl withSingleTransaction() { + return new ConnectedQueryConfigurationImpl(new SimpleQueryContext(null), dataSource, null, true, throwExceptions, exceptionHandler, rowMapperRegistry); + } +} diff --git a/sadu-queries/src/main/java/de/chojo/sadu/queries/configuration/context/SimpleQueryContext.java b/sadu-queries/src/main/java/de/chojo/sadu/queries/configuration/context/SimpleQueryContext.java new file mode 100644 index 00000000..f2663d38 --- /dev/null +++ b/sadu-queries/src/main/java/de/chojo/sadu/queries/configuration/context/SimpleQueryContext.java @@ -0,0 +1,33 @@ +/* + * SPDX-License-Identifier: LGPL-3.0-or-later + * + * Copyright (C) RainbowDashLabs and Contributor + */ + +package de.chojo.sadu.queries.configuration.context; + +import de.chojo.sadu.queries.api.configuration.context.QueryContext; +import de.chojo.sadu.queries.query.QueryImpl; + +import java.util.Collections; +import java.util.LinkedList; +import java.util.List; + +public class SimpleQueryContext implements QueryContext { + private final List exceptions = new LinkedList<>(); + private final QueryImpl query; + + public SimpleQueryContext(QueryImpl query) { + this.query = query; + } + + @Override + public List exceptions() { + return Collections.unmodifiableList(exceptions); + } + + @Override + public void logException(Exception e) { + exceptions.add(e); + } +} diff --git a/sadu-queries/src/main/java/de/chojo/sadu/queries/exception/SimpleExceptionHolder.java b/sadu-queries/src/main/java/de/chojo/sadu/queries/exception/SimpleExceptionHolder.java new file mode 100644 index 00000000..bb23602c --- /dev/null +++ b/sadu-queries/src/main/java/de/chojo/sadu/queries/exception/SimpleExceptionHolder.java @@ -0,0 +1,30 @@ +/* + * SPDX-License-Identifier: LGPL-3.0-or-later + * + * Copyright (C) RainbowDashLabs and Contributor + */ + +package de.chojo.sadu.queries.exception; + +import de.chojo.sadu.queries.api.exception.ExceptionHolder; + +import java.util.Collections; +import java.util.LinkedList; +import java.util.List; + +public class SimpleExceptionHolder implements ExceptionHolder { + private final List exceptions = new LinkedList<>(); + + public SimpleExceptionHolder() { + } + + @Override + public List exceptions() { + return Collections.unmodifiableList(exceptions); + } + + @Override + public void logException(Exception e) { + exceptions.add(e); + } +} diff --git a/sadu-queries/src/main/java/de/chojo/sadu/queries/query/QueryImpl.java b/sadu-queries/src/main/java/de/chojo/sadu/queries/query/QueryImpl.java index 64c90cf4..1924a25c 100644 --- a/sadu-queries/src/main/java/de/chojo/sadu/queries/query/QueryImpl.java +++ b/sadu-queries/src/main/java/de/chojo/sadu/queries/query/QueryImpl.java @@ -10,9 +10,12 @@ import de.chojo.sadu.core.exceptions.ThrowingFunction; import de.chojo.sadu.queries.api.base.ConnectionProvider; import de.chojo.sadu.queries.api.base.QueryProvider; +import de.chojo.sadu.queries.api.configuration.QueryConfiguration; +import de.chojo.sadu.queries.api.exception.ExceptionHolder; import de.chojo.sadu.queries.api.query.Query; -import de.chojo.sadu.queries.configuration.ConnectedQueryConfiguration; -import de.chojo.sadu.queries.configuration.QueryConfiguration; +import de.chojo.sadu.queries.api.configuration.ActiveQueryConfiguration; +import de.chojo.sadu.queries.api.configuration.ConnectedQueryConfiguration; +import de.chojo.sadu.queries.configuration.context.SimpleQueryContext; import de.chojo.sadu.queries.storage.ResultStorageImpl; import javax.sql.DataSource; @@ -22,14 +25,14 @@ import java.util.List; import java.util.function.Supplier; -public class QueryImpl implements DataSourceProvider, ConnectionProvider, QueryProvider, Query { +public class QueryImpl implements DataSourceProvider, ConnectionProvider, QueryProvider, Query, ExceptionHolder { - private final QueryConfiguration conf; + private final ActiveQueryConfiguration conf; private final ResultStorageImpl storage = new ResultStorageImpl(); private final List exceptions = new ArrayList<>(); public QueryImpl(QueryConfiguration conf) { - this.conf = conf.forQuery(this); + this.conf = conf.forQuery(new SimpleQueryContext(this)); } @Override @@ -47,13 +50,20 @@ public ResultStorageImpl storage() { return storage; } + @Override public void logException(Exception ex) { exceptions.add(ex); } @Override public T callConnection(Supplier defaultResult, ThrowingFunction connectionConsumer) { - if (!(conf instanceof ConnectedQueryConfiguration conn)) { + if (conf instanceof ConnectedQueryConfiguration conn) { + try { + return connectionConsumer.apply(conn.connection()); + } catch (SQLException e) { + conf.handleException(e); + } + } else { try (var conn = conf.dataSource().getConnection()) { conn.setAutoCommit(false); var result = connectionConsumer.apply(conn); @@ -62,16 +72,11 @@ public T callConnection(Supplier defaultResult, ThrowingFunction exceptions() { return exceptions; } diff --git a/sadu-queries/src/main/java/module-info.java b/sadu-queries/src/main/java/module-info.java index 172f5415..f02d752c 100644 --- a/sadu-queries/src/main/java/module-info.java +++ b/sadu-queries/src/main/java/module-info.java @@ -8,8 +8,11 @@ exports de.chojo.sadu.queries.api.call.calls; exports de.chojo.sadu.queries.api.execution.reading; exports de.chojo.sadu.queries.api.execution.writing; + exports de.chojo.sadu.queries.api.configuration; + exports de.chojo.sadu.queries.api.configuration.context; exports de.chojo.sadu.queries.api.parameter; exports de.chojo.sadu.queries.api.query; + exports de.chojo.sadu.queries.api.exception; exports de.chojo.sadu.queries.api.results; exports de.chojo.sadu.queries.api.results.reading; exports de.chojo.sadu.queries.api.results.writing.manipulation; @@ -22,6 +25,7 @@ exports de.chojo.sadu.queries.calls; exports de.chojo.sadu.queries.configuration; + exports de.chojo.sadu.queries.configuration.context; exports de.chojo.sadu.queries.exception;