Class TableImpl

java.lang.Object
org.datanucleus.store.rdbms.table.AbstractTable
org.datanucleus.store.rdbms.table.TableImpl
All Implemented Interfaces:
Table, org.datanucleus.store.schema.table.Table
Direct Known Subclasses:
AbstractClassTable, JoinTable, ProbeTable, SchemaTable, SequenceTable

public abstract class TableImpl extends AbstractTable
Class representing a table in a datastore (RDBMS). Provides a series of methods for validating the aspects of the table, namely
  • validate - Validate the table
  • validateColumns - Validate the columns in the table
  • validatePrimaryKey - Validate the primary key
  • validateIndices - Validate the indices on the table
  • validateForeignKeys - Validate all FKs for the table
  • validateConstraints - Validate the indices and FKs.
  • Constructor Details

    • TableImpl

      public TableImpl(DatastoreIdentifier name, RDBMSStoreManager storeMgr)
      Constructor.
      Parameters:
      name - The name of the table (in SQL).
      storeMgr - The StoreManager for this table.
  • Method Details

    • getPrimaryKey

      public PrimaryKey getPrimaryKey()
      Accessor for the primary key for this table. Will always return a PrimaryKey but if we have defined no columns, the pk.size() will be 0.
      Returns:
      The primary key.
    • validate

      public boolean validate(Connection conn, boolean validateColumnStructure, boolean autoCreate, Collection<Throwable> autoCreateErrors) throws SQLException
      Method to validate the table in the datastore.
      Parameters:
      conn - The JDBC Connection
      validateColumnStructure - Whether to validate the column structure, or just the column existence
      autoCreate - Whether to update the table to fix any validation errors. Only applies to missing columns.
      autoCreateErrors - Exceptions found in the "auto-create" process
      Returns:
      Whether the database was modified
      Throws:
      SQLException - Thrown when an error occurs in the JDBC calls
    • validateColumns

      public boolean validateColumns(Connection conn, boolean validateColumnStructure, boolean autoCreate, Collection<Throwable> autoCreateErrors) throws SQLException
      Utility to validate the columns of the table. Will throw a MissingColumnException if a column is not found (and is not required to auto create it)
      Parameters:
      conn - Connection to use for validation
      validateColumnStructure - Whether to validate down to the structure of the columns, or just their existence
      autoCreate - Whether to auto create any missing columns
      autoCreateErrors - Exceptions found in the "auto-create" process
      Returns:
      Whether it validates
      Throws:
      SQLException - Thrown if an error occurs in the validation process
    • initializeColumnInfoForPrimaryKeyColumns

      public void initializeColumnInfoForPrimaryKeyColumns(Connection conn) throws SQLException
      Utility to load the structure/metadata of primary key columns of the table.
      Parameters:
      conn - Connection to use for validation
      Throws:
      SQLException - Thrown if an error occurs in the initialization process
    • initializeColumnInfoFromDatastore

      public void initializeColumnInfoFromDatastore(Connection conn) throws SQLException
      Initialize the default value for columns if null using the values from the datastore.
      Parameters:
      conn - The JDBC Connection
      Throws:
      SQLException - Thrown if an error occurs in the default initialisation.
    • validatePrimaryKey

      protected boolean validatePrimaryKey(Connection conn) throws SQLException
      Utility method to validate the primary key of the table. Will throw a WrongPrimaryKeyException if the PK is incorrect. TODO Add an auto_create parameter on this
      Parameters:
      conn - Connection to use
      Returns:
      Whether it validates
      Throws:
      SQLException - When an error occurs in the valdiation
    • validateConstraints

      public boolean validateConstraints(Connection conn, boolean autoCreate, Collection<Throwable> autoCreateErrors, org.datanucleus.ClassLoaderResolver clr) throws SQLException
      Method to validate any constraints, and auto create them if required.
      Parameters:
      conn - The JDBC Connection
      autoCreate - Whether to auto create the constraints if not existing
      autoCreateErrors - Errors found in the "auto-create" process
      clr - The ClassLoaderResolver
      Returns:
      Whether the database was modified
      Throws:
      SQLException - Thrown when an error occurs in the JDBC calls
    • createConstraints

      public boolean createConstraints(Connection conn, Collection<Throwable> autoCreateErrors, org.datanucleus.ClassLoaderResolver clr) throws SQLException
      Method used to create all constraints for a brand new table.
      Parameters:
      conn - The JDBC Connection
      autoCreateErrors - Errors found in the "auto-create" process
      clr - The ClassLoaderResolver
      Returns:
      Whether the database was modified
      Throws:
      SQLException - Thrown when an error occurs in the JDBC calls
    • validateForeignKeys

      private boolean validateForeignKeys(Connection conn, boolean autoCreate, Collection<Throwable> autoCreateErrors, org.datanucleus.ClassLoaderResolver clr) throws SQLException
      Method to validate any foreign keys on this table in the datastore, and auto create any that are missing where required.
      Parameters:
      conn - The JDBC Connection
      autoCreate - Whether to auto create the FKs if not existing
      autoCreateErrors - Errors found during the auto-create process
      Returns:
      Whether the database was modified
      Throws:
      SQLException - Thrown when an error occurs in the JDBC calls
    • createForeignKeys

      private boolean createForeignKeys(Connection conn, Collection<Throwable> autoCreateErrors, org.datanucleus.ClassLoaderResolver clr, Map actualForeignKeysByName) throws SQLException
      Method to create any foreign keys on this table in the datastore
      Parameters:
      conn - The JDBC Connection
      autoCreateErrors - Errors found during the auto-create process
      actualForeignKeysByName - the current foreign keys
      Returns:
      Whether the database was modified
      Throws:
      SQLException - Thrown when an error occurs in the JDBC calls
    • validateIndices

      private boolean validateIndices(Connection conn, boolean autoCreate, Collection<Throwable> autoCreateErrors, org.datanucleus.ClassLoaderResolver clr) throws SQLException
      Method to validate any indices for this table, and auto create any missing ones where required.
      Parameters:
      conn - The JDBC Connection
      autoCreate - Whether to auto create any missing indices
      autoCreateErrors - Errors found during the auto-create process
      Returns:
      Whether the database was changed
      Throws:
      SQLException - Thrown when an error occurs in the JDBC calls
    • createIndices

      private boolean createIndices(Connection conn, Collection<Throwable> autoCreateErrors, org.datanucleus.ClassLoaderResolver clr, Map actualIndicesByName) throws SQLException
      Method to create any indices for this table
      Parameters:
      conn - The JDBC Connection
      autoCreateErrors - Errors found during the auto-create process
      actualIndicesByName - the actual indices by name
      Returns:
      Whether the database was changed
      Throws:
      SQLException - Thrown when an error occurs in the JDBC calls
    • validateCandidateKeys

      private boolean validateCandidateKeys(Connection conn, boolean autoCreate, Collection<Throwable> autoCreateErrors) throws SQLException
      Method to validate any Candidate keys on this table in the datastore, and auto create any that are missing where required.
      Parameters:
      conn - The JDBC Connection
      autoCreate - Whether to auto create the Candidate Keys if not existing
      autoCreateErrors - Errors found during the auto-create process
      Returns:
      Whether the database was modified
      Throws:
      SQLException - Thrown when an error occurs in the JDBC calls
    • createCandidateKeys

      private boolean createCandidateKeys(Connection conn, Collection<Throwable> autoCreateErrors, Map<DatastoreIdentifier,CandidateKey> actualCandidateKeysByName) throws SQLException
      Method to create any Candidate keys on this table in the datastore, and auto create any that are missing where required.
      Parameters:
      conn - The JDBC Connection
      autoCreateErrors - Errors found during the auto-create process
      Returns:
      Whether the database was modified
      Throws:
      SQLException - Thrown when an error occurs in the JDBC calls
    • dropConstraints

      public void dropConstraints(Connection conn) throws SQLException
      Method to drop the constraints for the table from the datastore.
      Parameters:
      conn - The JDBC Connection
      Throws:
      SQLException - Thrown when an error occurs in the JDBC call.
    • getExpectedForeignKeys

      public List<ForeignKey> getExpectedForeignKeys(org.datanucleus.ClassLoaderResolver clr)
      Accessor for the expected foreign keys for this table in the datastore. Currently only checks the columns for referenced tables (i.e relationships) and returns those.
      Parameters:
      clr - The ClassLoaderResolver
      Returns:
      List of foreign keys.
    • getExpectedCandidateKeys

      protected List<CandidateKey> getExpectedCandidateKeys()
      Accessor for the expected candidate keys for this table in the datastore. Currently returns an empty list.
      Returns:
      List of candidate keys.
    • getExpectedIndices

      protected Set<Index> getExpectedIndices(org.datanucleus.ClassLoaderResolver clr)
      Accessor for the indices for this table in the datastore.
      Parameters:
      clr - The ClassLoaderResolver
      Returns:
      Set of indices expected.
    • getExistingPrimaryKeys

      private Map<DatastoreIdentifier,PrimaryKey> getExistingPrimaryKeys(Connection conn) throws SQLException
      Accessor for the primary keys for this table in the datastore.
      Parameters:
      conn - The JDBC Connection
      Returns:
      Map of primary keys
      Throws:
      SQLException - Thrown when an error occurs in the JDBC call.
    • getExistingForeignKeys

      private Map<DatastoreIdentifier,ForeignKey> getExistingForeignKeys(Connection conn) throws SQLException
      Accessor for the foreign keys for this table.
      Parameters:
      conn - The JDBC Connection
      Returns:
      Map of foreign keys
      Throws:
      SQLException - Thrown when an error occurs in the JDBC call.
    • getExistingCandidateKeys

      private Map<DatastoreIdentifier,CandidateKey> getExistingCandidateKeys(Connection conn) throws SQLException
      Accessor for the candidate keys for this table.
      Parameters:
      conn - The JDBC Connection
      Returns:
      Map of candidate keys
      Throws:
      SQLException - Thrown when an error occurs in the JDBC call.
    • getExistingIndices

      private Map<DatastoreIdentifier,Index> getExistingIndices(Connection conn) throws SQLException
      Accessor for indices on the actual table.
      Parameters:
      conn - The JDBC Connection
      Returns:
      Map of indices (keyed by the index name)
      Throws:
      SQLException - Thrown when an error occurs in the JDBC call.
    • getSQLCreateStatements

      protected List<String> getSQLCreateStatements(Properties props)
      Accessor for the SQL CREATE statements for this table.
      Specified by:
      getSQLCreateStatements in class AbstractTable
      Parameters:
      props - Properties for controlling the table creation
      Returns:
      List of statements.
    • getSQLAddFKStatements

      protected Map<String,String> getSQLAddFKStatements(Map actualForeignKeysByName, org.datanucleus.ClassLoaderResolver clr)
      Get SQL statements to add expected Foreign Keys that are not yet at the table. If the returned Map is empty, the current FK setup is correct.
      Parameters:
      actualForeignKeysByName - Actual Map of foreign keys
      clr - The ClassLoaderResolver
      Returns:
      a Map with the SQL statements
    • getSQLAddCandidateKeyStatements

      protected Map<String,String> getSQLAddCandidateKeyStatements(Map<DatastoreIdentifier,CandidateKey> actualCandidateKeysByName)
      Get SQL statements to add expected Candidate Keys that are not yet on the table. If the returned Map is empty, the current Candidate Key setup is correct.
      Parameters:
      actualCandidateKeysByName - Actual Map of candidate keys
      Returns:
      a Map with the SQL statements
    • isIndexReallyNeeded

      private boolean isIndexReallyNeeded(Index requiredIdx, Collection actualIndices)
      Utility to check if an index is necessary.
      Parameters:
      requiredIdx - The index
      actualIndices - The actual indexes
      Returns:
      Whether the index is needed (i.e not present in the actual indexes)
    • getSQLCreateIndexStatements

      protected Map<String,String> getSQLCreateIndexStatements(Map actualIndicesByName, org.datanucleus.ClassLoaderResolver clr)
      Accessor for the CREATE INDEX statements for this table.
      Parameters:
      actualIndicesByName - Map of actual indexes
      clr - The ClassLoaderResolver
      Returns:
      Map of statements
    • getSQLDropStatements

      protected List<String> getSQLDropStatements()
      Accessor for the DROP statements for this table.
      Specified by:
      getSQLDropStatements in class AbstractTable
      Returns:
      List of statements
    • logMapping

      protected void logMapping(String memberName, JavaTypeMapping mapping)
      Convenience logging method to output the mapping information for an element, key, value field.
      Parameters:
      memberName - Name of the member
      mapping - The mapping