How to use

toIdentifier

method

in

org.hibernate.boot.model.relational.Database

  @Override
  public Identifier determineImplicitName(LocalMetadataBuildingContext context) {
    return database.toIdentifier( IndexedCollection.DEFAULT_INDEX_COLUMN_NAME );
  }
}

  @Override
  public Identifier determineImplicitName(LocalMetadataBuildingContext context) {
    return database.toIdentifier( IdentifierCollection.DEFAULT_IDENTIFIER_COLUMN_NAME );
  }
}

  @Override
  public Identifier getReferencedPrimaryKeyColumnName() {
    return database.toIdentifier( logicalReferencedColumn );
  }
}

@Override
public void addTableNameBinding(String schema, String catalog, String logicalName, String realTableName, Table denormalizedSuperTable) {
  final Identifier logicalNameIdentifier = getDatabase().toIdentifier( logicalName );
  final Identifier physicalNameIdentifier = getDatabase().toIdentifier( realTableName );
  logicalToPhysicalTableNameMap.put( logicalNameIdentifier, physicalNameIdentifier );
  physicalToLogicalTableNameMap.put( physicalNameIdentifier, logicalNameIdentifier );
}

private List<Identifier> toIdentifiers(String[] names) {
  if ( names == null ) {
    return Collections.emptyList();
  }
  final List<Identifier> columnNames = CollectionHelper.arrayList( names.length );
  for ( String name : names ) {
    columnNames.add( getDatabase().toIdentifier( name ) );
  }
  return columnNames;
}

@SuppressWarnings("unchecked")
private List<Identifier> extractColumnNames(List columns) {
  if ( columns == null || columns.isEmpty() ) {
    return Collections.emptyList();
  }
  final List<Identifier> columnNames = CollectionHelper.arrayList( columns.size() );
  for ( Column column : (List<Column>) columns ) {
    columnNames.add( getDatabase().toIdentifier( column.getQuotedName() ) );
  }
  return columnNames;
}

  @Override
  public Identifier determineImplicitName(LocalMetadataBuildingContext context) {
    return context.getMetadataCollector().getDatabase().toIdentifier( Collection.DEFAULT_ELEMENT_COLUMN_NAME );
  }
}

@Override
public Identifier handleExplicitName(
    String explicitName, MetadataBuildingContext buildingContext) {
  return buildingContext.getMetadataCollector().getDatabase().toIdentifier( explicitName );
}

  @Override
  public Identifier determineImplicitName(final LocalMetadataBuildingContext context) {
    return context.getMetadataCollector().getDatabase().toIdentifier( Collection.DEFAULT_KEY_COLUMN_NAME );
  }
}

  @Override
  public Identifier determineImplicitName(final LocalMetadataBuildingContext context) {
    return context.getMetadataCollector()
        .getDatabase()
        .toIdentifier( Collection.DEFAULT_ELEMENT_COLUMN_NAME );
  }
}

@Override
public String getLogicalColumnName(Table table, String physicalName) throws MappingException {
  return getLogicalColumnName( table, getDatabase().toIdentifier( physicalName ) );
}

@Override
public String getPhysicalColumnName(Table table, String logicalName) throws MappingException {
  return getPhysicalColumnName( table, getDatabase().toIdentifier( logicalName ) );
}

@Override
public void addColumnNameBinding(Table table, String logicalName, Column column) throws DuplicateMappingException {
  addColumnNameBinding( table, getDatabase().toIdentifier( logicalName ), column );
}

@Override
public String getPhysicalTableName(String logicalName) {
  return getPhysicalTableName( getDatabase().toIdentifier( logicalName ) );
}

  @Override
  public Identifier determineImplicitName(LocalMetadataBuildingContext context) {
    final Column column = primaryTable.getPrimaryKey().getColumn( count++ );
    return database.toIdentifier( column.getQuotedName() );
  }
}

private String normalizeColumnQuoting(String name) {
  return context.getMetadataCollector().getDatabase().toIdentifier( name ).render();
}

  @Override
  public Identifier determineImplicitName(LocalMetadataBuildingContext context) {
    final Column correspondingColumn = entityTableXref.getPrimaryTable().getPrimaryKey().getColumn( count++ );
    return database.toIdentifier( correspondingColumn.getQuotedName() );
  }
}

public Database(MetadataBuildingOptions buildingOptions, JdbcEnvironment jdbcEnvironment) {
  this.serviceRegistry = buildingOptions.getServiceRegistry();
  this.jdbcEnvironment = jdbcEnvironment;
  this.physicalNamingStrategy = buildingOptions.getPhysicalNamingStrategy();
  this.dialect = determineDialect( buildingOptions );
  this.implicitNamespace = makeNamespace(
      new Namespace.Name(
          toIdentifier( buildingOptions.getMappingDefaults().getImplicitCatalogName() ),
          toIdentifier( buildingOptions.getMappingDefaults().getImplicitSchemaName() )
      )
  );
}

private Identifier determineSchemaName(TableSpecificationSource tableSpecSource) {
  if ( StringHelper.isNotEmpty( tableSpecSource.getExplicitSchemaName() ) ) {
    return database.toIdentifier( tableSpecSource.getExplicitSchemaName() );
  }
  else {
    return database.getDefaultNamespace().getName().getSchema();
  }
}

private Identifier determineCatalogName(TableSpecificationSource tableSpecSource) {
  if ( StringHelper.isNotEmpty( tableSpecSource.getExplicitCatalogName() ) ) {
    return database.toIdentifier( tableSpecSource.getExplicitCatalogName() );
  }
  else {
    return database.getDefaultNamespace().getName().getCatalog();
  }
}