Coverage report

  %line %branch
org.apache.commons.configuration.DatabaseConfiguration
89% 
96% 

 1  
 /*
 2  
  * Copyright 2001-2004 The Apache Software Foundation.
 3  
  *
 4  
  * Licensed under the Apache License, Version 2.0 (the "License")
 5  
  * you may not use this file except in compliance with the License.
 6  
  * You may obtain a copy of the License at
 7  
  *
 8  
  *     http://www.apache.org/licenses/LICENSE-2.0
 9  
  *
 10  
  * Unless required by applicable law or agreed to in writing, software
 11  
  * distributed under the License is distributed on an "AS IS" BASIS,
 12  
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13  
  * See the License for the specific language governing permissions and
 14  
  * limitations under the License.
 15  
  */
 16  
 
 17  
 package org.apache.commons.configuration;
 18  
 
 19  
 import java.sql.Connection;
 20  
 import java.sql.PreparedStatement;
 21  
 import java.sql.ResultSet;
 22  
 import java.sql.SQLException;
 23  
 import java.sql.Statement;
 24  
 import java.util.ArrayList;
 25  
 import java.util.Collection;
 26  
 import java.util.Iterator;
 27  
 import java.util.List;
 28  
 
 29  
 import javax.sql.DataSource;
 30  
 
 31  
 import org.apache.commons.logging.Log;
 32  
 import org.apache.commons.logging.LogFactory;
 33  
 
 34  
 /**
 35  
  * Configuration stored in a database.
 36  
  *
 37  
  * @since 1.0
 38  
  *
 39  
  * @author Emmanuel Bourg
 40  
  * @version $Revision: 155408 $, $Date: 2005-02-26 13:56:39 +0100 (Sa, 26 Feb 2005) $
 41  
  */
 42  
 public class DatabaseConfiguration extends AbstractConfiguration
 43  
 {
 44  
     /** Logger */
 45  46
     private static Log log = LogFactory.getLog(DatabaseConfiguration.class);
 46  
 
 47  
     /** The datasource to connect to the database. */
 48  
     private DataSource datasource;
 49  
 
 50  
     /** The name of the table containing the configurations. */
 51  
     private String table;
 52  
 
 53  
     /** The column containing the name of the configuration. */
 54  
     private String nameColumn;
 55  
 
 56  
     /** The column containing the keys. */
 57  
     private String keyColumn;
 58  
 
 59  
     /** The column containing the values. */
 60  
     private String valueColumn;
 61  
 
 62  
     /** The name of the configuration. */
 63  
     private String name;
 64  
 
 65  
     /**
 66  
      * Build a configuration from a table containing multiple configurations.
 67  
      *
 68  
      * @param datasource    the datasource to connect to the database
 69  
      * @param table         the name of the table containing the configurations
 70  
      * @param nameColumn    the column containing the name of the configuration
 71  
      * @param keyColumn     the column containing the keys of the configuration
 72  
      * @param valueColumn   the column containing the values of the configuration
 73  
      * @param name          the name of the configuration
 74  
      */
 75  
     public DatabaseConfiguration(DataSource datasource, String table, String nameColumn,
 76  
             String keyColumn, String valueColumn, String name)
 77  425
     {
 78  425
         this.datasource = datasource;
 79  425
         this.table = table;
 80  425
         this.nameColumn = nameColumn;
 81  425
         this.keyColumn = keyColumn;
 82  425
         this.valueColumn = valueColumn;
 83  425
         this.name = name;
 84  425
     }
 85  
 
 86  
     /**
 87  
      * Build a configuration from a table.-
 88  
      *
 89  
      * @param datasource    the datasource to connect to the database
 90  
      * @param table         the name of the table containing the configurations
 91  
      * @param keyColumn     the column containing the keys of the configuration
 92  
      * @param valueColumn   the column containing the values of the configuration
 93  
      */
 94  
     public DatabaseConfiguration(DataSource datasource, String table, String keyColumn, String valueColumn)
 95  
     {
 96  241
         this(datasource, table, null, keyColumn, valueColumn, class="keyword">null);
 97  241
     }
 98  
 
 99  
     /**
 100  
      * {@inheritDoc}
 101  
      */
 102  
     public Object getProperty(String key)
 103  
     {
 104  161
         Object result = null;
 105  
 
 106  
         // build the query
 107  161
         StringBuffer query = new StringBuffer("SELECT * FROM " + table + " WHERE " + keyColumn + "=?");
 108  161
         if (nameColumn != null)
 109  
         {
 110  69
             query.append(" AND " + nameColumn + "=?");
 111  
         }
 112  
 
 113  161
         Connection conn = null;
 114  161
         PreparedStatement pstmt = null;
 115  
 
 116  
         try
 117  
         {
 118  161
             conn = datasource.getConnection();
 119  
 
 120  
             // bind the parameters
 121  161
             pstmt = conn.prepareStatement(query.toString());
 122  161
             pstmt.setString(1, key);
 123  161
             if (nameColumn != null)
 124  
             {
 125  69
                 pstmt.setString(2, name);
 126  
             }
 127  
 
 128  161
             ResultSet rs = pstmt.executeQuery();
 129  
 
 130  161
             if (rs.next())
 131  
             {
 132  115
                 result = rs.getObject(valueColumn);
 133  
             }
 134  
 
 135  
             // build a list if there is more than one row in the resultset
 136  161
             if (rs.next())
 137  
             {
 138  23
                 List results = new ArrayList();
 139  23
                 results.add(result);
 140  23
                 results.add(rs.getObject(valueColumn));
 141  46
                 while (rs.next())
 142  
                 {
 143  23
                     results.add(rs.getObject(valueColumn));
 144  
                 }
 145  23
                 result = results;
 146  
             }
 147  
         }
 148  0
         catch (SQLException e)
 149  
         {
 150  0
             log.error(e.getMessage(), e);
 151  
         }
 152  
         finally
 153  
         {
 154  161
             closeQuietly(conn, pstmt);
 155  161
         }
 156  
 
 157  161
         return result;
 158  
     }
 159  
 
 160  
     /**
 161  
      * {@inheritDoc}
 162  
      */
 163  
     protected void addPropertyDirect(String key, Object obj)
 164  
     {
 165  
         // build the query
 166  69
         StringBuffer query = new StringBuffer("INSERT INTO " + table);
 167  69
         if (nameColumn != null)
 168  
         {
 169  23
             query.append(" (" + nameColumn + ", " + keyColumn + ", " + valueColumn + ") VALUES (?, ?, ?)");
 170  
         }
 171  
         else
 172  
         {
 173  46
             query.append(" (" + keyColumn + ", " + valueColumn + ") VALUES (?, ?)");
 174  
         }
 175  
 
 176  69
         Connection conn = null;
 177  69
         PreparedStatement pstmt = null;
 178  
 
 179  
         try
 180  
         {
 181  69
             conn = datasource.getConnection();
 182  
 
 183  
             // bind the parameters
 184  69
             pstmt = conn.prepareStatement(query.toString());
 185  69
             int index = 1;
 186  69
             if (nameColumn != null)
 187  
             {
 188  23
                 pstmt.setString(index++, name);
 189  
             }
 190  69
             pstmt.setString(index++, key);
 191  69
             pstmt.setString(index++, String.valueOf(obj));
 192  
 
 193  69
             pstmt.executeUpdate();
 194  
         }
 195  0
         catch (SQLException e)
 196  
         {
 197  0
             log.error(e.getMessage(), e);
 198  
         }
 199  
         finally
 200  
         {
 201  
             // clean up
 202  69
             closeQuietly(conn, pstmt);
 203  69
         }
 204  69
     }
 205  
 
 206  
     /**
 207  
      * {@inheritDoc}
 208  
      */
 209  
     public boolean isEmpty()
 210  
     {
 211  126
         boolean empty = true;
 212  
 
 213  
         // build the query
 214  126
         StringBuffer query = new StringBuffer("SELECT count(*) FROM " + table);
 215  126
         if (nameColumn != null)
 216  
         {
 217  69
             query.append(" WHERE " + nameColumn + "=?");
 218  
         }
 219  
 
 220  126
         Connection conn = null;
 221  126
         PreparedStatement pstmt = null;
 222  
 
 223  
         try
 224  
         {
 225  126
             conn = datasource.getConnection();
 226  
 
 227  
             // bind the parameters
 228  126
             pstmt = conn.prepareStatement(query.toString());
 229  126
             if (nameColumn != null)
 230  
             {
 231  69
                 pstmt.setString(1, name);
 232  
             }
 233  
 
 234  126
             ResultSet rs = pstmt.executeQuery();
 235  
 
 236  126
             if (rs.next())
 237  
             {
 238  126
                 empty = rs.getInt(1) == 0;
 239  
             }
 240  
         }
 241  0
         catch (SQLException e)
 242  
         {
 243  0
             log.error(e.getMessage(), e);
 244  
         }
 245  
         finally
 246  
         {
 247  
             // clean up
 248  126
             closeQuietly(conn, pstmt);
 249  126
         }
 250  
 
 251  126
         return empty;
 252  
     }
 253  
 
 254  
     /**
 255  
      * {@inheritDoc}
 256  
      */
 257  
     public boolean containsKey(String key)
 258  
     {
 259  218
         boolean found = false;
 260  
 
 261  
         // build the query
 262  218
         StringBuffer query = new StringBuffer("SELECT * FROM " + table + " WHERE " + keyColumn + "=?");
 263  218
         if (nameColumn != null)
 264  
         {
 265  92
             query.append(" AND " + nameColumn + "=?");
 266  
         }
 267  
 
 268  218
         Connection conn = null;
 269  218
         PreparedStatement pstmt = null;
 270  
 
 271  
         try
 272  
         {
 273  218
             conn = datasource.getConnection();
 274  
 
 275  
             // bind the parameters
 276  218
             pstmt = conn.prepareStatement(query.toString());
 277  218
             pstmt.setString(1, key);
 278  218
             if (nameColumn != null)
 279  
             {
 280  92
                 pstmt.setString(2, name);
 281  
             }
 282  
 
 283  218
             ResultSet rs = pstmt.executeQuery();
 284  
 
 285  218
             found = rs.next();
 286  
         }
 287  0
         catch (SQLException e)
 288  
         {
 289  0
             log.error(e.getMessage(), e);
 290  
         }
 291  
         finally
 292  
         {
 293  
             // clean up
 294  218
             closeQuietly(conn, pstmt);
 295  218
         }
 296  
 
 297  218
         return found;
 298  
     }
 299  
 
 300  
     /**
 301  
      * {@inheritDoc}
 302  
      */
 303  
     public void clearProperty(String key)
 304  
     {
 305  
         // build the query
 306  57
         StringBuffer query = new StringBuffer("DELETE FROM " + table + " WHERE " + keyColumn + "=?");
 307  57
         if (nameColumn != null)
 308  
         {
 309  23
             query.append(" AND " + nameColumn + "=?");
 310  
         }
 311  
 
 312  57
         Connection conn = null;
 313  57
         PreparedStatement pstmt = null;
 314  
 
 315  
         try
 316  
         {
 317  57
             conn = datasource.getConnection();
 318  
 
 319  
             // bind the parameters
 320  57
             pstmt = conn.prepareStatement(query.toString());
 321  57
             pstmt.setString(1, key);
 322  57
             if (nameColumn != null)
 323  
             {
 324  23
                 pstmt.setString(2, name);
 325  
             }
 326  
 
 327  57
             pstmt.executeUpdate();
 328  
         }
 329  0
         catch (SQLException e)
 330  
         {
 331  0
             log.error(e.getMessage(), e);
 332  
         }
 333  
         finally
 334  
         {
 335  
             // clean up
 336  57
             closeQuietly(conn, pstmt);
 337  57
         }
 338  57
     }
 339  
 
 340  
     /**
 341  
      * {@inheritDoc}
 342  
      */
 343  
     public void clear()
 344  
     {
 345  
         // build the query
 346  46
         StringBuffer query = new StringBuffer("DELETE FROM " + table);
 347  46
         if (nameColumn != null)
 348  
         {
 349  23
             query.append(" WHERE " + nameColumn + "=?");
 350  
         }
 351  
 
 352  46
         Connection conn = null;
 353  46
         PreparedStatement pstmt = null;
 354  
 
 355  
         try
 356  
         {
 357  46
             conn = datasource.getConnection();
 358  
 
 359  
             // bind the parameters
 360  46
             pstmt = conn.prepareStatement(query.toString());
 361  46
             if (nameColumn != null)
 362  
             {
 363  23
                 pstmt.setString(1, name);
 364  
             }
 365  
 
 366  46
             pstmt.executeUpdate();
 367  
         }
 368  0
         catch (SQLException e)
 369  
         {
 370  0
             log.error(e.getMessage(), e);
 371  
         }
 372  
         finally
 373  
         {
 374  
             // clean up
 375  46
             closeQuietly(conn, pstmt);
 376  46
         }
 377  46
     }
 378  
 
 379  
     /**
 380  
      * {@inheritDoc}
 381  
      */
 382  
     public Iterator getKeys()
 383  
     {
 384  91
         Collection keys = new ArrayList();
 385  
 
 386  
         // build the query
 387  91
         StringBuffer query = new StringBuffer("SELECT DISTINCT " + keyColumn + " FROM " + table);
 388  91
         if (nameColumn != null)
 389  
         {
 390  23
             query.append(" WHERE " + nameColumn + "=?");
 391  
         }
 392  
 
 393  91
         Connection conn = null;
 394  91
         PreparedStatement pstmt = null;
 395  
 
 396  
         try
 397  
         {
 398  91
             conn = datasource.getConnection();
 399  
 
 400  
             // bind the parameters
 401  91
             pstmt = conn.prepareStatement(query.toString());
 402  91
             if (nameColumn != null)
 403  
             {
 404  23
                 pstmt.setString(1, name);
 405  
             }
 406  
 
 407  91
             ResultSet rs = pstmt.executeQuery();
 408  
 
 409  239
             while (rs.next())
 410  
             {
 411  148
                 keys.add(rs.getString(1));
 412  
             }
 413  
         }
 414  0
         catch (SQLException e)
 415  
         {
 416  0
             log.error(e.getMessage(), e);
 417  
         }
 418  
         finally
 419  
         {
 420  
             // clean up
 421  91
             closeQuietly(conn, pstmt);
 422  91
         }
 423  
 
 424  91
         return keys.iterator();
 425  
     }
 426  
 
 427  
     /**
 428  
      * Close a <code>Connection</code> and, <code>Statement</code>.
 429  
      * Avoid closing if null and hide any SQLExceptions that occur.
 430  
      *
 431  
      * @param conn The database connection to close
 432  
      * @param stmt The statement to close
 433  
      */
 434  
     private void closeQuietly(Connection conn, Statement stmt)
 435  
     {
 436  
         try
 437  
         {
 438  768
             if (stmt != null)
 439  
             {
 440  768
                 stmt.close();
 441  
             }
 442  768
             if (conn != null)
 443  
             {
 444  768
                 conn.close();
 445  
             }
 446  
         }
 447  0
         catch (SQLException e)
 448  
         {
 449  0
             log.error(e.getMessage(), e);
 450  768
         }
 451  768
     }
 452  
 }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.