How to use

Namespace

in

org.hibernate.boot.model.relational

@Override
public java.util.Collection<Table> collectTableMappings() {
  ArrayList<Table> tables = new ArrayList<>();
  for ( Namespace namespace : database.getNamespaces() ) {
    tables.addAll( namespace.getTables() );
  }
  return tables;
}

public Namespace adjustDefaultNamespace(Identifier catalogName, Identifier schemaName) {
  final Namespace.Name name = new Namespace.Name( catalogName, schemaName );
  if ( implicitNamespace.getName().equals( name ) ) {
    return implicitNamespace;
  }
  Namespace namespace = namespaceMap.get( name );
  if ( namespace == null ) {
    namespace = makeNamespace( name );
  }
  implicitNamespace = namespace;
  return implicitNamespace;
}

public Table(Namespace namespace, String subselect, boolean isAbstract) {
  this.catalog = namespace.getPhysicalName().getCatalog();
  this.schema = namespace.getPhysicalName().getSchema();
  this.subselect = subselect;
  this.isAbstract = isAbstract;
}

if ( tryToCreateCatalogs || tryToCreateSchemas ) {
  if ( tryToCreateCatalogs ) {
    final Identifier catalogLogicalName = namespace.getName().getCatalog();
    final Identifier catalogPhysicalName = namespace.getPhysicalName().getCatalog();
      && namespace.getPhysicalName().getSchema() != null
      && !existingDatabase.schemaExists( namespace.getName() ) ) {
    applySqlStrings(
        false,
        dialect.getCreateSchemaCommand( namespace.getPhysicalName().getSchema().render( dialect ) ),
        formatter,
        options,

  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()
    );
  }
}

