SchemaManager (EclipseLink 2.6.3, API Reference)

java.lang.Object
- org.eclipse.persistence.tools.schemaframework.SchemaManager

Direct Known Subclasses:

DynamicSchemaManager
```
public class SchemaManager
extends java.lang.Object
```
Purpose: Define all user level protocol for development time database manipulation.
Responsibilities:
- Define protocol for schema creation.
- Define any useful testing specific protocol.

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`createDatabaseSchemas` Flag to determine if database schemas should be created during DDL generation
`protected java.util.HashSet<java.lang.String>`	`createdDatabaseSchemas`
`protected java.util.HashSet<java.lang.String>`	`createdDatabaseSchemasOnDatabase`
`protected java.io.Writer`	`createSchemaWriter`
`protected boolean`	`createSQLFiles`
`protected TableCreator`	`defaultTableCreator`
`protected java.util.HashMap<java.lang.String,DatabaseObjectDefinition>`	`dropDatabaseSchemas`
`protected java.io.Writer`	`dropSchemaWriter`
`static boolean`	`FAST_TABLE_CREATOR` Allow table creator to occur "fast" by just deleting all the rows.
`static boolean`	`FORCE_DROP` Allow replacing of table to force the drop, this may require several passes.
`protected org.eclipse.persistence.internal.sessions.DatabaseSessionImpl`	`session`

Constructor Summary

Constructors
Constructor and Description

SchemaManager(DatabaseSession session)

SchemaManager(org.eclipse.persistence.internal.sessions.DatabaseSessionImpl session)

