/** * INTERNAL: * Iterate over the schemas that need to be dropped. */ public void dropDatabaseSchemas() { for (DatabaseObjectDefinition dod : dropDatabaseSchemas.values()) { if (shouldWriteToDatabase()) { dod.dropDatabaseSchemaOnDatabase(getSession()); } else { dod.dropDatabaseSchema(getSession(), getDropSchemaWriter()); appendToDDLWriter(getDropSchemaWriter(), "\n"); } } }
/** * INTERNAL: * Close the schema writer when the schema manger is garbage collected */ public void finalize() { try { this.closeDDLWriter(); } catch (ValidationException exception) { // do nothing } }
/** * Create all the receiver's sequences on the database for all of the loaded descriptors. */ public void createSequences() throws EclipseLinkException { createOrReplaceSequences(true); }
schemaManager.buildFieldTypes((TableDefinition)enumtr.nextElement()); if (!table.getName().equals(sequenceTableName)) { try { schemaManager.createObject(table); session.getSessionLog().log(SessionLog.FINEST, "default_tables_created", table.getFullName()); } catch (DatabaseException ex) { schemaManager.createUniqueConstraints((TableDefinition)enumtr.nextElement()); } catch (DatabaseException ex) { if (!shouldIgnoreDatabaseException()) { schemaManager.createForeignConstraints((TableDefinition)enumtr.nextElement()); } catch (DatabaseException ex) { if (!shouldIgnoreDatabaseException()) { schemaManager.createSequences();
private void replaceTablesAndConstraints(final SchemaManager schemaManager, final org.eclipse.persistence.sessions.DatabaseSession session) { for (Enumeration enumtr = getTableDefinitions().elements(); enumtr.hasMoreElements();) { schemaManager.buildFieldTypes((TableDefinition)enumtr.nextElement()); for (Enumeration enumtr = getTableDefinitions().elements(); enumtr.hasMoreElements();) { try { schemaManager.dropConstraints((TableDefinition)enumtr.nextElement()); } catch (org.eclipse.persistence.exceptions.DatabaseException dbE) { if (!table.getName().equals(sequenceTableName)) { try { schemaManager.replaceObject(table); } catch (DatabaseException ex) { if (!shouldIgnoreDatabaseException()) { schemaManager.createUniqueConstraints((TableDefinition)enumtr.nextElement()); } catch (DatabaseException ex) { if (!shouldIgnoreDatabaseException()) { schemaManager.createForeignConstraints((TableDefinition)enumtr.nextElement()); } catch (DatabaseException ex) { if (!shouldIgnoreDatabaseException()) {
/** * 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. */ public void replaceObject(DatabaseObjectDefinition databaseDefinition) throws EclipseLinkException { // PERF: Allow a special "fast" flag to be set on the session causes a delete from the table instead of a replace. boolean fast = FAST_TABLE_CREATOR; if (fast && (databaseDefinition instanceof TableDefinition)) { session.executeNonSelectingSQL("DELETE FROM " + databaseDefinition.getName()); } else if (fast && (databaseDefinition instanceof StoredProcedureDefinition)) { // do nothing } else { // CR 3870467, do not log stack boolean shouldLogExceptionStackTrace = getSession().getSessionLog().shouldLogExceptionStackTrace(); if (shouldLogExceptionStackTrace) { getSession().getSessionLog().setShouldLogExceptionStackTrace(false); } try { dropObject(databaseDefinition); } catch (DatabaseException exception) { // Ignore error } finally { if (shouldLogExceptionStackTrace) { getSession().getSessionLog().setShouldLogExceptionStackTrace(true); } } createObject(databaseDefinition); } }
boolean alreadyExists = false; if (check && CHECK_EXISTENCE && schemaManager.shouldWriteToDatabase()) { alreadyExists = schemaManager.checkTableExists(table); schemaManager.createObject(table); session.getSessionLog().log(SessionLog.FINEST, SessionLog.DDL, "default_tables_created", table.getFullName()); } catch (DatabaseException ex) { schemaManager.createOrReplaceSequences(createSequenceTables, createSequences);
boolean usesBatchWriting = false; if (getSession().getPlatform().usesBatchWriting()) { usesBatchWriting = true; getSession().getPlatform().setUsesBatchWriting(false); if (shouldWriteToDatabase()) { if (shouldCreateDatabaseSchema(databaseObjectDefinition, createdDatabaseSchemasOnDatabase)) { databaseObjectDefinition.createDatabaseSchemaOnDatabase(getSession(), createdDatabaseSchemasOnDatabase); databaseObjectDefinition.createOnDatabase(getSession()); } else { if (shouldCreateDatabaseSchema(databaseObjectDefinition, createdDatabaseSchemas)) { databaseObjectDefinition.createDatabaseSchema(getSession(), createSchemaWriter, createdDatabaseSchemas); appendToDDLWriter(createSchemaWriter, "\n"); databaseObjectDefinition.createObject(getSession(), createSchemaWriter); if (createSQLFiles){ this.appendToDDLWriter(createSchemaWriter, getSession().getPlatform().getStoredProcedureTerminationToken()); this.appendToDDLWriter(createSchemaWriter, "\n"); databaseObjectDefinition.postCreateObject(getSession(), createSchemaWriter, createSQLFiles); } finally { if (usesBatchWriting) { getSession().getPlatform().setUsesBatchWriting(true);
boolean exists = checkTableExists(tableDefinition); if ((shouldWriteToDatabase() && ! exists) || ! shouldWriteToDatabase()) { createObject(tableDefinition); dropObject(tableDefinition); createObject(tableDefinition); createObject(definition); } else { try { dropObject(definition); } catch (DatabaseException exception) { createObject(definition);
boolean alreadyExists = false; if (CHECK_EXISTENCE && schemaManager.shouldWriteToDatabase()) { alreadyExists = schemaManager.checkTableExists(table); schemaManager.createObject(table); session.getSessionLog().log(SessionLog.FINEST, SessionLog.DDL, "default_tables_created", table.getFullName()); } catch (DatabaseException exception) { schemaManager.createSequences();
/** * Create constraints. */ public void createConstraints(DatabaseSession session) { //CR2612669 createConstraints(session, new SchemaManager(session)); }
/** * Use the definition object to create the schema entity on the database. * This is used for creating tables, views, procedures ... etc ... */ public void createObject(DatabaseObjectDefinition databaseObjectDefinition) throws EclipseLinkException { boolean usesBatchWriting = false; if (getSession().getPlatform().usesBatchWriting()) { usesBatchWriting = true; getSession().getPlatform().setUsesBatchWriting(false); } try { if (shouldWriteToDatabase()) { databaseObjectDefinition.createOnDatabase(getSession()); } else { databaseObjectDefinition.createObject(getSession(), createSchemaWriter); if (createSQLFiles){ this.appendToDDLWriter(createSchemaWriter, getSession().getPlatform().getStoredProcedureTerminationToken()); } this.appendToDDLWriter(createSchemaWriter, "\n"); databaseObjectDefinition.postCreateObject(getSession(), createSchemaWriter, createSQLFiles); } } finally { if (usesBatchWriting) { getSession().getPlatform().setUsesBatchWriting(true); } } }
/** * Create constraints. */ public void createConstraints(org.eclipse.persistence.sessions.DatabaseSession session, SchemaManager schemaManager) { for (Enumeration enumtr = getTableDefinitions().elements(); enumtr.hasMoreElements();) { schemaManager.buildFieldTypes((TableDefinition)enumtr.nextElement()); } // Unique constraints should be generated before foreign key constraints, // because foreign key constraints can reference unique constraints for (Enumeration enumtr = getTableDefinitions().elements(); enumtr.hasMoreElements();) { try { schemaManager.createUniqueConstraints((TableDefinition)enumtr.nextElement()); } catch (DatabaseException ex) { if (!shouldIgnoreDatabaseException()) { throw ex; } } } for (Enumeration enumtr = getTableDefinitions().elements(); enumtr.hasMoreElements();) { try { schemaManager.createForeignConstraints((TableDefinition)enumtr.nextElement()); } catch (DatabaseException ex) { if (!shouldIgnoreDatabaseException()) { throw ex; } } } }
/** * Drop the tables from the database. */ public void dropTables(org.eclipse.persistence.sessions.DatabaseSession session, SchemaManager schemaManager) { for (Enumeration enumtr = getTableDefinitions().elements(); enumtr.hasMoreElements();) { schemaManager.buildFieldTypes((TableDefinition)enumtr.nextElement()); } for (Enumeration enumtr = getTableDefinitions().elements(); enumtr.hasMoreElements();) { try { schemaManager.dropConstraints((TableDefinition)enumtr.nextElement()); } catch (org.eclipse.persistence.exceptions.DatabaseException dbE) { //ignore } } String sequenceTableName = getSequenceTableName(session); for (Enumeration enumtr = getTableDefinitions().elements(); enumtr.hasMoreElements();) { // Must not create sequence table as done in createSequences. TableDefinition table = (TableDefinition)enumtr.nextElement(); if (!table.getName().equals(sequenceTableName)) { try { schemaManager.dropObject(table); } catch (DatabaseException ex) { if (!shouldIgnoreDatabaseException()) { throw ex; } } } } }
/** * INTERNAL: * Build the sequence definitions. */ protected HashSet<SequenceDefinition> buildSequenceDefinitions() { // Remember the processed - to handle each sequence just once. HashSet processedSequenceNames = new HashSet(); HashSet<SequenceDefinition> sequenceDefinitions = new HashSet<SequenceDefinition>(); for (ClassDescriptor descriptor : getSession().getDescriptors().values()) { if (descriptor.usesSequenceNumbers()) { String seqName = descriptor.getSequenceNumberName(); if (seqName == null) { seqName = getSession().getDatasourcePlatform().getDefaultSequence().getName(); } if (! processedSequenceNames.contains(seqName)) { processedSequenceNames.add(seqName); Sequence sequence = getSession().getDatasourcePlatform().getSequence(seqName); SequenceDefinition sequenceDefinition = buildSequenceDefinition(sequence); if (sequenceDefinition != null) { sequenceDefinitions.add(sequenceDefinition); } } } } return sequenceDefinitions; }
mgr.outputCreateDDLToWriter((Writer) createDDLJdbc); } else { mgr.outputCreateDDLToFile(appLocationPrefix + createDDLJdbc); mgr.outputDropDDLToWriter((Writer) dropDDLJdbc); } else if (dropDDLJdbc instanceof String) { mgr.outputDropDDLToFile(appLocationPrefix + dropDDLJdbc); } else { throw new PersistenceException(ExceptionLocalization.buildMessage("jpa21-ddl-invalid-target-script-type", new Object[]{ dropDDLJdbc , dropDDLJdbc.getClass()})); mgr.setCreateSQLFiles(terminator); generateDefaultTables(mgr, ddlType); mgr.closeDDLWriter();
/** * Create constraints. */ public void createConstraints(List<TableDefinition> tables, DatabaseSession session, SchemaManager schemaManager, boolean build) { buildConstraints(schemaManager, build); // Unique constraints should be generated before foreign key constraints, // because foreign key constraints can reference unique constraints for (TableDefinition table : tables) { try { schemaManager.createUniqueConstraints(table); } catch (DatabaseException ex) { if (!shouldIgnoreDatabaseException()) { throw ex; } } } for (TableDefinition table : tables) { try { schemaManager.createForeignConstraints(table); } catch (DatabaseException ex) { if (!shouldIgnoreDatabaseException()) { throw ex; } } } }
/** * Drop the table constraints from the database. */ public void dropConstraints(org.eclipse.persistence.sessions.DatabaseSession session, SchemaManager schemaManager) { for (Enumeration enumtr = getTableDefinitions().elements(); enumtr.hasMoreElements();) { schemaManager.buildFieldTypes((TableDefinition)enumtr.nextElement()); } for (Enumeration enumtr = getTableDefinitions().elements(); enumtr.hasMoreElements();) { try { schemaManager.dropConstraints((TableDefinition)enumtr.nextElement()); } catch (org.eclipse.persistence.exceptions.DatabaseException dbE) { //ignore } } }
createObject(definition); } catch (DatabaseException exception) { dropObject(definition); } catch (DatabaseException exception) { createObject(definition);
/** * INTERNAL: * Generate and write DDL from the persistence unit metadata to the database. */ protected void writeMetadataDDLToDatabase(TableCreationType tableCreationType, Map props, DatabaseSessionImpl session, ClassLoader classLoader) { SchemaManager mgr = new SchemaManager(session); // Set the create database schemas flag on the schema manager. String createSchemas = getConfigPropertyAsString(SCHEMA_GENERATION_CREATE_DATABASE_SCHEMAS, props); mgr.setCreateDatabaseSchemas(createSchemas != null && createSchemas.equalsIgnoreCase("true")); writeDDLToDatabase(mgr, tableCreationType); }