for ( Table table : namespace.getTables() ) {
  if ( !table.isPhysicalTable() ) {
    continue;
for ( Sequence sequence : namespace.getSequences() ) {
  if ( !schemaFilter.includeSequence( sequence ) ) {
    continue;
  if ( tryToDropSchemas && namespace.getPhysicalName().getSchema() != null ) {
    applySqlStrings(
        dialect.getDropSchemaCommand(
            namespace.getPhysicalName().getSchema().render( dialect )
        ),
        formatter,
    final Identifier catalogLogicalName = namespace.getName().getCatalog();
    final Identifier catalogPhysicalName = namespace.getPhysicalName().getCatalog();

tablesInformation.put( namespace, nameSpaceTablesInformation );
if ( schemaFilter.includeNamespace( namespace ) ) {
  for ( Sequence sequence : namespace.getSequences() ) {
    checkExportIdentifier( sequence, exportIdentifiers );
    final SequenceInformation sequenceInformation = existingDatabase.getSequenceInformation( sequence.getName() );
if ( schemaFilter.includeNamespace( namespace ) ) {
  final NameSpaceTablesInformation nameSpaceTablesInformation = tablesInformation.get( namespace );
  for ( Table table : namespace.getTables() ) {
    if ( schemaFilter.includeTable( table ) ) {
      final TableInformation tableInformation = nameSpaceTablesInformation.getTableInformation( table );

@Test
public void testQualifiedNameSeparator() throws Exception {
  Namespace.Name namespaceName = new Namespace.Name(
      Identifier.toIdentifier( "DB1" ),
      Identifier.toIdentifier( "PUBLIC" )
  );
  String expectedName = null;
  for ( Namespace namespace : metadata().getDatabase().getNamespaces() ) {
    if ( !namespace.getName().equals( namespaceName ) ) {
      continue;
    }
    assertEquals( 1, namespace.getTables().size() );
    expectedName = metadata().getDatabase().getJdbcEnvironment().getQualifiedObjectNameFormatter().format(
        namespace.getTables().iterator().next().getQualifiedTableName(),
        getDialect()
    );
  }
  assertNotNull( expectedName );
  SingleTableEntityPersister persister = (SingleTableEntityPersister) sessionFactory().getEntityPersister( Box.class.getName() );
  assertEquals( expectedName, persister.getTableName() );
}

public void performValidation(
    Metadata metadata,
    DatabaseInformation databaseInformation,
    ExecutionOptions options,
    Dialect dialect) {
  for ( Namespace namespace : metadata.getDatabase().getNamespaces() ) {
    if ( schemaFilter.includeNamespace( namespace ) ) {
      validateTables( metadata, databaseInformation, options, dialect, namespace );
    }
  }
  for ( Namespace namespace : metadata.getDatabase().getNamespaces() ) {
    if ( schemaFilter.includeNamespace( namespace ) ) {
      for ( Sequence sequence : namespace.getSequences() ) {
        if ( schemaFilter.includeSequence( sequence ) ) {
          final SequenceInformation sequenceInformation = databaseInformation.getSequenceInformation(
              sequence.getName()
          );
          validateSequence( sequence, sequenceInformation );
        }
      }
    }
  }
}

    ssr.getService( JdbcEnvironment.class ),
    new QualifiedNameImpl(
        namespace.getName(),
        Identifier.toIdentifier( "aSequence" )
    ),
);
sequenceStructure.registerExportables( database );
exportIdentifierSet.add( namespace.getSequences().iterator().next().getExportIdentifier() );
namespaceSize++;

    .locateSequence( Identifier.toIdentifier( "my_db_sequence" ) );
assertThat( sequence, notNullValue() );
final String[] sqlCreateStrings = new H2Dialect().getSequenceExporter().getSqlCreateStrings(

    final Identifier catalogLogicalName = namespace.getName().getCatalog();
    final Identifier catalogPhysicalName = namespace.getPhysicalName().getCatalog();
  if ( tryToCreateSchemas && namespace.getPhysicalName().getSchema() != null ) {
    applySqlStrings(
        dialect.getCreateSchemaCommand( namespace.getPhysicalName().getSchema().render( dialect ) ),
        formatter,
        options,
for ( Sequence sequence : namespace.getSequences() ) {
  if ( !schemaFilter.includeSequence( sequence ) ) {
    continue;
for ( Table table : namespace.getTables() ) {
  if ( !table.isPhysicalTable() ){
    continue;
for ( Table table : namespace.getTables() ) {
  if ( !table.isPhysicalTable() ){
    continue;
for ( Table table : namespace.getTables() ) {
  if ( !schemaFilter.includeTable( table ) ) {
    continue;

@Override
public void initializeSchema(SchemaDefinitionContext context) {
  ServiceRegistryImplementor serviceRegistry = context.getSessionFactory().getServiceRegistry();
  TypeTranslator typeTranslator = serviceRegistry.getService( TypeTranslator.class );
  OptionsService optionsService = serviceRegistry.getService( OptionsService.class );
  Map tableEntityTypeMapping = context.getTableEntityTypeMapping();
  InfinispanRemoteDatastoreProvider datastoreProvider = (InfinispanRemoteDatastoreProvider) serviceRegistry.getService( DatastoreProvider.class );
  String protobufPackageName = datastoreProvider.getProtobufPackageName();
  SchemaDefinitions sd = new SchemaDefinitions( protobufPackageName );
  HashSet<Sequence> sequences = new HashSet<>();
  for ( Namespace namespace : context.getDatabase().getNamespaces() ) {
    for ( Sequence sequence : namespace.getSequences() ) {
      sequences.add( sequence );
    }
    for ( Table table : namespace.getTables() ) {
      if ( table.isPhysicalTable() ) {
        createTableDefinition( context.getSessionFactory(), sd, table, typeTranslator, protobufPackageName,
          getCacheConfiguration( tableEntityTypeMapping, optionsService, table.getName() )
        );
      }
    }
  }
  for ( IdSourceKeyMetadata iddSourceKeyMetadata : context.getAllIdSourceKeyMetadata() ) {
    if ( !HotRodSequenceCounterHandler.isSequenceGeneratorId( iddSourceKeyMetadata ) ) {
      sd.createSequenceSchemaDefinition( iddSourceKeyMetadata, datastoreProvider.getProtobufPackageName() );
    }
  }
  datastoreProvider.registerSchemaDefinitions( sd, sequences );
}

@Test
@TestForIssue( jiraKey = "HHH-9936" )
public void testMultipleUsesOfDefaultSequenceName() {
  final MetadataImplementor metadata = (MetadataImplementor) new MetadataSources( ssr )
      .addAnnotatedClass( Entity1.class )
      .addAnnotatedClass( Entity2.class )
      .buildMetadata();
  metadata.validate();
  assertEquals( 0, metadata.getDatabase().getAuxiliaryDatabaseObjects().size() );
  int count = 0;
  for ( Namespace namespace : metadata.getDatabase().getNamespaces() ) {
    for ( Sequence sequence : namespace.getSequences() ) {
      count++;
    }
  }
  assertEquals( 1, count );
}

  @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 );
  }
}

private InformationExtractorJdbcDatabaseMetaDataImplTest buildInformationExtractorJdbcDatabaseMetaDataImplTest()
    throws SQLException {
  Database database = metadata.getDatabase();
  final ConnectionProvider connectionProvider = ssr.getService( ConnectionProvider.class );
  DatabaseInformation dbInfo = new DatabaseInformationImpl(
      ssr,
      database.getJdbcEnvironment(),
      new DdlTransactionIsolatorTestingImpl( ssr,
                          new JdbcEnvironmentInitiator.ConnectionProviderJdbcConnectionAccess(
                              connectionProvider )
      ),
      database.getDefaultNamespace().getName()
  );
  ExtractionContextImpl extractionContext = new ExtractionContextImpl(
      ssr,
      database.getJdbcEnvironment(),
      ssr.getService( JdbcServices.class ).getBootstrapJdbcConnectionAccess(),
      (ExtractionContext.DatabaseObjectAccess) dbInfo,
      database.getDefaultNamespace().getPhysicalName().getCatalog(),
      database.getDefaultNamespace().getPhysicalName().getSchema()
  );
  return new InformationExtractorJdbcDatabaseMetaDataImplTest(
      extractionContext );
}

@Override
public java.util.Collection<Table> collectTableMappings() {
  ArrayList<Table> tables = new ArrayList<>();
  for ( Namespace namespace : getDatabase().getNamespaces() ) {
    tables.addAll( namespace.getTables() );
  }
  return tables;
}

@Test
@TestForIssue( jiraKey = "HHH-9936" )
public void testMultipleUsesOfExplicitSequenceName() {
  final MetadataImplementor metadata = (MetadataImplementor) new MetadataSources( ssr )
      .addAnnotatedClass( Entity3.class )
      .addAnnotatedClass( Entity4.class )
      .buildMetadata();
  metadata.validate();
  assertEquals( 0, metadata.getDatabase().getAuxiliaryDatabaseObjects().size() );
  int count = 0;
  for ( Namespace namespace : metadata.getDatabase().getNamespaces() ) {
    for ( Sequence sequence : namespace.getSequences() ) {
      count++;
    }
  }
  assertEquals( 1, count );
}

public Settings(SessionFactoryOptions sessionFactoryOptions, Metadata metadata) {
  this(
      sessionFactoryOptions,
      extractName( metadata.getDatabase().getDefaultNamespace().getName().getCatalog() ),
      extractName( metadata.getDatabase().getDefaultNamespace().getName().getSchema() )
  );
}

public Table(
    Namespace namespace,
    Identifier physicalTableName,
    boolean isAbstract) {
  this.catalog = namespace.getPhysicalName().getCatalog();
  this.schema = namespace.getPhysicalName().getSchema();
  this.name = physicalTableName;
  this.isAbstract = isAbstract;
}