Constructors
Constructor and Description
`SchemaManager(DatabaseSession session)`
`SchemaManager(org.eclipse.persistence.internal.sessions.DatabaseSessionImpl session)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`alterSequence(SequenceDefinition sequenceDefinition)` Use the definition to alter sequence.
`void`	`appendToDDLWriter(java.lang.String stringToWrite)` PUBLIC: If the schema manager is writing to a writer, append this string to that writer.
`void`	`appendToDDLWriter(java.io.Writer schemaWriter, java.lang.String stringToWrite)`
`void`	`buildFieldTypes(TableDefinition tableDef)` INTERNAL: builds the field names based on the type read in from the builder
`protected SequenceDefinition`	`buildSequenceDefinition(Sequence sequence)`
`protected java.util.HashSet<SequenceDefinition>`	`buildSequenceDefinitions()` INTERNAL: Build the sequence definitions.
`boolean`	`checkTableExists(TableDefinition table)` Check if the table exists by issuing a select.
`void`	`closeDDLWriter()` PUBLIC: Close the schema writer.
`void`	`closeDDLWriter(java.io.Writer schemaWriter)`
`protected void`	`collectDatabaseSchemasForDrop(DatabaseObjectDefinition databaseObjectDefinition)` INTERNAL: Called when dropping tables.
`void`	`createConstraints(TableDefinition tableDefinition)` Use the table definition to add the constraints to the database, this is normally done in two steps to avoid dependencies.
`void`	`createDefaultTables(boolean generateFKConstraints)` Create the default table schema for the project this session associated with.
`void`	`createObject(DatabaseObjectDefinition databaseObjectDefinition)` Use the definition object to create the schema entity on the database.
`protected void`	`createOrReplaceSequences(boolean create)` Common implementor for createSequence and replaceSequence
`protected void`	`createOrReplaceSequences(boolean createSequenceTables, boolean createSequences)` Common implementor for createSequence and replaceSequence, distinguishes between sequence tables and sequence objects
`void`	`createSequences()` Create all the receiver's sequences on the database for all of the loaded descriptors.
`void`	`dropConstraints(TableDefinition tableDefinition)` Use the table definition to drop the constraints from the table, this is normally done in two steps to avoid dependencies.
`void`	`dropDatabaseSchemas()` INTERNAL: Iterate over the schemas that need to be dropped.
`void`	`dropDefaultTables()` Create the default table schema for the project this session associated with.
`void`	`dropObject(DatabaseObjectDefinition databaseObjectDefinition)` Use the definition object to drop the schema entity from the database.
`protected void`	`dropSequences()` This will drop the database schemas if managing the database schemas.
`void`	`dropTable(java.lang.String tableName)` Drop (delete) the table named tableName from the database.
`void`	`extendDefaultTables(boolean generateFKConstraints)` Create or extend the default table schema for the project this session associated with.
`void`	`finalize()` INTERNAL: Close the schema writer when the schema manger is garbage collected
`void`	`generateStoredProcedures()` PUBLIC: Use this method to generate stored procedures based on the dynamic SQL generated for your mappings and descriptors.
`void`	`generateStoredProcedures(java.io.Writer writer)` PUBLIC: Use this method to generate stored procedures based on the dynamic SQL generated for your mappings and descriptors.
`void`	`generateStoredProceduresAndAmendmentClass(java.lang.String path, java.lang.String fullyQualifiedClassName)` PUBLIC: Use this method to generate stored procedures based on the dynamic SQL generated for your mappings and descriptors.
`void`	`generateStoredProceduresAndAmendmentClass(java.io.Writer writer, java.lang.String fullyQualifiedClassName)` PUBLIC: Use this method to generate stored procedures based on the dynamic SQL generated for your mappings and descriptors.
`protected org.eclipse.persistence.internal.databaseaccess.DatabaseAccessor`	`getAccessor()` Return the appropriate accessor.
`java.util.Vector`	`getAllColumnNames(java.lang.String tableName)` Get a description of table columns available in a catalog.
`java.util.Vector`	`getAllColumnNames(java.lang.String creatorName, java.lang.String tableName)` Get a description of table columns available in a catalog.
`java.util.Vector`	`getAllTableNames()` Get a description of tables available in a catalog.
`java.util.Vector`	`getAllTableNames(java.lang.String creatorName)` Get a description of table columns available in a catalog.
`java.util.Vector`	`getColumnInfo(java.lang.String catalog, java.lang.String schema, java.lang.String tableName, java.lang.String columnName)` Get a description of table columns available in a catalog.
`protected TableCreator`	`getDefaultTableCreator(boolean generateFKConstraints)` Construct the default TableCreator.
`protected java.io.Writer`	`getDropSchemaWriter()`
`org.eclipse.persistence.internal.sessions.AbstractSession`	`getSession()`
`java.util.Vector`	`getTableInfo(java.lang.String catalog, java.lang.String schema, java.lang.String tableName, java.lang.String[] types)` Get a description of tables available in a catalog.
`protected java.io.Writer`	`getWriter(java.lang.String fileName)`
`void`	`outputCreateDDLToFile(java.lang.String fileName)`
`void`	`outputCreateDDLToWriter(java.io.Writer createWriter)`
`void`	`outputDDLToDatabase()` PUBLIC: Output all DDL statements directly to the database.
`void`	`outputDDLToFile(java.lang.String fileName)` PUBLIC: Output all DDL statements to a file writer specified by the name in the parameter.
`void`	`outputDDLToWriter(java.io.Writer schemaWriter)` PUBLIC: Output all DDL statements to a writer specified in the parameter.
`void`	`outputDropDDLToFile(java.lang.String fileName)`
`void`	`outputDropDDLToWriter(java.io.Writer dropWriter)`
`protected void`	`processSequenceDefinition(SequenceDefinition definition, boolean createTables, boolean createSequences, boolean replace, java.util.HashSet<java.lang.String> createdTableNames, java.util.HashSet<java.lang.String> droppedTableNames)` Method creates database tables/objects.
`protected void`	`processSequenceDefinitions(boolean createSequenceTables, boolean createSequences, boolean replaceSequences)` Common implementor for createSequence and replaceSequence, distinguishes between sequence tables and sequence objects
`void`	`replaceDefaultTables()` Drop and recreate the default table schema for the project this session associated with.
`void`	`replaceDefaultTables(boolean createSequenceTables, boolean generateFKConstraints)` Drop and recreate the default table schema for the project this session associated with.
`void`	`replaceDefaultTables(boolean createSequenceTables, boolean createSequences, boolean generateFKConstraints)` Drop and recreate the default table schema for the project this session associated with.
`void`	`replaceObject(DatabaseObjectDefinition databaseDefinition)` Use the definition object to drop and recreate the schema entity on the database.
`void`	`replaceSequences()` Drop and recreate all the receiver's sequences on the database for all of the loaded descriptors.
`void`	`setCreateDatabaseSchemas(boolean createDatabaseSchemas)` INTERNAL: Set to true if database schemas should be built during the DDL generation.
`void`	`setCreateSQLFiles(boolean genFlag)`
`void`	`setSession(org.eclipse.persistence.internal.sessions.DatabaseSessionImpl session)`
`protected boolean`	`shouldCreateDatabaseSchema(DatabaseObjectDefinition databaseObjectDefinition, java.util.Set<java.lang.String> createdDatabaseSchemas)` INTERNAL: Returns true if a database schema should be created during ddl generation for the given databaseObjectDefinition.
`boolean`	`shouldWriteToDatabase()` PUBLIC: Return true if this SchemaManager should write to the database directly

Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - session
```
protected org.eclipse.persistence.internal.sessions.DatabaseSessionImpl session
```
  - createSchemaWriter
```
protected java.io.Writer createSchemaWriter
```
  - dropSchemaWriter
```
protected java.io.Writer dropSchemaWriter
```
  - createSQLFiles
```
protected boolean createSQLFiles
```
  - defaultTableCreator
```
protected TableCreator defaultTableCreator
```
  - FAST_TABLE_CREATOR
```
public static boolean FAST_TABLE_CREATOR
```
    Allow table creator to occur "fast" by just deleting all the rows.
  - FORCE_DROP
```
public static boolean FORCE_DROP
```
    Allow replacing of table to force the drop, this may require several passes.
  - createDatabaseSchemas
```
protected boolean createDatabaseSchemas
```
    Flag to determine if database schemas should be created during DDL generation
  - createdDatabaseSchemas
```
protected java.util.HashSet<java.lang.String> createdDatabaseSchemas
```
  - createdDatabaseSchemasOnDatabase
```
protected java.util.HashSet<java.lang.String> createdDatabaseSchemasOnDatabase
```
  - dropDatabaseSchemas
```
protected java.util.HashMap<java.lang.String,DatabaseObjectDefinition> dropDatabaseSchemas
```
- Constructor Detail
  - SchemaManager
```
public SchemaManager(org.eclipse.persistence.internal.sessions.DatabaseSessionImpl session)
```
  - SchemaManager
```
public SchemaManager(DatabaseSession session)
```
- Method Detail
  - getDropSchemaWriter
```
protected java.io.Writer getDropSchemaWriter()
```
  - appendToDDLWriter
```
public void appendToDDLWriter(java.lang.String stringToWrite)
```
    PUBLIC: If the schema manager is writing to a writer, append this string to that writer.
  - appendToDDLWriter
```
public void appendToDDLWriter(java.io.Writer schemaWriter,
                     java.lang.String stringToWrite)
