class SingleColumnManager implements Manager<String> {

    private final StreamSupplierComponent streamSupplierComponent;
    private final StringField<String, String> field;
    private final TableIdentifier<String> tableId;

    SingleColumnManager(
        final StreamSupplierComponent streamSupplierComponent,
        @Config(name="temp.dbms", value="") final String dbms,
        @Config(name="temp.schema", value="") final String schema,
        @Config(name="temp.table", value="") final String table,
        @Config(name="temp.column", value="") final String column
    ) {
        this.streamSupplierComponent = requireNonNull(streamSupplierComponent);
        requireNonNull(dbms);
        requireNonNull(schema);
        requireNonNull(table);
        requireNonNull(column);
        this.tableId = TableIdentifier.of(dbms, schema, table);
        this.field   = StringField.create(
            new TempColumnIdentifier(dbms, schema, table, column),
            e -> e, (e, s) -> {},
            TypeMapper.identity(),
            false
        );
    }

    @ExecuteBefore(State.INITIALIZED)
    public void configureManagerComponent(@WithState(State.INITIALIZED) ManagerComponent managerComponent) {
        managerComponent.put(this);
    }

    @Override
    public TableIdentifier<String> getTableIdentifier() {
        return tableId;
    }

    @Override
    public Class<String> getEntityClass() {
        return String.class;
    }

    @Override
    public Stream<Field<String>> fields() {
        return SingletonStream.of(field);
    }

    @Override
    public Stream<Field<String>> primaryKeyFields() {
        return SingletonStream.of(field);
    }

    @Override
    public Stream<String> stream() {
        return streamSupplierComponent.stream(
            getTableIdentifier(),
            ParallelStrategy.computeIntensityDefault()
        );
    }

    @Override
    public String create() {
        throw newUnsupportedOperationExceptionReadOnly();
    }

    @Override
    public final String persist(String entity) {
        throw newUnsupportedOperationExceptionReadOnly();
    }

    @Override
    public Persister<String> persister() {
        throw newUnsupportedOperationExceptionReadOnly();
    }

    @Override
    public Persister<String> persister(HasLabelSet<String> fields) {
        throw newUnsupportedOperationExceptionReadOnly();
    }

    @Override
    public final String update(String entity) {
        throw newUnsupportedOperationExceptionReadOnly();
    }

    @Override
    public Updater<String> updater() {
        throw newUnsupportedOperationExceptionReadOnly();
    }

    @Override
    public Updater<String> updater(HasLabelSet<String> fields) {
        throw newUnsupportedOperationExceptionReadOnly();
    }

    @Override
    public final String remove(String entity) {
        throw newUnsupportedOperationExceptionReadOnly();
    }

    @Override
    public Remover<String> remover() {
        throw newUnsupportedOperationExceptionReadOnly();
    }

    @Override
    public String toString() {<FILL_FUNCTION_BODY>}

    private static UnsupportedOperationException newUnsupportedOperationExceptionReadOnly() {
        return new UnsupportedOperationException("This manager is read-only.");
    }

}

        return getClass().getSimpleName() + "{tableId: " +
            tableId.toString()
            + "}";
    
<no_super_class>