TablesDependencyHelper.java

  1. /*
  2.  *
  3.  * The DbUnit Database Testing Framework
  4.  * Copyright (C)2005, DbUnit.org
  5.  *
  6.  * This library is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU Lesser General Public
  8.  * License as published by the Free Software Foundation; either
  9.  * version 2.1 of the License, or (at your option) any later version.
  10.  *
  11.  * This library is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.  * Lesser General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU Lesser General Public
  17.  * License along with this library; if not, write to the Free Software
  18.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19.  *
  20.  */
  21. package org.dbunit.database.search;

  23. import java.sql.SQLException;
  24. import java.util.Set;

  26. import org.dbunit.database.IDatabaseConnection;
  27. import org.dbunit.database.PrimaryKeyFilter.PkTableMap;
  28. import org.dbunit.dataset.DataSetException;
  29. import org.dbunit.dataset.FilteredDataSet;
  30. import org.dbunit.dataset.IDataSet;
  31. import org.dbunit.dataset.filter.ITableFilter;
  32. import org.dbunit.util.CollectionsHelper;
  33. import org.dbunit.util.search.DepthFirstSearch;
  34. import org.dbunit.util.search.SearchException;
  35. import org.slf4j.Logger;
  36. import org.slf4j.LoggerFactory;


  39. /**
  40.  * Helper for the graph-search based classes used to calculate dependency
  41.  * among tables.  
  42.  * 
  43.  * @author Felipe Leme (dbunit@felipeal.net)
  44.  * @author Last changed by: $Author$
  45.  * @version $Revision$ $Date$
  46.  * @since Aug 26, 2005
  47.  */
  48. public class TablesDependencyHelper {

  50.     /**
  51.      * Logger for this class
  52.      */
  53.     private static final Logger logger = LoggerFactory.getLogger(TablesDependencyHelper.class);

  55.     // this is a "static" class
  56.     private TablesDependencyHelper() {
  57.     }

  59.     /**
  60.      * Get the name of all tables that depend on the root tables (i.e, all tables that have FKs
  61.      * pointing to the PK of the root table).
  62.      * @param connection database connection
  63.      * @param rootTable root table described above
  64.      * @return name of all tables that depend on the root table (including the root table), 
  65.      * in the right order for insertions
  66.      * @throws SearchException if an exception occurred while calculating the order
  67.      */
  68.     public static String[] getDependentTables( IDatabaseConnection connection, String rootTable ) 
  69.     throws SearchException 
  70.     {
  71.         logger.debug("getDependentTables(connection={}, rootTable={}) - start", connection, rootTable);
  72.         return getDependentTables( connection, new String[] { rootTable } );    
  73.     }

  75.     /**
  76.      * Get the name of all tables that depend on the root tables (i.e, all tables that have FKs
  77.      * pointing to the PK of one of the root tables).
  78.      * @param connection database connection
  79.      * @param rootTables array of root tables described above
  80.      * @return name of all tables that depend on the root tables (including the root tables), 
  81.      * in the right order for insertions
  82.      * @throws SearchException if an exception occurred while calculating the order
  83.      */
  84.     public static String[] getDependentTables( IDatabaseConnection connection, String[] rootTables ) 
  85.     throws SearchException 
  86.     {
  87.         logger.debug("getDependentTables(connection={}, rootTables={}) - start", connection, rootTables);

  89.         ImportedKeysSearchCallback callback = new ImportedKeysSearchCallback(connection);
  90.         DepthFirstSearch search = new DepthFirstSearch();
  91.         Set tables = search.search( rootTables, callback );
  92.         return CollectionsHelper.setToStrings( tables );
  93.     }

  95.     /**
  96.      * Get the name of all tables that the given rootTable depends on (i.e, all tables whose PK is a FK for the root table). 
  97.      * @param connection database connection
  98.      * @param rootTable root table described above
  99.      * @return name of all tables that the rootTable depends on (including the rootTable itself), 
  100.      * in the right order for insertions
  101.      * @throws SearchException if an exception occurred while calculating the order
  102.      * @since 2.4
  103.      */
  104.     public static String[] getDependsOnTables( IDatabaseConnection connection, String rootTable ) 
  105.     throws SearchException 
  106.     {
  107.         logger.debug("getDependsOnTables(connection={}, rootTable={}) - start", connection, rootTable);

  109.         ExportedKeysSearchCallback callback = new ExportedKeysSearchCallback(connection);
  110.         DepthFirstSearch search = new DepthFirstSearch();
  111.         Set tables = search.search( new String[]{rootTable}, callback );
  112.         return CollectionsHelper.setToStrings( tables );
  113.     }

  115.     /**
  116.      * Get the name of all tables that depend on a root table ( i.e, all tables whose PK
  117.      * is a FK for the root table) and also the tables the root table depends on 
  118.      * (i.e., all tables which have a FK for the root table's PK). 
  119.      * @param connection database connection
  120.      * @param rootTable root table described above
  121.      * @return name of all tables that depend on the root table (including the root table), 
  122.      * in the right order for insertions
  123.      * @throws SearchException if an exception occurred while calculating the order
  124.      */
  125.     public static String[] getAllDependentTables( IDatabaseConnection connection, String rootTable ) 
  126.     throws SearchException 
  127.     {
  128.         logger.debug("getAllDependentTables(connection={}, rootTable={}) - start", connection, rootTable);
  129.         return getAllDependentTables( connection, new String[] { rootTable } );
  130.     }

  132.     /**
  133.      * Get the name of all tables that depend on the root tables ( i.e, all tables whose PK
  134.      * is a FK for any of the root tables) and also the tables the root tables depends on 
  135.      * (i.e., all tables which have a FK for any of the root table's PK). 
  136.      * @param connection database connection
  137.      * @param rootTables root tables described above
  138.      * @return name of all tables that depend on the root tables (including the root tables), 
  139.      * in the right order for insertions
  140.      * @throws SearchException if an exception occurred while calculating the order
  141.      */
  142.     public static String[] getAllDependentTables(IDatabaseConnection connection, String[] rootTables)
  143.     throws SearchException
  144.     {
  145.         logger.debug("getAllDependentTables(connection={}, rootTables={}) - start",connection, rootTables);

  147.         ImportedAndExportedKeysSearchCallback callback = new ImportedAndExportedKeysSearchCallback(connection);
  148.         DepthFirstSearch search = new DepthFirstSearch();
  149.         Set tables = search.search(rootTables, callback);
  150.         return CollectionsHelper.setToStrings(tables);
  151.     }

  153.     // TODO: javadoc (and unit tests) from down here...

  155.     public static IDataSet getDataset(IDatabaseConnection connection,String rootTable, Set allowedIds) 
  156.     throws SearchException, SQLException, DataSetException
  157.     {
  158.         if (logger.isDebugEnabled())
  159.         {
  160.             logger.debug("getDataset(connection={}, rootTable={}, allowedIds={}) - start", 
  161.                     new Object[] { connection, rootTable, allowedIds });
  162.         }

  164.         PkTableMap map = new PkTableMap();
  165.         map.addAll(rootTable, allowedIds);
  166.         return getDataset(connection, map);
  167.     }

  169.     public static IDataSet getDataset( IDatabaseConnection connection, PkTableMap rootTables ) 
  170.     throws SearchException, SQLException, DataSetException 
  171.     {
  172.         logger.debug("getDataset(connection={}, rootTables={}) - start", connection, rootTables);

  174.         ImportedKeysSearchCallbackFilteredByPKs callback = new ImportedKeysSearchCallbackFilteredByPKs(connection, rootTables);
  175.         ITableFilter filter = callback.getFilter();
  176.         DepthFirstSearch search = new DepthFirstSearch();
  177.         String[] tableNames = rootTables.getTableNames(); 
  178.         Set tmpTables = search.search( tableNames, callback );
  179.         String[] dependentTables  = CollectionsHelper.setToStrings( tmpTables );
  180.         IDataSet tmpDataset = connection.createDataSet( dependentTables );
  181.         FilteredDataSet dataset = new FilteredDataSet(filter, tmpDataset);
  182.         return dataset;
  183.     }

  185.     public static IDataSet getAllDataset( IDatabaseConnection connection, String rootTable, Set allowedPKs ) 
  186.     throws SearchException, SQLException, DataSetException 
  187.     {
  188.         if (logger.isDebugEnabled())
  189.         {
  190.             logger.debug("getAllDataset(connection={}, rootTable={}, allowedPKs={}) - start", 
  191.                     new Object[]{ connection, rootTable, allowedPKs });
  192.         }

  194.         PkTableMap map = new PkTableMap();
  195.         map.addAll( rootTable, allowedPKs );
  196.         return getAllDataset( connection, map );
  197.     }

  199.     public static IDataSet getAllDataset( IDatabaseConnection connection, PkTableMap rootTables ) 
  200.     throws SearchException, SQLException, DataSetException 
  201.     {
  202.         logger.debug("getAllDataset(connection={}, rootTables={}) - start", connection, rootTables);

  204.         ImportedAndExportedKeysSearchCallbackFilteredByPKs callback = new ImportedAndExportedKeysSearchCallbackFilteredByPKs(connection, rootTables);    
  205.         ITableFilter filter = callback.getFilter();
  206.         DepthFirstSearch search = new DepthFirstSearch();
  207.         String[] tableNames = rootTables.getTableNames(); 
  208.         Set tmpTables = search.search( tableNames, callback );
  209.         String[] dependentTables  = CollectionsHelper.setToStrings( tmpTables );
  210.         IDataSet tmpDataset = connection.createDataSet( dependentTables );
  211.         FilteredDataSet dataset = new FilteredDataSet(filter, tmpDataset);
  212.         return dataset;
  213.     }

  215.     /**
  216.      * Returns a set of tables on which the given table directly depends on.
  217.      * @param connection The connection to be used for the database lookup.
  218.      * @param tableName
  219.      * @return a set of tables on which the given table directly depends on.
  220.      * @throws SearchException
  221.      * @since 2.4
  222.      */
  223.     public static Set getDirectDependsOnTables(IDatabaseConnection connection,
  224.             String tableName) throws SearchException 
  225.     {
  226.         logger.debug("getDirectDependsOnTables(connection={}, tableName={}) - start", 
  227.                     connection, tableName);
  228.         
  229.         ExportedKeysSearchCallback callback = new ExportedKeysSearchCallback(connection);
  230.         // Do a depthFirstSearch with a recursion depth of 1
  231.         DepthFirstSearch search = new DepthFirstSearch(1);
  232.         Set tables = search.search( new String[]{tableName}, callback );
  233.         return tables;
  234.     }

  236.     /**
  237.      * Returns a set of tables which directly depend on the given table.
  238.      * @param connection The connection to be used for the database lookup.
  239.      * @param tableName
  240.      * @return a set of tables on which the given table directly depends on.
  241.      * @throws SearchException
  242.      * @since 2.4
  243.      */
  244.     public static Set getDirectDependentTables(IDatabaseConnection connection,
  245.             String tableName) throws SearchException 
  246.     {
  247.         logger.debug("getDirectDependentTables(connection={}, tableName={}) - start", 
  248.                     connection, tableName);

  250.         ImportedKeysSearchCallback callback = new ImportedKeysSearchCallback(connection);
  251.         // Do a depthFirstSearch with a recursion depth of 1
  252.         DepthFirstSearch search = new DepthFirstSearch(1);
  253.         Set tables = search.search( new String[]{tableName}, callback );
  254.         return tables;
  255.     }

  257. }
Created with JaCoCo 0.8.3.201901230119