```
  - buildFieldTypes
```
public void buildFieldTypes(TableDefinition tableDef)
```
    INTERNAL: builds the field names based on the type read in from the builder
  - closeDDLWriter
```
public void closeDDLWriter()
```
    PUBLIC: Close the schema writer.
  - closeDDLWriter
```
public void closeDDLWriter(java.io.Writer schemaWriter)
```
  - collectDatabaseSchemasForDrop
```
protected void collectDatabaseSchemasForDrop(DatabaseObjectDefinition databaseObjectDefinition)
```
    INTERNAL: Called when dropping tables. Will build a map of those schemas (and a table that references it) that should be dropped.
  - createConstraints
```
public void createConstraints(TableDefinition tableDefinition)
                       throws EclipseLinkException
```
    Use the table definition to add the constraints to the database, this is normally done in two steps to avoid dependencies.
    
    Throws:
    
    EclipseLinkException
  - createObject
```
public void createObject(DatabaseObjectDefinition databaseObjectDefinition)
                  throws EclipseLinkException
```
    Use the definition object to create the schema entity on the database. This is used for creating tables, views, procedures ... etc ...
    
    Throws:
    
    EclipseLinkException
  - createSequences
```
public void createSequences()
                     throws EclipseLinkException
```
    Create all the receiver's sequences on the database for all of the loaded descriptors.
    
    Throws:
    
    EclipseLinkException
  - setCreateDatabaseSchemas
```
public void setCreateDatabaseSchemas(boolean createDatabaseSchemas)
```
    INTERNAL: Set to true if database schemas should be built during the DDL generation.
  - setCreateSQLFiles
```
public void setCreateSQLFiles(boolean genFlag)
```
  - replaceSequences
```
public void replaceSequences()
                      throws EclipseLinkException
