DatabaseConfiguration.java

  1. /*
  2.  * Licensed to the Apache Software Foundation (ASF) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * The ASF licenses this file to You under the Apache License, Version 2.0
  6.  * (the "License"); you may not use this file except in compliance with
  7.  * the License.  You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */

  18. package org.apache.commons.configuration2;

  20. import java.sql.Clob;
  21. import java.sql.Connection;
  22. import java.sql.PreparedStatement;
  23. import java.sql.ResultSet;
  24. import java.sql.SQLException;
  25. import java.sql.Statement;
  26. import java.util.ArrayList;
  27. import java.util.Collection;
  28. import java.util.Iterator;
  29. import java.util.List;

  31. import javax.sql.DataSource;

  33. import org.apache.commons.configuration2.convert.DisabledListDelimiterHandler;
  34. import org.apache.commons.configuration2.convert.ListDelimiterHandler;
  35. import org.apache.commons.configuration2.event.ConfigurationErrorEvent;
  36. import org.apache.commons.configuration2.event.ConfigurationEvent;
  37. import org.apache.commons.configuration2.event.EventType;
  38. import org.apache.commons.configuration2.io.ConfigurationLogger;
  39. import org.apache.commons.lang3.StringUtils;

  41. /**
  42.  * Configuration stored in a database. The properties are retrieved from a table containing at least one column for the
  43.  * keys, and one column for the values. It's possible to store several configurations in the same table by adding a
  44.  * column containing the name of the configuration. The name of the table and the columns have to be specified using the
  45.  * corresponding properties.
  46.  * <p>
  47.  * The recommended way to create an instance of {@code DatabaseConfiguration} is to use a <em>configuration
  48.  * builder</em>. The builder is configured with a special parameters object defining the database structures used by the
  49.  * configuration. Such an object can be created using the {@code database()} method of the {@code Parameters} class. See
  50.  * the examples below for more details.
  51.  * </p>
  52.  *
  53.  * <p>
  54.  * <strong>Example 1 - One configuration per table</strong>
  55.  * </p>
  56.  *
  57.  * <pre>
  58.  * CREATE TABLE myconfig (
  59.  *     `key`   VARCHAR NOT NULL PRIMARY KEY,
  60.  *     `value` VARCHAR
  61.  * );
  62.  *
  63.  * INSERT INTO myconfig (key, value) VALUES ('foo', 'bar');
  64.  *
  65.  * BasicConfigurationBuilder&lt;DatabaseConfiguration&gt; builder =
  66.  *     new BasicConfigurationBuilder&lt;DatabaseConfiguration&gt;(DatabaseConfiguration.class);
  67.  * builder.configure(
  68.  *     Parameters.database()
  69.  *         .setDataSource(dataSource)
  70.  *         .setTable("myconfig")
  71.  *         .setKeyColumn("key")
  72.  *         .setValueColumn("value")
  73.  * );
  74.  * Configuration config = builder.getConfiguration();
  75.  * String value = config.getString("foo");
  76.  * </pre>
  77.  *
  78.  * <p>
  79.  * <strong>Example 2 - Multiple configurations per table</strong>
  80.  * </p>
  81.  *
  82.  * <pre>
  83.  * CREATE TABLE myconfigs (
  84.  *     `name`  VARCHAR NOT NULL,
  85.  *     `key`   VARCHAR NOT NULL,
  86.  *     `value` VARCHAR,
  87.  *     CONSTRAINT sys_pk_myconfigs PRIMARY KEY (`name`, `key`)
  88.  * );
  89.  *
  90.  * INSERT INTO myconfigs (name, key, value) VALUES ('config1', 'key1', 'value1');
  91.  * INSERT INTO myconfigs (name, key, value) VALUES ('config2', 'key2', 'value2');
  92.  *
  93.  * BasicConfigurationBuilder&lt;DatabaseConfiguration&gt; builder =
  94.  *     new BasicConfigurationBuilder&lt;DatabaseConfiguration&gt;(DatabaseConfiguration.class);
  95.  * builder.configure(
  96.  *     Parameters.database()
  97.  *         .setDataSource(dataSource)
  98.  *         .setTable("myconfigs")
  99.  *         .setKeyColumn("key")
  100.  *         .setValueColumn("value")
  101.  *         .setConfigurationNameColumn("name")
  102.  *         .setConfigurationName("config1")
  103.  * );
  104.  * Configuration config1 = new DatabaseConfiguration(dataSource, "myconfigs", "name", "key", "value", "config1");
  105.  * String value1 = conf.getString("key1");
  106.  * </pre>
  107.  *
  108.  * The configuration can be instructed to perform commits after database updates. This is achieved by setting the
  109.  * {@code commits} parameter of the constructors to <strong>true</strong>. If commits should not be performed (which is the
  110.  * default behavior), it should be ensured that the connections returned by the {@code DataSource} are in auto-commit
  111.  * mode.
  112.  * <p>
  113.  * <strong>Note: Like JDBC itself, protection against SQL injection is left to the user.</strong>
  114.  * </p>
  115.  *
  116.  * @since 1.0
  117.  */
  118. public class DatabaseConfiguration extends AbstractConfiguration {
  119.     /**
  120.      * An internally used helper class for simplifying database access through plain JDBC. This class provides a simple
  121.      * framework for creating and executing a JDBC statement. It especially takes care of proper handling of JDBC resources
  122.      * even in case of an error.
  123.      *
  124.      * @param <T> the type of the results produced by a JDBC operation
  125.      */
  126.     private abstract class AbstractJdbcOperation<T> {
  127.         /** Stores the connection. */
  128.         private Connection connection;

  130.         /** Stores the statement. */
  131.         private PreparedStatement preparedStatement;

  133.         /** Stores the result set. */
  134.         private ResultSet resultSet;

  136.         /** The type of the event to send in case of an error. */
  137.         private final EventType<? extends ConfigurationErrorEvent> errorEventType;

  139.         /** The type of the operation which caused an error. */
  140.         private final EventType<?> operationEventType;

  142.         /** The property configurationName for an error event. */
  143.         private final String errorPropertyName;

  145.         /** The property value for an error event. */
  146.         private final Object errorPropertyValue;

  148.         /**
  149.          * Creates a new instance of {@code JdbcOperation} and initializes the properties related to the error event.
  150.          *
  151.          * @param errEvType the type of the error event
  152.          * @param opType the operation event type
  153.          * @param errPropName the property configurationName for the error event
  154.          * @param errPropVal the property value for the error event
  155.          */
  156.         protected AbstractJdbcOperation(final EventType<? extends ConfigurationErrorEvent> errEvType, final EventType<?> opType, final String errPropName,
  157.             final Object errPropVal) {
  158.             errorEventType = errEvType;
  159.             operationEventType = opType;
  160.             errorPropertyName = errPropName;
  161.             errorPropertyValue = errPropVal;
  162.         }

  164.         /**
  165.          * Creates a {@code PreparedStatement} object for executing the specified SQL statement.
  166.          *
  167.          * @param sql the statement to be executed
  168.          * @param nameCol a flag whether the configurationName column should be taken into account
  169.          * @return the prepared statement object
  170.          * @throws SQLException if an SQL error occurs
  171.          */
  172.         protected PreparedStatement createStatement(final String sql, final boolean nameCol) throws SQLException {
  173.             final String statement;
  174.             if (nameCol && configurationNameColumn != null) {
  175.                 final StringBuilder buf = new StringBuilder(sql);
  176.                 buf.append(" AND ").append(configurationNameColumn).append("=?");
  177.                 statement = buf.toString();
  178.             } else {
  179.                 statement = sql;
  180.             }

  182.             preparedStatement = getConnection().prepareStatement(statement);
  183.             return preparedStatement;
  184.         }

  186.         /**
  187.          * Executes this operation. This method obtains a database connection and then delegates to {@code performOperation()}.
  188.          * Afterwards it performs the necessary clean up. Exceptions that are thrown during the JDBC operation are caught and
  189.          * transformed into configuration error events.
  190.          *
  191.          * @return the result of the operation
  192.          */
  193.         public T execute() {
  194.             T result = null;

  196.             if (getDataSource() != null) {
  197.                 try {
  198.                     connection = getDataSource().getConnection();
  199.                     result = performOperation();

  201.                     if (isAutoCommit()) {
  202.                         connection.commit();
  203.                     }
  204.                 } catch (final SQLException e) {
  205.                     fireError(errorEventType, operationEventType, errorPropertyName, errorPropertyValue, e);
  206.                 } finally {
  207.                     close(connection, preparedStatement, resultSet);
  208.                 }
  209.             }

  211.             return result;
  212.         }

  214.         /**
  215.          * Gets the current connection. This method can be called while {@code execute()} is running. It returns <strong>null</strong>
  216.          * otherwise.
  217.          *
  218.          * @return the current connection
  219.          */
  220.         protected Connection getConnection() {
  221.             return connection;
  222.         }

  224.         /**
  225.          * Creates an initializes a {@code PreparedStatement} object for executing an SQL statement. This method first calls
  226.          * {@code createStatement()} for creating the statement and then initializes the statement's parameters.
  227.          *
  228.          * @param sql the statement to be executed
  229.          * @param nameCol a flag whether the configurationName column should be taken into account
  230.          * @param params the parameters for the statement
  231.          * @return the initialized statement object
  232.          * @throws SQLException if an SQL error occurs
  233.          */
  234.         protected PreparedStatement initStatement(final String sql, final boolean nameCol, final Object... params) throws SQLException {
  235.             final PreparedStatement ps = createStatement(sql, nameCol);

  237.             int idx = 1;
  238.             for (final Object param : params) {
  239.                 ps.setObject(idx++, param);
  240.             }
  241.             if (nameCol && configurationNameColumn != null) {
  242.                 ps.setString(idx, configurationName);
  243.             }

  245.             return ps;
  246.         }

  248.         /**
  249.          * Creates a {@code PreparedStatement} for a query, initializes it and executes it. The resulting {@code ResultSet} is
  250.          * returned.
  251.          *
  252.          * @param sql the statement to be executed
  253.          * @param nameCol a flag whether the configurationName column should be taken into account
  254.          * @param params the parameters for the statement
  255.          * @return the {@code ResultSet} produced by the query
  256.          * @throws SQLException if an SQL error occurs
  257.          */
  258.         protected ResultSet openResultSet(final String sql, final boolean nameCol, final Object... params) throws SQLException {
  259.             return resultSet = initStatement(sql, nameCol, params).executeQuery();
  260.         }

  262.         /**
  263.          * Performs the JDBC operation. This method is called by {@code execute()} after this object has been fully initialized.
  264.          * Here the actual JDBC logic has to be placed.
  265.          *
  266.          * @return the result of the operation
  267.          * @throws SQLException if an SQL error occurs
  268.          */
  269.         protected abstract T performOperation() throws SQLException;
  270.     }

  272.     /** Constant for the statement used by getProperty. */
  273.     private static final String SQL_GET_PROPERTY = "SELECT * FROM %s WHERE %s =?";

  275.     /** Constant for the statement used by isEmpty. */
  276.     private static final String SQL_IS_EMPTY = "SELECT count(*) FROM %s WHERE 1 = 1";

  278.     /** Constant for the statement used by clearProperty. */
  279.     private static final String SQL_CLEAR_PROPERTY = "DELETE FROM %s WHERE %s =?";

  281.     /** Constant for the statement used by clear. */
  282.     private static final String SQL_CLEAR = "DELETE FROM %s WHERE 1 = 1";

  284.     /** Constant for the statement used by getKeys. */
  285.     private static final String SQL_GET_KEYS = "SELECT DISTINCT %s FROM %s WHERE 1 = 1";

  287.     /**
  288.      * Converts a CLOB to a string.
  289.      *
  290.      * @param clob the CLOB to be converted
  291.      * @return the extracted string value
  292.      * @throws SQLException if an error occurs
  293.      */
  294.     private static Object convertClob(final Clob clob) throws SQLException {
  295.         final int len = (int) clob.length();
  296.         return len > 0 ? clob.getSubString(1, len) : StringUtils.EMPTY;
  297.     }

  299.     /** The data source to connect to the database. */
  300.     private DataSource dataSource;

  302.     /** The configurationName of the table containing the configurations. */
  303.     private String table;

  305.     /** The column containing the configurationName of the configuration. */
  306.     private String configurationNameColumn;

  308.     /** The column containing the keys. */
  309.     private String keyColumn;

  311.     /** The column containing the values. */
  312.     private String valueColumn;

  314.     /** The configurationName of the configuration. */
  315.     private String configurationName;

  317.     /** A flag whether commits should be performed by this configuration. */
  318.     private boolean autoCommit;

  320.     /**
  321.      * Creates a new instance of {@code DatabaseConfiguration}.
  322.      */
  323.     public DatabaseConfiguration() {
  324.         initLogger(new ConfigurationLogger(DatabaseConfiguration.class));
  325.         addErrorLogListener();
  326.     }

  328.     /**
  329.      * Adds a property to this configuration. If this causes a database error, an error event will be generated of type
  330.      * {@code ADD_PROPERTY} with the causing exception. The event's {@code propertyName} is set to the passed in property
  331.      * key, the {@code propertyValue} points to the passed in value.
  332.      *
  333.      * @param key the property key
  334.      * @param obj the value of the property to add
  335.      */
  336.     @Override
  337.     protected void addPropertyDirect(final String key, final Object obj) {
  338.         new AbstractJdbcOperation<Void>(ConfigurationErrorEvent.WRITE, ConfigurationEvent.ADD_PROPERTY, key, obj) {
  339.             @Override
  340.             protected Void performOperation() throws SQLException {
  341.                 final StringBuilder query = new StringBuilder("INSERT INTO ");
  342.                 query.append(table).append(" (");
  343.                 query.append(keyColumn).append(", ");
  344.                 query.append(valueColumn);
  345.                 if (configurationNameColumn != null) {
  346.                     query.append(", ").append(configurationNameColumn);
  347.                 }
  348.                 query.append(") VALUES (?, ?");
  349.                 if (configurationNameColumn != null) {
  350.                     query.append(", ?");
  351.                 }
  352.                 query.append(")");

  354.                 try (PreparedStatement pstmt = initStatement(query.toString(), false, key, String.valueOf(obj))) {
  355.                     if (configurationNameColumn != null) {
  356.                         pstmt.setString(3, configurationName);
  357.                     }

  359.                     pstmt.executeUpdate();
  360.                     return null;
  361.                 }
  362.             }
  363.         }.execute();
  364.     }

  366.     /**
  367.      * Adds a property to this configuration. This implementation temporarily disables list delimiter parsing, so that even
  368.      * if the value contains the list delimiter, only a single record is written into the managed table. The implementation
  369.      * of {@code getProperty()} takes care about delimiters. So list delimiters are fully supported by
  370.      * {@code DatabaseConfiguration}, but internally treated a bit differently.
  371.      *
  372.      * @param key the key of the new property
  373.      * @param value the value to be added
  374.      */
  375.     @Override
  376.     protected void addPropertyInternal(final String key, final Object value) {
  377.         final ListDelimiterHandler oldHandler = getListDelimiterHandler();
  378.         try {
  379.             // temporarily disable delimiter parsing
  380.             setListDelimiterHandler(DisabledListDelimiterHandler.INSTANCE);
  381.             super.addPropertyInternal(key, value);
  382.         } finally {
  383.             setListDelimiterHandler(oldHandler);
  384.         }
  385.     }

  387.     /**
  388.      * Removes all entries from this configuration. If this causes a database error, an error event will be generated of
  389.      * type {@code CLEAR} with the causing exception. Both the event's {@code propertyName} and the {@code propertyValue}
  390.      * will be undefined.
  391.      */
  392.     @Override
  393.     protected void clearInternal() {
  394.         new AbstractJdbcOperation<Void>(ConfigurationErrorEvent.WRITE, ConfigurationEvent.CLEAR, null, null) {
  395.             @Override
  396.             protected Void performOperation() throws SQLException {
  397.                 try (PreparedStatement statement = initStatement(String.format(SQL_CLEAR, table), true)) {
  398.                     statement.executeUpdate();
  399.                 }
  400.                 return null;
  401.             }
  402.         }.execute();
  403.     }

  405.     /**
  406.      * Removes the specified value from this configuration. If this causes a database error, an error event will be
  407.      * generated of type {@code CLEAR_PROPERTY} with the causing exception. The event's {@code propertyName} will be set to
  408.      * the passed in key, the {@code propertyValue} will be undefined.
  409.      *
  410.      * @param key the key of the property to be removed
  411.      */
  412.     @Override
  413.     protected void clearPropertyDirect(final String key) {
  414.         new AbstractJdbcOperation<Void>(ConfigurationErrorEvent.WRITE, ConfigurationEvent.CLEAR_PROPERTY, key, null) {
  415.             @Override
  416.             protected Void performOperation() throws SQLException {
  417.                 try (PreparedStatement ps = initStatement(String.format(SQL_CLEAR_PROPERTY, table, keyColumn), true, key)) {
  418.                     ps.executeUpdate();
  419.                     return null;
  420.                 }
  421.             }
  422.         }.execute();
  423.     }

  425.     /**
  426.      * Close the specified database objects. Avoid closing if null and hide any SQLExceptions that occur.
  427.      *
  428.      * @param conn The database connection to close
  429.      * @param stmt The statement to close
  430.      * @param rs the result set to close
  431.      */
  432.     protected void close(final Connection conn, final Statement stmt, final ResultSet rs) {
  433.         try {
  434.             if (rs != null) {
  435.                 rs.close();
  436.             }
  437.         } catch (final SQLException e) {
  438.             getLogger().error("An error occurred on closing the result set", e);
  439.         }

  441.         try {
  442.             if (stmt != null) {
  443.                 stmt.close();
  444.             }
  445.         } catch (final SQLException e) {
  446.             getLogger().error("An error occurred on closing the statement", e);
  447.         }

  449.         try {
  450.             if (conn != null) {
  451.                 conn.close();
  452.             }
  453.         } catch (final SQLException e) {
  454.             getLogger().error("An error occurred on closing the connection", e);
  455.         }
  456.     }

  458.     /**
  459.      * Checks whether this configuration contains the specified key. If this causes a database error, an error event will be
  460.      * generated of type {@code READ} with the causing exception. The event's {@code propertyName} will be set to the passed
  461.      * in key, the {@code propertyValue} will be undefined.
  462.      *
  463.      * @param key the key to be checked
  464.      * @return a flag whether this key is defined
  465.      */
  466.     @Override
  467.     protected boolean containsKeyInternal(final String key) {
  468.         final AbstractJdbcOperation<Boolean> op = new AbstractJdbcOperation<Boolean>(ConfigurationErrorEvent.READ, ConfigurationErrorEvent.READ, key, null) {
  469.             @Override
  470.             protected Boolean performOperation() throws SQLException {
  471.                 try (ResultSet rs = openResultSet(String.format(SQL_GET_PROPERTY, table, keyColumn), true, key)) {
  472.                     return rs.next();
  473.                 }
  474.             }
  475.         };

  477.         final Boolean result = op.execute();
  478.         return result != null && result.booleanValue();
  479.     }

  481.     /**
  482.      * Tests whether this configuration contains one or more matches to this value. This operation stops at first
  483.      * match but may be more expensive than the containsKey method.
  484.      * @since 2.11.0
  485.      */
  486.     @Override
  487.     protected boolean containsValueInternal(final Object value) {
  488.         final AbstractJdbcOperation<Boolean> op = new AbstractJdbcOperation<Boolean>(ConfigurationErrorEvent.READ, ConfigurationErrorEvent.READ, null, value) {
  489.             @Override
  490.             protected Boolean performOperation() throws SQLException {
  491.                 try (ResultSet rs = openResultSet(String.format(SQL_GET_PROPERTY, table, valueColumn), false, value)) {
  492.                     return rs.next();
  493.                 }
  494.             }
  495.         };
  496.         final Boolean result = op.execute();
  497.         return result != null && result.booleanValue();
  498.     }

  500.     /**
  501.      * Extracts the value of a property from the given result set. The passed in {@code ResultSet} was created by a SELECT
  502.      * statement on the underlying database table. This implementation reads the value of the column determined by the
  503.      * {@code valueColumn} property. Normally the contained value is directly returned. However, if it is of type
  504.      * {@code CLOB}, text is extracted as string.
  505.      *
  506.      * @param rs the current {@code ResultSet}
  507.      * @return the value of the property column
  508.      * @throws SQLException if an error occurs
  509.      */
  510.     protected Object extractPropertyValue(final ResultSet rs) throws SQLException {
  511.         Object value = rs.getObject(valueColumn);
  512.         if (value instanceof Clob) {
  513.             value = convertClob((Clob) value);
  514.         }
  515.         return value;
  516.     }

  518.     /**
  519.      * Gets the name of this configuration instance.
  520.      *
  521.      * @return the name of this configuration
  522.      */
  523.     public String getConfigurationName() {
  524.         return configurationName;
  525.     }

  527.     /**
  528.      * Gets the name of the table column with the configuration name.
  529.      *
  530.      * @return the name of the configuration name column
  531.      */
  532.     public String getConfigurationNameColumn() {
  533.         return configurationNameColumn;
  534.     }

  536.     /**
  537.      * Gets the used {@code DataSource} object.
  538.      *
  539.      * @return the data source
  540.      * @since 1.4
  541.      * @deprecated Use {@link #getDataSource()}
  542.      */
  543.     @Deprecated
  544.     public DataSource getDatasource() {
  545.         return dataSource;
  546.     }

  548.     /**
  549.      * Gets the {@code DataSource} for obtaining database connections.
  550.      *
  551.      * @return the {@code DataSource}
  552.      */
  553.     public DataSource getDataSource() {
  554.         return dataSource;
  555.     }

  557.     /**
  558.      * Gets the name of the column containing the configuration keys.
  559.      *
  560.      * @return the name of the key column
  561.      */
  562.     public String getKeyColumn() {
  563.         return keyColumn;
  564.     }

  566.     /**
  567.      * Returns an iterator with the names of all properties contained in this configuration. If this causes a database
  568.      * error, an error event will be generated of type {@code READ} with the causing exception. Both the event's
  569.      * {@code propertyName} and the {@code propertyValue} will be undefined.
  570.      *
  571.      * @return an iterator with the contained keys (an empty iterator in case of an error)
  572.      */
  573.     @Override
  574.     protected Iterator<String> getKeysInternal() {
  575.         final Collection<String> keys = new ArrayList<>();
  576.         new AbstractJdbcOperation<Collection<String>>(ConfigurationErrorEvent.READ, ConfigurationErrorEvent.READ, null, null) {
  577.             @Override
  578.             protected Collection<String> performOperation() throws SQLException {
  579.                 try (ResultSet rs = openResultSet(String.format(SQL_GET_KEYS, keyColumn, table), true)) {
  580.                     while (rs.next()) {
  581.                         keys.add(rs.getString(1));
  582.                     }
  583.                     return keys;
  584.                 }
  585.             }
  586.         }.execute();

  588.         return keys.iterator();
  589.     }

  591.     /**
  592.      * Gets the value of the specified property. If this causes a database error, an error event will be generated of
  593.      * type {@code READ} with the causing exception. The event's {@code propertyName} is set to the passed in property key,
  594.      * the {@code propertyValue} is undefined.
  595.      *
  596.      * @param key the key of the desired property
  597.      * @return the value of this property
  598.      */
  599.     @Override
  600.     protected Object getPropertyInternal(final String key) {
  601.         final AbstractJdbcOperation<Object> op = new AbstractJdbcOperation<Object>(ConfigurationErrorEvent.READ, ConfigurationErrorEvent.READ, key, null) {
  602.             @Override
  603.             protected Object performOperation() throws SQLException {
  604.                 final List<Object> results = new ArrayList<>();
  605.                 try (ResultSet rs = openResultSet(String.format(SQL_GET_PROPERTY, table, keyColumn), true, key)) {
  606.                     while (rs.next()) {
  607.                         // Split value if it contains the list delimiter
  608.                         getListDelimiterHandler().parse(extractPropertyValue(rs)).forEach(results::add);
  609.                     }
  610.                 }
  611.                 if (!results.isEmpty()) {
  612.                     return results.size() > 1 ? results : results.get(0);
  613.                 }
  614.                 return null;
  615.             }
  616.         };

  618.         return op.execute();
  619.     }

  621.     /**
  622.      * Gets the name of the table containing configuration data.
  623.      *
  624.      * @return the name of the table to be queried
  625.      */
  626.     public String getTable() {
  627.         return table;
  628.     }

  630.     /**
  631.      * Gets the name of the column containing the configuration values.
  632.      *
  633.      * @return the name of the value column
  634.      */
  635.     public String getValueColumn() {
  636.         return valueColumn;
  637.     }

  639.     /**
  640.      * Returns a flag whether this configuration performs commits after database updates.
  641.      *
  642.      * @return a flag whether commits are performed
  643.      */
  644.     public boolean isAutoCommit() {
  645.         return autoCommit;
  646.     }

  648.     /**
  649.      * Checks if this configuration is empty. If this causes a database error, an error event will be generated of type
  650.      * {@code READ} with the causing exception. Both the event's {@code propertyName} and {@code propertyValue} will be
  651.      * undefined.
  652.      *
  653.      * @return a flag whether this configuration is empty.
  654.      */
  655.     @Override
  656.     protected boolean isEmptyInternal() {
  657.         final AbstractJdbcOperation<Integer> op = new AbstractJdbcOperation<Integer>(ConfigurationErrorEvent.READ, ConfigurationErrorEvent.READ, null, null) {
  658.             @Override
  659.             protected Integer performOperation() throws SQLException {
  660.                 try (ResultSet rs = openResultSet(String.format(SQL_IS_EMPTY, table), true)) {
  661.                     return rs.next() ? Integer.valueOf(rs.getInt(1)) : null;
  662.                 }
  663.             }
  664.         };

  666.         final Integer count = op.execute();
  667.         return count == null || count.intValue() == 0;
  668.     }

  670.     /**
  671.      * Sets the auto commit flag. If set to <strong>true</strong>, this configuration performs a commit after each database update.
  672.      *
  673.      * @param autoCommit the auto commit flag
  674.      */
  675.     public void setAutoCommit(final boolean autoCommit) {
  676.         this.autoCommit = autoCommit;
  677.     }

  679.     /**
  680.      * Sets the name of this configuration instance.
  681.      *
  682.      * @param configurationName the name of this configuration
  683.      */
  684.     public void setConfigurationName(final String configurationName) {
  685.         this.configurationName = configurationName;
  686.     }

  688.     /**
  689.      * Sets the name of the table column with the configuration name.
  690.      *
  691.      * @param configurationNameColumn the name of the column with the configuration name
  692.      */
  693.     public void setConfigurationNameColumn(final String configurationNameColumn) {
  694.         this.configurationNameColumn = configurationNameColumn;
  695.     }

  697.     /**
  698.      * Sets the {@code DataSource} for obtaining database connections.
  699.      *
  700.      * @param dataSource the {@code DataSource}
  701.      */
  702.     public void setDataSource(final DataSource dataSource) {
  703.         this.dataSource = dataSource;
  704.     }

  706.     /**
  707.      * Sets the name of the column containing the configuration keys.
  708.      *
  709.      * @param keyColumn the name of the key column
  710.      */
  711.     public void setKeyColumn(final String keyColumn) {
  712.         this.keyColumn = keyColumn;
  713.     }

  715.     /**
  716.      * Sets the name of the table containing configuration data.
  717.      *
  718.      * @param table the table name
  719.      */
  720.     public void setTable(final String table) {
  721.         this.table = table;
  722.     }

  724.     /**
  725.      * Sets the name of the column containing the configuration values.
  726.      *
  727.      * @param valueColumn the name of the value column
  728.      */
  729.     public void setValueColumn(final String valueColumn) {
  730.         this.valueColumn = valueColumn;
  731.     }
  732. }
Created with JaCoCo 0.8.12.202403310830