org.hibernate.boot.model.relational.Database Java Examples

private static Metadata setupMetadataMock() {
  Metadata metadata = mock(Metadata.class);
  Database database = mock(Database.class);
  JdbcEnvironment jdbcEnvironment = mock(JdbcEnvironment.class);
  QualifiedObjectNameFormatter qualifiedObjectNameFormatter =
      mock(QualifiedObjectNameFormatter.class);

  when(metadata.getDatabase()).thenReturn(database);
  when(database.getJdbcEnvironment()).thenReturn(jdbcEnvironment);
  when(jdbcEnvironment.getQualifiedObjectNameFormatter())
      .thenReturn(qualifiedObjectNameFormatter);
  when(qualifiedObjectNameFormatter.format(any(QualifiedTableName.class), any()))
      .thenAnswer(invocation ->
          ((QualifiedTableName) invocation.getArguments()[0]).getTableName().getCanonicalName());

  return metadata;
}
 

protected void migrateTable(
		Table table,
		TableInformation tableInformation,
		Dialect dialect,
		Metadata metadata,
		Formatter formatter,
		ExecutionOptions options,
		GenerationTarget... targets) {
	final Database database = metadata.getDatabase();

	//noinspection unchecked
	applySqlStrings(
			false,
			table.sqlAlterStrings(
					dialect,
					metadata,
					tableInformation,
					getDefaultCatalogName( database, dialect ),
					getDefaultSchemaName( database, dialect )
			),
			formatter,
			options,
			targets
	);
}
 

protected void buildSequence(Database database) {
	final int sourceIncrementSize = getSourceIncrementSize();

	final Namespace namespace = database.locateNamespace(
			logicalQualifiedSequenceName.getCatalogName(),
			logicalQualifiedSequenceName.getSchemaName()
	);
	Sequence sequence = namespace.locateSequence( logicalQualifiedSequenceName.getObjectName() );
	if ( sequence != null ) {
		sequence.validate( initialValue, sourceIncrementSize );
	}
	else {
		sequence = namespace.createSequence( logicalQualifiedSequenceName.getObjectName(), initialValue, sourceIncrementSize );
	}

	this.sequenceName = database.getJdbcEnvironment().getQualifiedObjectNameFormatter().format(
			sequence.getName(),
			database.getJdbcEnvironment().getDialect()
	);
}
 

@Override
public void registerExportables(Database database) {
	if (generator instanceof ExportableProducer) {
		((ExportableProducer) generator).registerExportables( database );
	}
	if (reactiveGenerator instanceof ExportableProducer) {
		((ExportableProducer) reactiveGenerator).registerExportables( database );
	}
}
 

protected void addColumnBinding(SimpleValue value) {
	final String logicalColumnName;
	if ( StringHelper.isNotEmpty( this.logicalColumnName ) ) {
		logicalColumnName = this.logicalColumnName;
	}
	else {
		final ObjectNameNormalizer normalizer = context.getObjectNameNormalizer();
		final Database database = context.getMetadataCollector().getDatabase();
		final ImplicitNamingStrategy implicitNamingStrategy = context.getBuildingOptions()
				.getImplicitNamingStrategy();

		final Identifier implicitName = normalizer.normalizeIdentifierQuoting(
				implicitNamingStrategy.determineBasicColumnName(
						new ImplicitBasicColumnNameSource() {
							@Override
							public AttributePath getAttributePath() {
								return AttributePath.parse( propertyName );
							}

							@Override
							public boolean isCollectionElement() {
								return false;
							}

							@Override
							public MetadataBuildingContext getBuildingContext() {
								return context;
							}
						}
				)
		);
		logicalColumnName = implicitName.render( database.getDialect() );
	}
	context.getMetadataCollector().addColumnNameBinding( value.getTable(), logicalColumnName, getMappingColumn() );
}
 

@Override
public Database getDatabase() {
	// important to delay this instantiation until as late as possible.
	if ( database == null ) {
		this.database = new Database( options );
	}
	return database;
}
 

@Override
public void registerExportables(Database database) {
	final Namespace namespace = database.locateNamespace(
			logicalQualifiedSequenceName.getCatalogName(),
			logicalQualifiedSequenceName.getSchemaName()
	);
	Sequence sequence = namespace.locateSequence( logicalQualifiedSequenceName.getObjectName() );
	if ( sequence != null ) {
		sequence.validate( 1, 1 );
	}
	else {
		sequence = namespace.createSequence(
				logicalQualifiedSequenceName.getObjectName(),
				1,
				1
		);
	}

	final JdbcEnvironment jdbcEnvironment = database.getJdbcEnvironment();
	final Dialect dialect = jdbcEnvironment.getDialect();

	this.sequenceName = jdbcEnvironment.getQualifiedObjectNameFormatter().format(
			sequence.getName(),
			dialect
	);
	this.sql = jdbcEnvironment.getDialect().getSequenceNextValString( sequenceName );
}
 