```
    Drop and recreate all the receiver's sequences on the database for all of the loaded descriptors.
    
    Throws:
    
    EclipseLinkException
  - createOrReplaceSequences
```
protected void createOrReplaceSequences(boolean create)
                                 throws EclipseLinkException
```
    Common implementor for createSequence and replaceSequence
    
    Parameters:
    create - - true to create the sequences, false to replace them (dropped then create)
    
    Throws:
    
    EclipseLinkException
  - createOrReplaceSequences
```
protected void createOrReplaceSequences(boolean createSequenceTables,
                            boolean createSequences)
                                 throws EclipseLinkException
```
    Common implementor for createSequence and replaceSequence, distinguishes between sequence tables and sequence objects
    
    Parameters:
    createSequenceTables - - true to create the sequences tables, false to replace them (dropped then create)
    createSequences - - true to create the sequences objects, false to replace them (dropped then create)
    
    Throws:
    
    EclipseLinkException
  - dropSequences
```
protected void dropSequences()
```
    This will drop the database schemas if managing the database schemas.
  - processSequenceDefinition
```
protected void processSequenceDefinition(SequenceDefinition definition,
                             boolean createTables,
                             boolean createSequences,
                             boolean replace,
                             java.util.HashSet<java.lang.String> createdTableNames,
                             java.util.HashSet<java.lang.String> droppedTableNames)
                                  throws EclipseLinkException
```
    Method creates database tables/objects. If create is true, it will attempt to create the object and silently ignore exceptions. If create is false, it will drop the object ignoring any exceptions, then create it if the replace flag is true (otherwise a drop only).
    
    Parameters:
    definition - - the sequence definition
    createTables - - true if table sequence table definitions should be created.
    createSequences - - true if the sequence definition should be created, false if it should be dropped.
    replace - - true if table definitions and sequence definitions should be replaced.
    
    Throws:
    
    EclipseLinkException
  - processSequenceDefinitions
```
protected void processSequenceDefinitions(boolean createSequenceTables,
                              boolean createSequences,
                              boolean replaceSequences)
                                   throws EclipseLinkException
```
    Common implementor for createSequence and replaceSequence, distinguishes between sequence tables and sequence objects
    
    Parameters:
    createSequenceTables - - true to create the sequences tables, false to replace them (dropped then create)
    createSequences - - true to create the sequences objects, false to replace them (dropped then create)
    replaceSequences - - true to actually replace, false to drop only.
    
    Throws:
    
    EclipseLinkException
  - buildSequenceDefinitions
```
protected java.util.HashSet<SequenceDefinition> buildSequenceDefinitions()
```
    INTERNAL: Build the sequence definitions.
  - checkTableExists
```
public boolean checkTableExists(TableDefinition table)
```
    Check if the table exists by issuing a select.
  - buildSequenceDefinition
```
protected SequenceDefinition buildSequenceDefinition(Sequence sequence)
```
  - dropConstraints
```
public void dropConstraints(TableDefinition tableDefinition)
                     throws EclipseLinkException
```
    Use the table definition to drop the constraints from the table, this is normally done in two steps to avoid dependencies.
    
    Throws:
    
    EclipseLinkException
  - dropObject
```
public void dropObject(DatabaseObjectDefinition databaseObjectDefinition)
                throws EclipseLinkException
```
    Use the definition object to drop the schema entity from the database. This is used for dropping tables, views, procedures ... etc ...
    
    Throws:
    
    EclipseLinkException
  - dropTable
```
public void dropTable(java.lang.String tableName)
               throws EclipseLinkException
```
    Drop (delete) the table named tableName from the database.
    
    Throws:
    
    EclipseLinkException
  - finalize
```
public void finalize()
```
    INTERNAL: Close the schema writer when the schema manger is garbage collected
    
    Overrides:
    
    finalize in class java.lang.Object
  - generateStoredProcedures
```
public void generateStoredProcedures()
                              throws EclipseLinkException
