querydsl | Unified Queries for Java | Object-Relational Mapping library

Yes, you can use QueryDsl, Jooq, Spring Data, hibernate, etc to do that.

Example of using Spring Data:

I assume that you are passing a detached entity instance to the update method, and a new transaction is started when entering the method (by the spring transactional aop proxy).
(Otherwise, the dbDomain entry would be resolved from the hibernate 1st level cache to the passed entity instance updated, so that there would not be any property differences.)

When passing the detached instance updated to the save method, the entity manager will merge it into the persistence context. Thereby, it will also check for another already attached instance of the same entity (same ID), and keep the other instance of the entity in sync by copying all values from the newly passed instance to the other attached instance:
https://github.com/hibernate/hibernate-orm/blob/734b80c531bdb2a9bb33971cd57f51fce662e758/hibernate-core/src/main/java/org/hibernate/event/internal/DefaultMergeEventListener.java#L346
(Which makes sense, since you would otherwise end up with different values on the attached entities, and you could not decide which would be persisted to the DB at the end of the transaction.)

To prevent your dbDomain instance being updated, you could manually detach it from the persistence context before calling save(updated):

As said in the comments, Conn can not be shared between threads, so in this case you would need to move the Pool handle, and get a connection from within the clusure itself:

The reason for this is that Jaybird currently doesn't support a timeout for Connection.isValid(int) and ignores it, and thus - if the specified timeout is non-zero - it registers a SQLWarning on the connection (instead of throwing an exception). Although registering a warning here isn't specified in the JDBC specification, this is similar to what JDBC requires a driver to do when it replaces/ignores user-specified values when configuring the result set type, concurrency and holdability.

When Hibernate notices there is a warning registered on the connection, it will log that warning in org.hibernate.engine.jdbc.spi.SqlExceptionHelper. This logging of warnings can be disabled by setting the property hibernate.jdbc.log.warnings=false (see Query Settings in the Hibernate documentation). In case of Spring Boot, I guess you can set this as property spring.jpa.properties.hibernate.jdbc.log.warnings (but I haven't verified this).

The timeout is configurable through the HikariCP property validationTimeout, but - by default - this doesn't accept a value lower than 250 milliseconds (you can change that with system property com.zaxxer.hikari.timeoutMs.floor). Alternatively, you can configure HikariCP property connectionTestQuery with - for example - select 1 from rdb$database, so HikariCP uses the test query instead of Connection.isValid(int). Be aware that a test query has more overhead.

The warning code printed is the SQLWarning.getErrorCode() (technically, SQLException.getErrorCode(), a.k.a the vendor code). And given this warning doesn't have an error/warning code, its value is 0, which simply means "there is no specific vendor code associated with this warning".

I have created this issue to see if actual timeout support can be added in Jaybird 4.0.6 or Jaybird 5.

Disclosure: I am one of the maintainers of Jaybird.

@ElementCollection and @OrderColumn are causing a first problem here. After they are removed (and the schema is setup correctly), the function call (SQL template) needs to be corrected.

The problem with @ElementCollection and @OrderColumn is that they represent an alternative approach for storing lists/arrays as part of an entity.
@ElementCollection stores the elements in a separate table, with each element in a separate row (each referencing the entity). To "remember" the correct order, an @OrderColumn is needed as part of the separate table, since rows are returned in arbitrary order if no order is specified (https://stackoverflow.com/a/20050403).

In contrast, ListArrayType and @Column(columnDefinition = "bigint[]") will enable saving the sequence of elements in one column of an entity row. Therefore, no separate table is used, and since the elements are not saved in separate rows, no additional order information is needed.

So without @ElementCollection and @OrderColumn the list mapping is already correctly setup. Be aware that your schema might currently be in a bad state, and you need to make sure that there is a bigint[] column in the entity table (can e.g. be auto-created by hibernate when @ElementCollection and @OrderColumn are removed).

2. Fixing the PostgresQL function call: array_length needs a second argument indicating the dimension of the array along which the length is returned (https://www.postgresql.org/docs/current/functions-array.html). So specifying the template string as follows should get you the correct result:
"function('array_length', {0}, 1)"
("1" being the requested array dimension).

It appears you're still (perhaps transitively) relying on some Querydsl 4.0.0 dependencies. You need to remove those (I can't point out which ones, because you didn't include the full POM in your snippet).

I also recommend getting rid of the plugin altogether and instead using the dependency classifier:

You can use a BooleanBuilder in Stream.reduce as follows:

The pagination code transforms your query from one returning Favorites to one returning (Favorites, i64). It adds a column via SELECT *, COUNT(*) to keep track of total counts.

You should either use the provided .load_and_count_pages() instead of .load() or you can probably get just the original columns by using a .select(). The code could possibly be modified to avoid adding the column if you don't need the counts and only need limit and offset.

Only the Insertable derive macro handles the #[table_name = ...] attribute. So it should not be included if you're not using it.