public ExportableColumn(
		Database database,
		Table table,
		String name,
		BasicType type,
		String dbTypeDeclaration) {
	super( name );
	setValue( new ValueImpl( this, table, type, database ) );
	setSqlType( dbTypeDeclaration );
}
 

public ExportableColumn(Database database, Table table, String name, BasicType type) {
	this(
			database,
			table,
			name,
			type,
			database.getDialect().getTypeName( type.sqlTypes( null )[0] )
	);
}
 

public Database getDatabase() {
    return database;
}
 

public Database getDatabase() {
	return database;
}
 

@Override
public Database getDatabase() {
	return database;
}
 

MetadataImpl(
		UUID uuid,
		MetadataBuildingOptions metadataBuildingOptions,
		MutableIdentifierGeneratorFactory identifierGeneratorFactory,
		Map<String, PersistentClass> entityBindingMap,
		Map<Class, MappedSuperclass> mappedSuperclassMap,
		Map<String, Collection> collectionBindingMap,
		Map<String, TypeDefinition> typeDefinitionMap,
		Map<String, FilterDefinition> filterDefinitionMap,
		Map<String, FetchProfile> fetchProfileMap,
		Map<String, String> imports,
		Map<String, IdentifierGeneratorDefinition> idGeneratorDefinitionMap,
		Map<String, NamedQueryDefinition> namedQueryMap,
		Map<String, NamedSQLQueryDefinition> namedNativeQueryMap,
		Map<String, NamedProcedureCallDefinition> namedProcedureCallMap,
		Map<String, ResultSetMappingDefinition> sqlResultSetMappingMap,
		Map<String, NamedEntityGraphDefinition> namedEntityGraphMap,
		Map<String, SQLFunction> sqlFunctionMap,
		java.util.Collection<DomainDataRegionConfigImpl.Builder> cacheRegionConfigBuilders,
		Database database,
		BootstrapContext bootstrapContext) {
	this.uuid = uuid;
	this.metadataBuildingOptions = metadataBuildingOptions;
	this.identifierGeneratorFactory = identifierGeneratorFactory;
	this.entityBindingMap = entityBindingMap;
	this.mappedSuperclassMap = mappedSuperclassMap;
	this.collectionBindingMap = collectionBindingMap;
	this.typeDefinitionMap = typeDefinitionMap;
	this.filterDefinitionMap = filterDefinitionMap;
	this.fetchProfileMap = fetchProfileMap;
	this.imports = imports;
	this.idGeneratorDefinitionMap = idGeneratorDefinitionMap;
	this.namedQueryMap = namedQueryMap;
	this.namedNativeQueryMap = namedNativeQueryMap;
	this.namedProcedureCallMap = namedProcedureCallMap;
	this.sqlResultSetMappingMap = sqlResultSetMappingMap;
	this.namedEntityGraphMap = namedEntityGraphMap;
	this.sqlFunctionMap = sqlFunctionMap;
	this.cacheRegionConfigBuilders = cacheRegionConfigBuilders;
	this.database = database;
	this.bootstrapContext = bootstrapContext;
}
 

protected Database database() {
	if ( database == null ) {
		database = getBuildingContext().getMetadataCollector().getDatabase();
	}
	return database;
}
 

@Override
public Database getDatabase() {
	return delegate.getDatabase();
}
 

public ValueImpl(ExportableColumn column, Table table, BasicType type, Database database) {
	this.column = column;
	this.table = table;
	this.type = type;
	this.database = database;
}
 

@Override
public void registerExportables(Database database) {
	for (GenerationPlan plan : generationPlans) {
		plan.registerExportables( database );
	}
}
 

@Override
public void registerExportables(Database database) {
	final Namespace namespace = database.locateNamespace(
			qualifiedTableName.getCatalogName(),
			qualifiedTableName.getSchemaName()
	);

	Table table = namespace.locateTable( qualifiedTableName.getObjectName() );
	if ( table == null ) {
		table = namespace.createTable( qualifiedTableName.getObjectName(), false );

		// todo : note sure the best solution here.  do we add the columns if missing?  other?
		table.setPrimaryKey( new PrimaryKey( table ) );

		final Column pkColumn = new ExportableColumn(
				database,
				table,
				segmentColumnName,
				StringType.INSTANCE,
				database.getDialect().getTypeName( Types.VARCHAR, keySize, 0, 0 )
		);
		pkColumn.setNullable( false );
		table.addColumn( pkColumn );
		table.getPrimaryKey().addColumn( pkColumn );

		final Column valueColumn = new ExportableColumn(
				database,
				table,
				valueColumnName,
				LongType.INSTANCE
		);
		table.addColumn( valueColumn );
	}

	final JdbcEnvironment jdbcEnvironment = database.getJdbcEnvironment();

	// allow physical naming strategies a chance to kick in
	tableName = jdbcEnvironment.getQualifiedObjectNameFormatter().format(
			table.getQualifiedTableName(),
			jdbcEnvironment.getDialect()
	);

	query = "select " +
			valueColumnName +
			" from " +
			jdbcEnvironment.getDialect().appendLockHint( LockMode.PESSIMISTIC_WRITE, tableName ) +
			" where " + segmentColumnName + " = '" + segmentName + "'" +
			jdbcEnvironment.getDialect().getForUpdateString();

	update = "update " +
			tableName +
			" set " +
			valueColumnName +
			" = ? where " +
			valueColumnName +
			" = ? and " +
			segmentColumnName +
			" = '" +
			segmentName
			+ "'";

	insert = "insert into " + tableName +
			"(" + segmentColumnName + ", " + valueColumnName + ") " +
			"values('" + segmentName + "', ?)";



}
 