```
    PUBLIC: Use this method to generate stored procedures based on the dynamic SQL generated for your mappings and descriptors. This should be used with caution as it maintenance will be high. Stored procedures may be generated either directly on the database or to a file.
    
    Throws:
    
    EclipseLinkException
  - generateStoredProcedures
```
public void generateStoredProcedures(java.io.Writer writer)
                              throws EclipseLinkException
```
    PUBLIC: Use this method to generate stored procedures based on the dynamic SQL generated for your mappings and descriptors. This should be used with caution as it maintenance will be high. Stored procedures may be generated either directly on the database or to a file.
    
    Throws:
    
    EclipseLinkException
  - generateStoredProceduresAndAmendmentClass
```
public void generateStoredProceduresAndAmendmentClass(java.io.Writer writer,
                                             java.lang.String fullyQualifiedClassName)
                                               throws EclipseLinkException
```
    PUBLIC: Use this method to generate stored procedures based on the dynamic SQL generated for your mappings and descriptors. This should be used with caution as it maintenance will be high. Stored procedures may be generated either directly on the database or to a file.
    
    Throws:
    
    EclipseLinkException
  - generateStoredProceduresAndAmendmentClass
```
public void generateStoredProceduresAndAmendmentClass(java.lang.String path,
                                             java.lang.String fullyQualifiedClassName)
                                               throws EclipseLinkException
```
    PUBLIC: Use this method to generate stored procedures based on the dynamic SQL generated for your mappings and descriptors. This should be used with caution as it maintenance will be high. Stored procedures may be generated either directly on the database or to a file.
    
    Throws:
    
    EclipseLinkException
  - getAccessor
```
protected org.eclipse.persistence.internal.databaseaccess.DatabaseAccessor getAccessor()
```
    Return the appropriate accessor. Assume we are dealing with a JDBC accessor.
  - getAllColumnNames
```
public java.util.Vector getAllColumnNames(java.lang.String tableName)
                                   throws DatabaseException
```
    Get a description of table columns available in a catalog.
    Each column description has the following columns:
    1. TABLE_CAT String => table catalog (may be null)
    2. TABLE_SCHEM String => table schema (may be null)
    3. TABLE_NAME String => table name
    4. COLUMN_NAME String => column name
    5. DATA_TYPE short => SQL type from java.sql.Types
    6. TYPE_NAME String => Data source dependent type name
    7. COLUMN_SIZE int => column size. For char or date types this is the maximum number of characters, for numeric or decimal types this is precision.
    8. BUFFER_LENGTH is not used.
    9. DECIMAL_DIGITS int => the number of fractional digits
    10. NUM_PREC_RADIX int => Radix (typically either 10 or 2)
    11. NULLABLE int => is NULL allowed?
      
      columnNoNulls - might not allow NULL values
      columnNullable - definitely allows NULL values
      columnNullableUnknown - nullability unknown
    12. REMARKS String => comment describing column (may be null)
    13. COLUMN_DEF String => default value (may be null)
    14. SQL_DATA_TYPE int => unused
    15. SQL_DATETIME_SUB int => unused
    16. CHAR_OCTET_LENGTH int => for char types the maximum number of bytes in the column
    17. ORDINAL_POSITION int => index of column in table (starting at 1)
    18. IS_NULLABLE String => "NO" means column definitely does not allow NULL values; "YES" means the column might allow NULL values. An empty string means nobody knows.
    Parameters:
    tableName - a table name pattern
    
    Returns:
    a Vector of Records.
    
    Throws:
    
    DatabaseException
  - getAllColumnNames
```
public java.util.Vector getAllColumnNames(java.lang.String creatorName,
                                 java.lang.String tableName)
                                   throws DatabaseException
