HQL查询传递集合至自定义类触发PostgreSQL语法错误求助

为什么获取集合报错但size()可以正常工作？ #

这是HQL/JPQL的核心限制导致的：

• 当你在SELECT new中使用集合关联（比如q.votes这种@OneToMany属性）时，Hibernate无法直接将数据库的查询结果映射成集合对象。因为集合关联在SQL层面需要通过JOIN来获取多条记录，但HQL的SELECT new期望的是单个列/单个值作为构造参数，所以它会生成无效的SQL（也就是你看到的.）。
• 而q.votes.size()是HQL支持的特殊语法，Hibernate会自动把它转换成SQL的COUNT()聚合函数，最终返回单个数值，这符合构造参数需要单个值的要求，所以可以正常运行。

解决方案：几种可行的实现方式 #

1. 查询实体后手动转换为DTO（最直观的方案）

既然直接在HQL里构造带集合的DTO不行，我们可以先查询出关联了votes的Question实体，然后在服务层手动转换成你的Projection类：

修改Repository接口：

interface QuestionRepository : JpaRepository<Question, Long> {
    @Query("SELECT q FROM Question q LEFT JOIN FETCH q.votes WHERE q.form = :form")
    fun findQuestionsWithVotes(@Param("form") form: Form): List<Question>
}

这里用LEFT JOIN FETCH确保votes集合被加载（避免懒加载异常）。

在服务层转换：

@Service
class QuestionService(private val repo: QuestionRepository) {
    fun getQuestionProjections(form: Form): List<Projection> {
        return repo.findQuestionsWithVotes(form).map { question ->
            Projection(
                id = question.id,
                otherId = question.otherId,
                votes = question.votes.map { vote ->
                    VoteProjection(
                        id = vote.id,
                        user = vote.user?.let { VoteUserProjection(it.id) }
                    )
                }
            )
        }
    }
}

2. 使用Spring Data的接口投影（简洁方案）

如果你的DTO转换逻辑比较简单，可以用Spring Data的接口投影来自动处理嵌套集合：

定义投影接口：

interface QuestionProjection {
    fun getId(): Long
    fun getOtherId(): String
    fun getVotes(): List<VoteProjection>

    interface VoteProjection {
        fun getId(): Long
        fun getUser(): VoteUserProjection?

        interface VoteUserProjection {
            fun getId(): Long
        }
    }
}

修改Repository接口：

interface QuestionRepository : JpaRepository<Question, Long> {
    @Query("SELECT q FROM Question q LEFT JOIN FETCH q.votes WHERE q.form = :form")
    fun findQuestionProjections(@Param("form") form: Form): List<QuestionProjection>
}

Spring Data会自动将查询结果映射到这些接口的实现类中，不需要手动写转换逻辑。

3. 使用Hibernate的ResultTransformer（进阶方案）

如果一定要在查询层面完成转换，可以用EntityManager结合ResultTransformer，不过这种方式需要更多的手动配置：

@Service
class QuestionService(private val entityManager: EntityManager) {
    fun getQuestionProjections(form: Form): List<Projection> {
        val query = entityManager.createQuery("""
            SELECT q.id as id, q.otherId as otherId, v.id as voteId, u.id as userId
            FROM Question q
            LEFT JOIN q.votes v
            LEFT JOIN v.user u
            WHERE q.form = :form
        """)
        query.setParameter("form", form)
        
        return query.unwrap(org.hibernate.query.Query::class.java)
            .setResultTransformer(object : ResultTransformer {
                private val projections = mutableMapOf<Long, Projection>()

                override fun transformTuple(tuple: Array<Any>, aliases: Array<String>): Any? {
                    val questionId = tuple[0] as Long
                    var projection = projections[questionId]
                    if (projection == null) {
                        projection = Projection(
                            id = questionId,
                            otherId = tuple[1] as String,
                            votes = mutableListOf()
                        )
                        projections[questionId] = projection
                    }
                    
                    // 处理投票数据
                    val voteId = tuple[2] as Long?
                    if (voteId != null) {
                        val userId = tuple[3] as Long?
                        val voteProjection = VoteProjection(
                            id = voteId,
                            user = userId?.let { VoteUserProjection(it) }
                        )
                        (projection.votes as MutableList).add(voteProjection)
                    }
                    return null
                }

                override fun transformList(list: MutableList<*>): MutableList<*> {
                    return projections.values.toMutableList()
                }
            })
            .list() as List<Projection>
    }
}

这种方式需要自己处理分组逻辑，把JOIN后的多行结果转换成带集合的DTO。

总结 #

最推荐的是第一种或第二种方案：

• 如果需要复杂的转换逻辑（比如你的Vote到VoteProjection的映射），第一种手动转换的方式更灵活；
• 如果只是简单的属性映射，第二种接口投影的方式更简洁。

内容的提问来源于stack exchange，提问作者Julian