How to use org.hibernate.boot.model.relational

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

public SimpleAuxiliaryDatabaseObject(
    Namespace namespace,
    String[] createStrings,
    String[] dropStrings,
    Set<String> dialectScopes) {
  this(
      dialectScopes,
      extractName( namespace.getPhysicalName().getCatalog() ),
      extractName( namespace.getPhysicalName().getSchema() ),
      createStrings,
      dropStrings
  );
}

  @Override
  public int compareTo(Name that) {
    // per Comparable, the incoming Name cannot be null.  However, its catalog/schema might be
    // so we need to account for that.
    int catalogCheck = ComparableHelper.compare( this.getCatalog(), that.getCatalog() );
    if ( catalogCheck != 0 ) {
      return catalogCheck;
    }
    return ComparableHelper.compare( this.getSchema(), that.getSchema() );
  }
}

@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 QualifiedNameImpl(Namespace.Name schemaName, Identifier objectName) {
  this(
      schemaName.getCatalog(),
      schemaName.getSchema(),
      objectName
  );
}

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

@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 Identifier determineImplicitName(LocalMetadataBuildingContext context) {
    return database.toIdentifier( IdentifierCollection.DEFAULT_IDENTIFIER_COLUMN_NAME );
  }
}

@Override
public String[] sqlDropStrings(Dialect dialect) throws HibernateException {
  // delegate to auxiliary object
  return sequenceObject.sqlDropStrings( dialect );
}

@Override
public String[] sqlCreateStrings(Dialect dialect) {
  final String[] copy = new String[createStrings.length];
  for ( int i = 0, max =createStrings.length; i<max; i++ ) {
    copy[i] = injectCatalogAndSchema( createStrings[i] );
  }
  return copy;
}

protected InitCommand generateInsertInitCommand() {
  int value = initialValue;
  if ( storeLastUsedValue ) {
    value = initialValue - 1;
  }
  return new InitCommand( "insert into " + renderedTableName + "(" + segmentColumnName + ", " + valueColumnName + ")" + " values ('" + segmentValue + "'," + ( value ) + ")" );
}

@Override
public String[] sqlCreateStrings(Dialect dialect) throws HibernateException {
  // delegate to auxiliary object
  return sequenceObject.sqlCreateStrings( dialect );
}

  @Override
  public ServiceRegistry getServiceRegistry() {
    return database.getServiceRegistry();
  }
}

/**
 * The name of the table in which we store this generator's persistent state.
 *
 * @return The table name.
 */
public final String getTableName() {
  return qualifiedTableName.render();
}

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

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

  @Override
  public String[] getSqlDropStrings(AuxiliaryDatabaseObject object, Metadata metadata) {
    return object.sqlDropStrings( dialect );
  }
}

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

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