```
    Get a description of table columns available in a catalog.
    Each column description has the following columns:
    1. TABLE_CAT String => table catalog (may be null)
    2. TABLE_SCHEM String => table schema (may be null)
    3. TABLE_NAME String => table name
    4. COLUMN_NAME String => column name
    5. DATA_TYPE short => SQL type from java.sql.Types
    6. TYPE_NAME String => Data source dependent type name
    7. COLUMN_SIZE int => column size. For char or date types this is the maximum number of characters, for numeric or decimal types this is precision.
    8. BUFFER_LENGTH is not used.
    9. DECIMAL_DIGITS int => the number of fractional digits
    10. NUM_PREC_RADIX int => Radix (typically either 10 or 2)
    11. NULLABLE int => is NULL allowed?
      
      columnNoNulls - might not allow NULL values
      columnNullable - definitely allows NULL values
      columnNullableUnknown - nullability unknown
    12. REMARKS String => comment describing column (may be null)
    13. COLUMN_DEF String => default value (may be null)
    14. SQL_DATA_TYPE int => unused
    15. SQL_DATETIME_SUB int => unused
    16. CHAR_OCTET_LENGTH int => for char types the maximum number of bytes in the column
    17. ORDINAL_POSITION int => index of column in table (starting at 1)
    18. IS_NULLABLE String => "NO" means column definitely does not allow NULL values; "YES" means the column might allow NULL values. An empty string means nobody knows.
    Parameters:
    creatorName - a schema name pattern; "" retrieves those without a schema
    tableName - a table name pattern
    
    Returns:
    a Vector of Records.
    
    Throws:
    
    DatabaseException
  - getAllTableNames
```
public java.util.Vector getAllTableNames()
                                  throws DatabaseException
```
    Get a description of tables available in a catalog.
    Each table description has the following columns:
    1. TABLE_CAT String => table catalog (may be null)
    2. TABLE_SCHEM String => table schema (may be null)
    3. TABLE_NAME String => table name
    4. TABLE_TYPE String => table type. Typical types are "TABLE", "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", "LOCAL TEMPORARY", "ALIAS", "SYNONYM".
    5. REMARKS String => explanatory comment on the table
    Note: Some databases may not return information for all tables.
    Returns:
    a Vector of Records.
    
    Throws:
    
    DatabaseException
  - getAllTableNames
```
public java.util.Vector getAllTableNames(java.lang.String creatorName)
                                  throws DatabaseException
```
    Get a description of table columns available in a catalog.
    Each column description has the following columns:
    1. TABLE_CAT String => table catalog (may be null)
    2. TABLE_SCHEM String => table schema (may be null)
    3. TABLE_NAME String => table name
    4. COLUMN_NAME String => column name
    5. DATA_TYPE short => SQL type from java.sql.Types
    6. TYPE_NAME String => Data source dependent type name
    7. COLUMN_SIZE int => column size. For char or date types this is the maximum number of characters, for numeric or decimal types this is precision.
    8. BUFFER_LENGTH is not used.
    9. DECIMAL_DIGITS int => the number of fractional digits
    10. NUM_PREC_RADIX int => Radix (typically either 10 or 2)
    11. NULLABLE int => is NULL allowed?
      
      columnNoNulls - might not allow NULL values
      columnNullable - definitely allows NULL values
      columnNullableUnknown - nullability unknown
    12. REMARKS String => comment describing column (may be null)
    13. COLUMN_DEF String => default value (may be null)
    14. SQL_DATA_TYPE int => unused
    15. SQL_DATETIME_SUB int => unused
    16. CHAR_OCTET_LENGTH int => for char types the maximum number of bytes in the column
    17. ORDINAL_POSITION int => index of column in table (starting at 1)
    18. IS_NULLABLE String => "NO" means column definitely does not allow NULL values; "YES" means the column might allow NULL values. An empty string means nobody knows.
    Parameters:
    creatorName - a schema name pattern; "" retrieves those without a schema
    
    Returns:
    a Vector of Records.
    
    Throws:
    
    DatabaseException
  - getColumnInfo
```
public java.util.Vector getColumnInfo(java.lang.String catalog,
                             java.lang.String schema,
                             java.lang.String tableName,
                             java.lang.String columnName)
                               throws DatabaseException
