mysql - Spring Data 在 OneToMany 上创建内部联接

Question

所以我正在使用 spring 数据，并且在尝试获取此休眠查询的列表时遇到问题。

interface NewFooWithMetadataDAO : Repository<Foo, Int> {
    @Query("""SELECT NEW com.foo.persistence.sql.po.NewFooWithMetadataPO(
                    b.id,
                    b.accountId,
                    bi.profitCenterSegmentation,
                    b.fooContext
                )
                from
                    Foo b
                    left join b.fooIntent bi
                    left join b.fooContext bc
                where
                    account_id = ?1
                group by
                    b.id
    """)
    fun findByAccountId(accountId: Int): List<NewFooWithMetadataPO>
}

此查询创建一个像这样的休眠查询。

select 
    foo0_.id as col_0_0_, 
    foo0_.account_id as col_1_0_, 
    foo_buc1_.profit_center_segmentation as col_2_0_,
    . as col_3_0_ 
from 
    foo foo0_ 
    left outer join foo_intent foo_buc1_ on foo0_.foo_intent_id=foo_buc1_.id 
    left outer join foo_context_map foocont2_ on foo0_.id=foocont2_.foo_id 
    inner join foo_context_map foocont3_ on foo0_.id=foocont3_.foo_id 
where 
    account_id=? 
group by foo0_.id

这是一个错误的查询。

我还在 HQL 中尝试了 bc 而不是 b.fooContext，但是我没有得到集合，而是得到了一个 FooContextPO。

我的实体就像

@Entity
@Table(name = "foo")
data class Foo(
        @Id
        val id: Int,
        @Column(name= "account_id")
        val accountId: Int,

        @OneToOne
        @JoinColumn(name = "foo_intent_id", referencedColumnName = "id")
        @NotFound(action=NotFoundAction.IGNORE)
        val fooIntent: FooIntentPO,


        @OneToMany
        @JoinColumn(name = "foo_id", referencedColumnName = "id")
        @NotFound(action=NotFoundAction.IGNORE)
        val fooContext: Collection<FooContextPO>
){
        @Entity
        @Table(name = "foo_intent")
        data class FooIntentPO(
                @Id
                val id: Int,
                @Column(name = "profit_center_segmentation")
                val profitCenterSegmentation: String
        )
        @Entity
        @Table(name = "foo_context_map")
        data class FooContextPO(
                @Id
                val id: Int,
                @Column(name = "foo_id")
                val fooId: Int,
                @OneToOne
                @JoinColumn(name = "context_id", referencedColumnName = "id")
                val context: ContextPO
        )
        @Entity
        @Table(name = "context")
        data class ContextPO (
                @Id
                val id: Int,
                @ManyToOne
                @JoinColumn(name = "foo_id", referencedColumnName = "id")
                val foo: Foo,
                @Column(name = "context")
                val context: String
        )

}

data class NewFooWithMetadataPO(
        val id: Int,
        val accountId: Int?,
        val profitCenterSegmentation: String?,
        val context: Collection<Foo.FooContextPO>
)

有什么方法可以让左连接在这里正常工作而不生成内连接吗？

Answer 1

由于选择下面的映射属性b.fooContext，您肯定会获得内部连接

SELECT NEW com.foo.persistence.sql.po.NewFooWithMetadataPO(
                    b.id,
                    b.accountId,
                    bi.profitCenterSegmentation,
                    b.fooContext
                )...

您将作为 bc 单独外部联接到 FooContextPO，因此如果您想避免内部联接，则无法引用映射的属性 fooContext >。因此您需要选择 bc。

事实上，由于实际的基础数据，您只得到 1 条记录吗？当您选择 bc 而不是 b.fooContext 时生成的 SQL 看起来也不正确吗？如果是这样...你能分享一下那个sql是什么样的吗？