How to use

Sequence

in

org.hibernate.boot.model.relational

@Override
public String[] getSqlCreateStrings(Sequence sequence, Metadata metadata) {
  final JdbcEnvironment jdbcEnvironment = metadata.getDatabase().getJdbcEnvironment();
  return dialect.getCreateSequenceStrings(
      jdbcEnvironment.getQualifiedObjectNameFormatter().format(
          sequence.getName(),
          jdbcEnvironment.getDialect()
      ),
      sequence.getInitialValue(),
      sequence.getIncrementSize()
  );
}

public Sequence createSequence(Identifier logicalName, int initialValue, int increment) {
  if ( sequences.containsKey( logicalName ) ) {
    throw new HibernateException( "Sequence was already registered with that name [" + logicalName.toString() + "]" );
  }
  final Identifier physicalName = physicalNamingStrategy.toPhysicalSequenceName( logicalName, jdbcEnvironment );
  Sequence sequence = new Sequence(
      this.physicalName.getCatalog(),
      this.physicalName.getSchema(),
      physicalName,
      initialValue,
      increment
  );
  sequences.put( logicalName, sequence );
  return sequence;
}

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

  protected void validateSequence(Sequence sequence, SequenceInformation sequenceInformation) {
    if ( sequenceInformation == null ) {
      throw new SchemaManagementException(
          String.format( "Schema-validation: missing sequence [%s]", sequence.getName() )
      );
    }

    if ( sequenceInformation.getIncrementSize() > 0
        && sequence.getIncrementSize() != sequenceInformation.getIncrementSize() ) {
      throw new SchemaManagementException(
          String.format(
              "Schema-validation: sequence [%s] defined inconsistent increment-size; found [%s] but expecting [%s]",
              sequence.getName(),
              sequenceInformation.getIncrementSize(),
              sequence.getIncrementSize()
          )
      );
    }
  }
}

public SequenceClusteredCounterHandler(EmbeddedCacheManager cacheManager, Sequence sequence) {
  super( cacheManager );
  counter = getCounterOrCreateIt( sequence.getExportIdentifier(), sequence.getInitialValue() );
}

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

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

@Override
public org.hibernate.metamodel.model.relational.spi.Sequence generateRuntimeSequence(
    PhysicalNamingStrategy namingStrategy,
    JdbcEnvironment jdbcEnvironment) {
  return new org.hibernate.metamodel.model.relational.spi.Sequence(
      getLogicalName().getCatalogName(),
      getLogicalName().getSchemaName(),
      getLogicalName().getSequenceName(),
      getInitialValue(),
      getIncrementSize(),
      namingStrategy,
      jdbcEnvironment
  );
}

);
sequenceStructure.registerExportables( database );
exportIdentifierSet.add( namespace.getSequences().iterator().next().getExportIdentifier() );
namespaceSize++;

  @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( getInitialValue(), getIncrementSize() );
    }
    else {
      sequence = namespace.createSequence( logicalQualifiedSequenceName.getObjectName(), getInitialValue(), getIncrementSize() );
    }
  }
}

public SequenceClusteredCounterHandler(EmbeddedCacheManager cacheManager, Sequence sequence) {
  super( cacheManager );
  counter = getCounterOrCreateIt( sequence.getExportIdentifier(), sequence.getInitialValue() );
}

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

  @Override
  public String[] getSqlDropStrings(Sequence sequence, Metadata metadata) {
    final JdbcEnvironment jdbcEnvironment = metadata.getDatabase().getJdbcEnvironment();
    return dialect.getDropSequenceStrings(
        jdbcEnvironment.getQualifiedObjectNameFormatter().format(
            sequence.getName(),
            jdbcEnvironment.getDialect()
        )
    );
  }
}

this.sequenceCounterHandlers.put( seq.getExportIdentifier(),
    new SequenceClusteredCounterHandler( persistenceStrategy.getCacheManager().getCacheManager(), seq ) );

public CounterHandler(RemoteCacheManager cacheManager, Sequence sequence) {
  CounterManager counterManager = RemoteCounterManagerFactory.asCounterManager( cacheManager );
  counterName = sequence.getExportIdentifier();
  if ( !counterManager.isDefined( counterName ) ) {
    defineCounter( counterManager, counterName, sequence.getInitialValue() );
  }
  counter = counterManager.getStrongCounter( counterName );
}

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

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

this.sequenceCounterHandlers.put( seq.getExportIdentifier(),
    new SequenceClusteredCounterHandler( persistenceStrategy.getCacheManager().getCacheManager(), seq ) );

public MappedSequence createSequence(Identifier logicalName, int initialValue, int increment) {
  if ( sequences.containsKey( logicalName ) ) {
    throw new HibernateException( "Sequence was already registered with that name [" + logicalName.toString() + "]" );
  }
  Sequence sequence = new Sequence(
      getName().getCatalog(),
      getName().getSchema(),
      logicalName,
      initialValue,
      increment
  );
  sequences.put( logicalName, sequence );
  return sequence;
}

for ( Sequence sequence : namespace.getSequences() ) {
  checkExportIdentifier( sequence, exportIdentifiers );
  final SequenceInformation sequenceInformation = existingDatabase.getSequenceInformation( sequence.getName() );
  if ( sequenceInformation == null ) {
    applySqlStrings(