Class Joiner


  • public class Joiner
    extends Object
    Utility for finding rows based on pre-defined, foreign-key table relationships.
    Author:
    James Ahlborn
    Usage:
    General: This class is general use.
    • Method Detail

      • create

        public static Joiner create​(Table fromTable,
                                    Table toTable)
                             throws IOException
        Creates a new Joiner based on the foreign-key relationship between the given "from"" table and the given "to"" table.
        Parameters:
        fromTable - the "from" side of the relationship
        toTable - the "to" side of the relationship
        Throws:
        IllegalArgumentException - if there is no relationship between the given tables
        IOException
      • create

        public static Joiner create​(Index fromIndex)
                             throws IOException
        Creates a new Joiner based on the given index which backs a foreign-key relationship. The table of the given index will be the "from" table and the table on the other end of the relationship will be the "to" table.
        Parameters:
        fromIndex - the index backing one side of a foreign-key relationship
        Throws:
        IOException
      • createReverse

        public Joiner createReverse()
                             throws IOException
        Creates a new Joiner that is the reverse of this Joiner (the "from" and "to" tables are swapped).
        Throws:
        IOException
      • getFromTable

        public Table getFromTable()
      • getFromIndex

        public Index getFromIndex()
      • getToTable

        public Table getToTable()
      • getToIndex

        public Index getToIndex()
      • hasRows

        public boolean hasRows​(Map<String,​?> fromRow)
                        throws IOException
        Returns true if the "to" table has any rows based on the given columns in the "from" table, false otherwise.
        Throws:
        IOException
      • hasRows

        public boolean hasRows​(Object[] fromRow)
                        throws IOException
        Returns true if the "to" table has any rows based on the given columns in the "from" table, false otherwise.
        Throws:
        IOException
        Usage:
        Intermediate: This method requires moderate API knowledge.
      • findFirstRow

        public Row findFirstRow​(Map<String,​?> fromRow)
                         throws IOException
        Returns the first row in the "to" table based on the given columns in the "from" table if any, null if there is no matching row.
        Parameters:
        fromRow - row from the "from" table (which must include the relevant columns for this join relationship)
        Throws:
        IOException
      • findFirstRow

        public Row findFirstRow​(Map<String,​?> fromRow,
                                Collection<String> columnNames)
                         throws IOException
        Returns selected columns from the first row in the "to" table based on the given columns in the "from" table if any, null if there is no matching row.
        Parameters:
        fromRow - row from the "from" table (which must include the relevant columns for this join relationship)
        columnNames - desired columns in the from table row
        Throws:
        IOException
      • findRows

        public EntryIterableBuilder findRows​(Map<String,​?> fromRow)
        Returns an Iterator over all the rows in the "to" table based on the given columns in the "from" table.
        Parameters:
        fromRow - row from the "from" table (which must include the relevant columns for this join relationship)
      • findRows

        public EntryIterableBuilder findRows​(Object[] fromRow)
        Returns an Iterator with the selected columns over all the rows in the "to" table based on the given columns in the "from" table.
        Parameters:
        fromRow - row from the "from" table (which must include the relevant columns for this join relationship)
      • deleteRows

        public boolean deleteRows​(Map<String,​?> fromRow)
        Deletes any rows in the "to" table based on the given columns in the "from" table.
        Parameters:
        fromRow - row from the "from" table (which must include the relevant columns for this join relationship)
        Returns:
        true if any "to" rows were deleted, false otherwise
      • deleteRows

        public boolean deleteRows​(Object[] fromRow)
        Deletes any rows in the "to" table based on the given columns in the "from" table.
        Parameters:
        fromRow - row from the "from" table (which must include the relevant columns for this join relationship)
        Returns:
        true if any "to" rows were deleted, false otherwise
        Usage:
        Intermediate: This method requires moderate API knowledge.
      • toFKString

        public String toFKString()
        Returns a pretty string describing the foreign key relationship backing this Joiner.