How to use

QualifiedSequenceName

in

org.hibernate.boot.model.relational

  @Override
  public SequenceInformation locateSequenceInformation(QualifiedSequenceName sequenceName) {
    // again, follow legacy behavior
    if ( sequenceName.getCatalogName() != null || sequenceName.getSchemaName() != null ) {
      sequenceName = new QualifiedSequenceName( null, null, sequenceName.getSequenceName() );
    }

    return sequenceInformationMap.get( sequenceName );
  }
}

public Sequence(
    Identifier catalogName,
    Identifier schemaName,
    Identifier sequenceName,
    int initialValue,
    int incrementSize) {
  this( catalogName, schemaName, sequenceName );
  this.initialValue = initialValue;
  this.incrementSize = incrementSize;
}

  public Identifier getSequenceName() {
    return getObjectName();
  }
}

@Override
public String format(QualifiedSequenceName qualifiedSequenceName, Dialect dialect) {
  return format.format(
      qualifiedSequenceName.getCatalogName(),
      qualifiedSequenceName.getSchemaName(),
      qualifiedSequenceName.getSequenceName(),
      dialect
  );
}

assertNotNull( sequenceInformations );
SequenceInformation sequenceInformation = sequenceInformations.iterator().next();
assertEquals( "ITEM_SEQ", sequenceInformation.getSequenceName().getSequenceName().getText().toUpperCase() );
assertEquals( 100, sequenceInformation.getStartValue().intValue() );
assertEquals( 10, sequenceInformation.getIncrementValue().intValue() );

  @Override
  public boolean includeSequence(Sequence sequence) {
    final String render = sequence.getName().render();
    return !"entity_2_seq_gen".endsWith( sequence.getName().render() );
  }
}

private void initializeSequences() throws SQLException {
  Iterable<SequenceInformation> itr = jdbcEnvironment.getDialect()
      .getSequenceInformationExtractor()
      .extractMetadata( extractionContext );
  for ( SequenceInformation sequenceInformation : itr ) {
    sequenceInformationMap.put(
        // for now, follow the legacy behavior of storing just the
        // unqualified sequence name.
        new QualifiedSequenceName(
            null,
            null,
            sequenceInformation.getSequenceName().getSequenceName()
        ),
        sequenceInformation
    );
  }
}

@Override
public SequenceInformation getSequenceInformation(
    Identifier catalogName,
    Identifier schemaName,
    Identifier sequenceName) {
  return getSequenceInformation( new QualifiedSequenceName( catalogName, schemaName, sequenceName ) );
}

  /**
   * Get the database sequence increment value from the associated {@link SequenceInformation} object.
   *
   * @param jdbcEnvironment the current JdbcEnvironment
   * @param sequenceName sequence name
   *
   * @return sequence increment value
   */
  private Long getSequenceIncrementValue(JdbcEnvironment jdbcEnvironment, String sequenceName) {
    return jdbcEnvironment.getExtractedDatabaseMetaData().getSequenceInformationList().stream().filter(
        sequenceInformation -> {
          Identifier catalog = sequenceInformation.getSequenceName().getCatalogName();
          Identifier schema = sequenceInformation.getSequenceName().getSchemaName();
          return sequenceName.equalsIgnoreCase( sequenceInformation.getSequenceName().getSequenceName().getText() ) &&
              ( catalog == null || catalog.equals( jdbcEnvironment.getCurrentCatalog() ) ) &&
              ( schema == null || schema.equals( jdbcEnvironment.getCurrentSchema() ) );
        }
    ).map( SequenceInformation::getIncrementValue ).findFirst().orElse( null );
  }
}

Iterable<SequenceInformation> sequences = sequenceInformationExtractor.extractMetadata(extractionContext);
for (SequenceInformation next : sequences) {
  sequenceNames.add(next.getSequenceName().getSequenceName().getText());

private void addSequence(List<Statement> statements, Sequence sequence) {
  Statement statement = new Statement( SEQUENCE_CREATION_QUERY, Collections.<String, Object>singletonMap( SEQUENCE_NAME_QUERY_PARAM, sequence.getName().render() ) );
  statements.add( statement );
}

@Override
public SequenceInformation getSequenceInformation(Namespace.Name schemaName, Identifier sequenceName) {
  return getSequenceInformation( new QualifiedSequenceName( schemaName, sequenceName ) );
}

generatedSequences.add( sequence.getName().getSequenceName().getText() );
igniteDatastoreProvider.atomicSequence( sequence.getName().getSequenceName().getText(), sequence.getInitialValue(), true );

private void addSequence(Statements statements, Sequence sequence) {
  Statement statement = new Statement( SEQUENCE_CREATION_QUERY, Collections.<String, Object>singletonMap( SEQUENCE_NAME_QUERY_PARAM, sequence.getName().render() ) );
  statements.addStatement( statement );
}

sequenceInformationList.add(
    new SequenceInformationImpl(
        new QualifiedSequenceName(
            identifierHelper.toIdentifier(
              resultSetCatalogName( resultSet )

protected Map<String, Object> params(Sequence sequence) {
  return params( sequence.getName().render(), sequence.getInitialValue() );
}