```
    Get a description of table columns available in a catalog.
    Only column descriptions matching the catalog, schema, table and column name criteria are returned. They are ordered by TABLE_SCHEM, TABLE_NAME and ORDINAL_POSITION.
    Each column description has the following columns:
    1. TABLE_CAT String => table catalog (may be null)
    2. TABLE_SCHEM String => table schema (may be null)
    3. TABLE_NAME String => table name
    4. COLUMN_NAME String => column name
    5. DATA_TYPE short => SQL type from java.sql.Types
    6. TYPE_NAME String => Data source dependent type name
    7. COLUMN_SIZE int => column size. For char or date types this is the maximum number of characters, for numeric or decimal types this is precision.
    8. BUFFER_LENGTH is not used.
    9. DECIMAL_DIGITS int => the number of fractional digits
    10. NUM_PREC_RADIX int => Radix (typically either 10 or 2)
    11. NULLABLE int => is NULL allowed?
      
      columnNoNulls - might not allow NULL values
      columnNullable - definitely allows NULL values
      columnNullableUnknown - nullability unknown
    12. REMARKS String => comment describing column (may be null)
    13. COLUMN_DEF String => default value (may be null)
    14. SQL_DATA_TYPE int => unused
    15. SQL_DATETIME_SUB int => unused
    16. CHAR_OCTET_LENGTH int => for char types the maximum number of bytes in the column
    17. ORDINAL_POSITION int => index of column in table (starting at 1)
    18. IS_NULLABLE String => "NO" means column definitely does not allow NULL values; "YES" means the column might allow NULL values. An empty string means nobody knows.
    Parameters:
    catalog - a catalog name; "" retrieves those without a catalog; null means drop catalog name from the selection criteria
    schema - a schema name pattern; "" retrieves those without a schema
    tableName - a table name pattern
    columnName - a column name pattern
    
    Returns:
    a Vector of Records.
    
    Throws:
    
    DatabaseException
  - getSession
```
public org.eclipse.persistence.internal.sessions.AbstractSession getSession()
```
  - getTableInfo
```
public java.util.Vector getTableInfo(java.lang.String catalog,
                            java.lang.String schema,
                            java.lang.String tableName,
                            java.lang.String[] types)
                              throws DatabaseException
```
    Get a description of tables available in a catalog.
    Only table descriptions matching the catalog, schema, table name and type criteria are returned. They are ordered by TABLE_TYPE, TABLE_SCHEM and TABLE_NAME.
    Each table description has the following columns:
    1. TABLE_CAT String => table catalog (may be null)
    2. TABLE_SCHEM String => table schema (may be null)
    3. TABLE_NAME String => table name
    4. TABLE_TYPE String => table type. Typical types are "TABLE", "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", "LOCAL TEMPORARY", "ALIAS", "SYNONYM".
    5. REMARKS String => explanatory comment on the table
    Note: Some databases may not return information for all tables.
    Parameters:
    catalog - a catalog name; "" retrieves those without a catalog; null means drop catalog name from the selection criteria
    schema - a schema name pattern; "" retrieves those without a schema
    tableName - a table name pattern
    types - a list of table types to include; null returns all types
    
    Returns:
    a Vector of Records.
    
    Throws:
    
    DatabaseException
  - outputDDLToDatabase
```
public void outputDDLToDatabase()
```
    PUBLIC: Output all DDL statements directly to the database.
  - outputDDLToFile
```
public void outputDDLToFile(java.lang.String fileName)
```
    PUBLIC: Output all DDL statements to a file writer specified by the name in the parameter.
  - outputCreateDDLToFile
```
public void outputCreateDDLToFile(java.lang.String fileName)
```
  - outputDropDDLToFile
```
public void outputDropDDLToFile(java.lang.String fileName)
```
  - getWriter
```
protected java.io.Writer getWriter(java.lang.String fileName)
```
  - outputDDLToWriter
```
public void outputDDLToWriter(java.io.Writer schemaWriter)
```
    PUBLIC: Output all DDL statements to a writer specified in the parameter.
  - outputCreateDDLToWriter
```
public void outputCreateDDLToWriter(java.io.Writer createWriter)
```
  - outputDropDDLToWriter
```
public void outputDropDDLToWriter(java.io.Writer dropWriter)
```
  - replaceObject
```
public void replaceObject(DatabaseObjectDefinition databaseDefinition)
                   throws EclipseLinkException
