How to perform a query with a converted value

I have a simple converter to map DayOfWeek to an Integer to match the legacy data code which used Calendar day of week values. However, when I am doing criteria queries, it appears to be using the ordinal value of DayOfWeek rather than my converted value.

    default Optional<ProgramSchedule> findByProgramWeekAndDay(final Program program, int week, final DayOfWeek dayOfWeek) {

        return findOne(((root, query, cb) ->
            cb.and(
                cb.equal(root.get(ProgramSchedule_.program), program),
                cb.equal(root.get(ProgramSchedule_.week), week),
                cb.equal(root.get(ProgramSchedule_.dayOfWeek), dayOfWeek))
        ));

    }

And calling it with

programSchedules.findByProgramWeekAndDay(psFdProgram, 1, DayOfWeek.TUESDAY)

Gives me the following where parameter 2 was supposed be the day of the week, however, I was expecting it to be 3 which is the day of week value for Calendar.TUESDAY.

ype.descriptor.sql.BasicBinder TRACE binding parameter [1] as [VARCHAR] - [PS-FD]
ype.descriptor.sql.BasicBinder TRACE binding parameter [2] as [INTEGER] - [1]

I'm using Spring JPA

The converter looks like this

@Component
@Converter(autoApply = true)
public class DayOfWeekConverter implements AttributeConverter<DayOfWeek, Integer> {

    @Override
    public Integer convertToDatabaseColumn(final DayOfWeek dayOfWeek) {

        if (dayOfWeek == null) {
            return null;
        } else if (DayOfWeek.SUNDAY == dayOfWeek) {
            return Calendar.SUNDAY;
        } else if (DayOfWeek.MONDAY == dayOfWeek) {
            return Calendar.MONDAY;
        } else if (DayOfWeek.TUESDAY == dayOfWeek) {
            return Calendar.TUESDAY;
        } else if (DayOfWeek.WEDNESDAY == dayOfWeek) {
            return Calendar.WEDNESDAY;
        } else if (DayOfWeek.THURSDAY == dayOfWeek) {
            return Calendar.THURSDAY;
        } else if (DayOfWeek.FRIDAY == dayOfWeek) {
            return Calendar.FRIDAY;
        } else if (DayOfWeek.SATURDAY == dayOfWeek) {
            return Calendar.SATURDAY;
        } else {
            throw new IllegalStateException();
        }
    }

    @Override
    public DayOfWeek convertToEntityAttribute(final Integer dbValue) {

        if (dbValue == null) {
            return null;
        } else if (Calendar.SUNDAY == dbValue) {
            return DayOfWeek.SUNDAY;
        } else if (Calendar.MONDAY == dbValue) {
            return DayOfWeek.MONDAY;
        } else if (Calendar.TUESDAY == dbValue) {
            return DayOfWeek.TUESDAY;
        } else if (Calendar.WEDNESDAY == dbValue) {
            return DayOfWeek.WEDNESDAY;
        } else if (Calendar.THURSDAY == dbValue) {
            return DayOfWeek.THURSDAY;
        } else if (Calendar.FRIDAY == dbValue) {
            return DayOfWeek.FRIDAY;
        } else if (Calendar.SATURDAY == dbValue) {
            return DayOfWeek.SATURDAY;
        } else {
            throw new IllegalArgumentException(String.format("dbValue=%d is not valid", dbValue));
        }
    }
}

I annotated dayOfWeek as follows

    @Id
    @Column(name = "Day", nullable = false)
    @Convert(converter = DayOfWeekConverter.class) // I had it without this one as well
    private DayOfWeek dayOfWeek;

It's not limited to criteria queries either, it also occurs with JPQL queries:

    @Query("from ProgramSchedule p where p.program = :program and week = :week and dayOfWeek = :dayOfWeek")
Optional<ProgramSchedule> findByProgramWeekAndDay(final Program program, int week, final DayOfWeek dayOfWeek);

yields

    where
programsch0_.Program=? 
and programsch0_.Week=? 
and programsch0_.Day=?
ype.descriptor.sql.BasicBinder TRACE binding parameter [1] as [VARCHAR] - [PS-FD]
ype.descriptor.sql.BasicBinder TRACE binding parameter [2] as [INTEGER] - [1]
ype.descriptor.sql.BasicBinder TRACE binding parameter [3] as [INTEGER] - [1]

@Id and @Convert cannot be used together, so you have to use an @IdClass, like so:

@Entity
@IdClass(MyEntity.class)
public class MyId {
@Id
private DayOfWeek dayOfWeek;
...
}
public class MyEnity implements Serializable {
@Column(name = "Day")
@Convert(converter = DayOfWeekConverter.class)
private DayOfWeek dayOfWeek;
}

EDIT According to docs the above code also doesn't work, so I looked for a workaround and found this:

@Entity
public class MyEntity {
@EmbeddedId
private DayOfWeek dayOfWeek;
...
}
@Embeddable
public static class Id {
@Column(name = "Day")
@Convert(converter = DayOfWeekConverter.class)
private DayOfWeek dayOfWeek;
}
</details>