@Override
public void registerExportables(Database database) {
	buildSequence( database );
	this.sql = database.getJdbcEnvironment().getDialect().getSequenceNextValString( sequenceName );
}
 

@Override
public void registerExportables(Database database) {
	final JdbcEnvironment jdbcEnvironment = database.getJdbcEnvironment();
	final Dialect dialect = jdbcEnvironment.getDialect();

	final Namespace namespace = database.locateNamespace(
			logicalQualifiedTableName.getCatalogName(),
			logicalQualifiedTableName.getSchemaName()
	);

	Table table = namespace.locateTable( logicalQualifiedTableName.getObjectName() );
	if ( table == null ) {
		table = namespace.createTable( logicalQualifiedTableName.getObjectName(), false );
	}

	this.tableNameText = jdbcEnvironment.getQualifiedObjectNameFormatter().format(
			table.getQualifiedTableName(),
			dialect
	);

	this.valueColumnNameText = logicalValueColumnNameIdentifier.render( dialect );


	this.selectQuery = "select " + valueColumnNameText + " as id_val" +
			" from " + dialect.appendLockHint( LockMode.PESSIMISTIC_WRITE, tableNameText ) +
			dialect.getForUpdateString();

	this.updateQuery = "update " + tableNameText +
			" set " + valueColumnNameText + "= ?" +
			" where " + valueColumnNameText + "=?";

	ExportableColumn valueColumn = new ExportableColumn(
			database,
			table,
			valueColumnNameText,
			LongType.INSTANCE
	);
	table.addColumn( valueColumn );

	table.addInitCommand(
			new InitCommand( "insert into " + tableNameText + " values ( " + initialValue + " )" )
	);
}
 

@Override
public void registerExportables(Database database) {
	final Dialect dialect = database.getJdbcEnvironment().getDialect();

	final Namespace namespace = database.locateNamespace(
			qualifiedTableName.getCatalogName(),
			qualifiedTableName.getSchemaName()
	);

	Table table = namespace.locateTable( qualifiedTableName.getObjectName() );
	if ( table == null ) {
		table = namespace.createTable( qualifiedTableName.getObjectName(), false );

		// todo : note sure the best solution here.  do we add the columns if missing?  other?
		final Column segmentColumn = new ExportableColumn(
				database,
				table,
				segmentColumnName,
				StringType.INSTANCE,
				dialect.getTypeName( Types.VARCHAR, segmentValueLength, 0, 0 )
		);
		segmentColumn.setNullable( false );
		table.addColumn( segmentColumn );

		// lol
		table.setPrimaryKey( new PrimaryKey( table ) );
		table.getPrimaryKey().addColumn( segmentColumn );

		final Column valueColumn = new ExportableColumn(
				database,
				table,
				valueColumnName,
				LongType.INSTANCE
		);
		table.addColumn( valueColumn );
	}

	// allow physical naming strategies a chance to kick in
	this.renderedTableName = database.getJdbcEnvironment().getQualifiedObjectNameFormatter().format(
			table.getQualifiedTableName(),
			dialect
	);
	table.addInitCommand( generateInsertInitCommand() );

	this.selectQuery = buildSelectQuery( dialect );
	this.updateQuery = buildUpdateQuery();
	this.insertQuery = buildInsertQuery();
}
 

@Override
public void registerExportables(Database database) {
	databaseStructure.registerExportables( database );
}
 

private String getDefaultSchemaName(Database database, Dialect dialect) {
	final Identifier identifier = database.getDefaultNamespace().getPhysicalName().getSchema();
	return identifier == null ? null : identifier.render( dialect );
}
 

private String getDefaultCatalogName(Database database, Dialect dialect) {
	final Identifier identifier = database.getDefaultNamespace().getPhysicalName().getCatalog();
	return identifier == null ? null : identifier.render( dialect );
}
 

@Override
public void registerExportables(Database database) {
	if ( ExportableProducer.class.isInstance( subGenerator ) ) {
		( (ExportableProducer) subGenerator ).registerExportables( database );
	}
}
 

@Override
public Database getDatabase() {
    return metadata.getDatabase();
}
 

/**
 * Retrieve the database model.
 *
 * @return The database model.
 */
Database getDatabase();