Spring boot JPA how to query a #OneToMany relationship given one object in the many relationship - spring

Question

I've seen a few related questions but I can't seem to find the right answer for what I'm trying to do.
I have two tables Jobs and Workers, a job can have many workers, simplified entity
#Entity
#Table(name = "jobs")
data class Job(
#Id
#Type(type = "pg-uuid")
val id: UUID = UUID.randomUUID()
) {
#ManyToOne
var office: Office? = null
#OneToMany(targetEntity = Worker::class)
var requests: MutableList<Worker> = mutableListOf()
}
I want to be able to fetch a list of jobs for a specific worker
I've tried a few queries native and not, but trying to just do it by namedMethods now, whatever works I guess to be honest here is what seems like it should work in my jobs repo
#Repository
interface JobsRepo : CrudRepository<Job, UUID> {
#Query("SELECT j FROM Job j WHERE id = ?1")
fun findJobById(id: UUID): Job?
#Query("SELECT j FROM Job j WHERE office_id = ?1")
fun findJobsByOffice(id: UUID): List<Job>?
#Modifying
#Transactional
#Query("UPDATE jobs SET job_status = 4 WHERE job_status = 1 AND start_time < ?1", nativeQuery = true)
fun expireJobs(date: Date)
fun findByRequests_Worker(worker: Worker): List<Job>?
}
I'm not really sure how to query the array property
requests
with in input of one worker. I tried querying the UUID of the worker too since thats whats in the join table
JPA creates a join table with both foreign keys the table is
jobs_requests
and columns
job_id UUID
requests_id UUID

Answer 1

You mentioned that a Job can have many workers, and you also mentioned that you want to get a list of jobs for a specific worker. So this sounds like a ManyToMany relationship rather than OneToMany.
For a ManyToMany relationship, a join table is unavoidable. You need to specify #ManyToMany annotation on both entities, then you can use WorkerRepository to query for the worker and then to get the job list for that worker you will just need to access by worker.getJobs().
Following is the setup for the ManyToMany relationship, hope it can help:
#Entity
#Table(name = "jobs")
data class Job (
#ManyToMany
#get:ManyToMany
#get:JoinTable(
name = "worker_job",
joinColumns = [JoinColumn(name = "job_id")],
inverseJoinColumns = [JoinColumn(name = "worker_id")]
)
val worker: Set<Worker> = HashSet()
)
#Entity
#Table(name = "worker")
data class Worker (
#ManyToMany
#get:ManyToMany
#get:JoinTable(
name = "worker_job",
joinColumns = [JoinColumn(name = "worker_id")],
inverseJoinColumns = [JoinColumn(name = "job_id")]
)
val jobs: Set<Jobs> = HashSet()
)

Answer 2

Its also worth noting that for all practical uses, you should try to avoid explicit ManyToMany annotation. You should rather make a new Entity/Table which will have fields of a Job and Worker both with ManyToOne associations to their respective entities.
The reason why you should avoid explicit ManyToMany is because, say when there is a specific job for example JavaDev, and there are say 1000 Workers on the given job. And at one point you have a JavaDev entity and you want to get all the workers whose ages are between 20 and 25. To do this, one would iterate on the Workers list which is part of JavaDev entity and filter them out. When that happens there is 2 scenarios:
Workers list is a lazy association and when you try to access it hibernate will send 1000(n+1 problem) queries to the database.
Workers list is an eager association and hibernate will send same amount of queries to the database but as soon as you try to fetch JavaDev entity.
Hence your execution times will increase as there will be unnecessary amount of load on the database itself. And on larger projects this will get even more complicated.
All of this can be avoided if you create your own manytomany(job_workers for ex.) table, with accompanying repository and a service, from witch you'll be able to query your data more efficiently.