```
    Use the definition object to drop and recreate the schema entity on the database. This is used for dropping tables, views, procedures ... etc ... This handles and ignore any database error while dropping in case the object did not previously exist.
    
    Throws:
    
    EclipseLinkException
  - getDefaultTableCreator
```
protected TableCreator getDefaultTableCreator(boolean generateFKConstraints)
```
    Construct the default TableCreator. If the default TableCreator is already created, just returns it.
  - createDefaultTables
```
public void createDefaultTables(boolean generateFKConstraints)
```
    Create the default table schema for the project this session associated with.
  - dropDatabaseSchemas
```
public void dropDatabaseSchemas()
```
    INTERNAL: Iterate over the schemas that need to be dropped.
  - dropDefaultTables
```
public void dropDefaultTables()
```
    Create the default table schema for the project this session associated with.
  - replaceDefaultTables
```
public void replaceDefaultTables()
                          throws EclipseLinkException
```
    Drop and recreate the default table schema for the project this session associated with.
    
    Throws:
    
    EclipseLinkException
  - replaceDefaultTables
```
public void replaceDefaultTables(boolean createSequenceTables,
                        boolean generateFKConstraints)
                          throws EclipseLinkException
```
    Drop and recreate the default table schema for the project this session associated with.
    
    Throws:
    
    EclipseLinkException
  - replaceDefaultTables
```
public void replaceDefaultTables(boolean createSequenceTables,
                        boolean createSequences,
                        boolean generateFKConstraints)
                          throws EclipseLinkException
```
    Drop and recreate the default table schema for the project this session associated with.
    
    Throws:
    
    EclipseLinkException
  - setSession
```
public void setSession(org.eclipse.persistence.internal.sessions.DatabaseSessionImpl session)
```
  - shouldCreateDatabaseSchema
```
protected boolean shouldCreateDatabaseSchema(DatabaseObjectDefinition databaseObjectDefinition,
                                 java.util.Set<java.lang.String> createdDatabaseSchemas)
```
    INTERNAL: Returns true if a database schema should be created during ddl generation for the given databaseObjectDefinition.
  - shouldWriteToDatabase
```
public boolean shouldWriteToDatabase()
```
    PUBLIC: Return true if this SchemaManager should write to the database directly
  - alterSequence
```
public void alterSequence(SequenceDefinition sequenceDefinition)
                   throws EclipseLinkException
```
    Use the definition to alter sequence.
    
    Throws:
    
    EclipseLinkException
  - extendDefaultTables
```
public void extendDefaultTables(boolean generateFKConstraints)
                         throws EclipseLinkException
```
    Create or extend the default table schema for the project this session associated with.
    
    Throws:
    
    EclipseLinkException

Class SchemaManager

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

session

createSchemaWriter

dropSchemaWriter

createSQLFiles

defaultTableCreator

FAST_TABLE_CREATOR

FORCE_DROP

createDatabaseSchemas

createdDatabaseSchemas

createdDatabaseSchemasOnDatabase

dropDatabaseSchemas

Constructor Detail

SchemaManager

SchemaManager

Method Detail

getDropSchemaWriter

appendToDDLWriter

appendToDDLWriter

buildFieldTypes

closeDDLWriter

closeDDLWriter

collectDatabaseSchemasForDrop

createConstraints

createObject

createSequences

setCreateDatabaseSchemas

setCreateSQLFiles

replaceSequences

createOrReplaceSequences

createOrReplaceSequences

dropSequences

processSequenceDefinition

processSequenceDefinitions

buildSequenceDefinitions

checkTableExists

buildSequenceDefinition

dropConstraints

dropObject

dropTable

finalize

generateStoredProcedures

generateStoredProcedures

generateStoredProceduresAndAmendmentClass

generateStoredProceduresAndAmendmentClass

getAccessor

getAllColumnNames

getAllColumnNames

getAllTableNames

getAllTableNames

getColumnInfo

getSession

getTableInfo

outputDDLToDatabase

outputDDLToFile

outputCreateDDLToFile

outputDropDDLToFile

getWriter

outputDDLToWriter

outputCreateDDLToWriter

outputDropDDLToWriter

replaceObject

getDefaultTableCreator

createDefaultTables

dropDatabaseSchemas

dropDefaultTables

replaceDefaultTables

replaceDefaultTables

replaceDefaultTables

setSession

shouldCreateDatabaseSchema

shouldWriteToDatabase

alterSequence

extendDefaultTables