JPA/hibernate中的子查询未返回正确的结果？

我在电影和演员表之间有一个

oneToMany

关联，而

manytone

关联的方式正好相反

我想知道某个演员的电影名字。在

SQL

中，此查询将

SELECT m.name from Movie m INNER JOIN Actor a on a.movie_id=m.movie_id AND a.name='BRAD'

在

JPQL

work中，将编写与

SELECT m.name from Movie m INNER JOIN m.actors act where act.name='BRAD'

此查询与上面描述的纯SQL查询不同

我希望能表演这样的东西，因为每个电影对象都有一组演员

SELECT m.name from Movie m, m.actors act where BRAD' EXISTS act.names

上面的查询语法是错误的。但它传达了我想要选择的东西。如何在不使用联接的情况下实现此查询，如果可能，如何在不使用子查询的情况下实现此查询

事实上，我尝试了以下子查询版本，但也不起作用：

select m.name from Movie m Where EXISTS (SELECT act.movie FROM Actor act where act.name='Brad')

上面的查询返回所有电影行

以下是我的实体中的相关部分：

    @Entity
public class Movie {

    @Id
    @Column(name="MOVIE_ID")
    @GeneratedValue
    private Long id;

    @Column(name="MovieName")
    private String name;

    @Column(name="Date_Released")
    private Date date;

    @OneToMany(mappedBy="movie",fetch=FetchType.EAGER,cascade=CascadeType.ALL)
    private Set<Actor> actors=new HashSet<>();

    public Movie(){}

    public Movie(String name, Date released){
        this.name=name;
        this.date=released;
    }


    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Date getDate() {
        return date;
    }

    public void setDate(Date date) {
        this.date = date;
    }

    public Set<Actor> getActors() {
        return actors;
    }

    public void setActors(Set<Actor> actors) {
        this.actors = actors;
    }

    public String toString(){
        return  id + " : " + name + " : " + date;
    }

    public void addActor(Actor a){
        getActors().add(a);
    }
}

    @Entity
public class Actor {
    @Id
    @Column(name="ACTOR_ID")
    @GeneratedValue
    private Long id;

    @Column(name="ACTOR_NAME")
    private String name;

    @ManyToOne(fetch=FetchType.EAGER)
    @JoinColumn(name="ACTOR_MOVIE")
    private Movie movie;


    public Actor(){}

    public Actor(String name){
        this.name=name;
    }


    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }


    public Movie getMovie() {
        return movie;
    }

    public void setMovie(Movie movie) {
        this.movie = movie;
    }

    public String toString(){
        return name + " : " + movie.getName();
    }

}

@实体
公映{
@身份证
@列（name=“MOVIE\u ID”）
@生成值
私人长id；
@列（name=“MovieName”）
私有字符串名称；
@列（name=“发布日期”）
私人日期；
@OneToMany（mappedBy=“movie”，fetch=FetchType.EAGER，cascade=CascadeType.ALL）
私有集actors=newhashset（）；
公共电影（）{}
公共电影（字符串名称、发布日期）{
this.name=name；
此日期=发布日期；
}
公共长getId（）{
返回id；
}
公共无效集合id（长id）{
this.id=id；
}
公共字符串getName（）{
返回名称；
}
公共void集合名（字符串名）{
this.name=名称；
}
公共日期getDate（）{
返回日期；
}
公共作废设置日期（日期）{
this.date=日期；
}
公共集getActors（）{
返回演员；
}
公共无效集合参与者（集合参与者）{
这个。演员=演员；
}
公共字符串toString（）{
返回id+“：”+名称+“：”+日期；
}
公共无效添加者（参与者a）{
getActors（）。添加（a）；
}
}
@实体
公共级演员{
@身份证
@列（name=“ACTOR\u ID”）
@生成值
私人长id；
@列（name=“ACTOR\u name”）
私有字符串名称；
@manytone（fetch=FetchType.EAGER）
@JoinColumn（name=“ACTOR\u MOVIE”）
私人电影；
公共参与者（）{}
公共参与者（字符串名称）{
this.name=name；
}
公共长getId（）{
返回id；
}
公共无效集合id（长id）{
this.id=id；
}
公共字符串getName（）{
返回名称；
}
公共void集合名（字符串名）{
this.name=名称；
}
公共电影{
回归电影；
}
公共电影（电影）{
这部电影=电影；
}
公共字符串toString（）{
返回name+“：”+movie.getName（）；
}
}

这里的测试类：

public class HibernateTest {

    public static void main(String[] args) {

 Movie movie1 = new Movie("Mr and Mrs.Smith", new Date(2005, 6, 5));
    Actor actor3=new Actor("Brad");
    actor3.setMovie(movie1);
    Actor actor4=new Actor("Joe"); 
    actor4.setMovie(movie1);
    movie1.getActors().add(actor3);
    movie1.getActors().add(actor4);

    Movie movie = new Movie("Titanic", new Date(1997,12,19));
    Actor actor1=new Actor("Leo");
    Actor actor2=new Actor("Kate");
    actor1.setMovie(movie);
    actor2.setMovie(movie); 
    movie.getActors().add(actor1); 
    movie.getActors().add(actor2); 


   SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
    Session session = sessionFactory.openSession();
    session.beginTransaction();
    session.persist(movie);
    session.persist(movie1);
    session.getTransaction().commit();
    session.close();

    session = sessionFactory.openSession();
    session.beginTransaction();
    List<String> bradMovies=session.createQuery("select m.name from Movie m, IN   (m.actors)actors"
            + " Where actors.name='BRAD'").list();
    System.out.println("bradMovies = "+ actorsFromMovies);
    session.getTransaction().commit();
    session.close();

公共类HibernateTest{
公共静态void main（字符串[]args）{
电影1=新电影（“史密斯夫妇”，新日期（2005年6月5日））；
演员3=新演员（“布拉德”）；
actor3.setMovie（电影1）；
演员4=新演员（“乔”）；
演员4.布景电影（电影1）；
movie1.getActors（）.add（actor3）；
movie1.getActors（）.add（actor4）；
电影=新电影（“泰坦尼克号”，新日期（1997,12,19））；
演员1=新演员（“Leo”）；
演员2=新演员（“凯特”）；
演员1.布景电影（电影）；
actor2.setMovie（电影）；
movie.getActors（）.add（actor1）；
movie.getActors（）.add（actor2）；
SessionFactory SessionFactory=新配置（）.configure（）.buildSessionFactory（）；
Session Session=sessionFactory.openSession（）；
session.beginTransaction（）；
坚持（电影）；
会议.坚持（电影1）；
session.getTransaction（）.commit（）；
session.close（）；
session=sessionFactory.openSession（）；
session.beginTransaction（）；
List bradMovies=session.createQuery（“在（m.actors）actors中从电影m中选择m.name”
+“Where actors.name='BRAD'）.list（）；
System.out.println（“bradMovies=“+actorsFromMovies”）；
session.getTransaction（）.commit（）；
session.close（）；

} }

编辑：

---

我编辑了上面的代码以包含整个代码。以前它只有片段。

这里是一个没有任何连接和子查询的HQL查询：

Query q2 = session.createQuery("SELECT m FROM Movie m, IN (m.actors)actors 
WHERE actors.name = 'Brad'");

你的问题中下面的查询同样有效，但我不清楚你为什么不想使用它

SELECT m.name from Movie m INNER JOIN m.actors act where act.name='BRAD'

---

上面的第一个解决方案是返回空列表。我是100%，因为我刚刚插入，所以有条目与之匹配。顺便说一句，我不想使用连接，如果它是不需要的。联接会导致更多的性能问题。@brainstorm，我已经在我的机器上测试了它，它工作了，所以我想我使用的和您使用的是不同的。您可以添加更多关于DB中实体和示例数据之间的映射以及hibernate为我的第一个HQL生成的查询的详细信息吗？这样我就可以看到区别在哪里了。此外，您还说您不想使用JOIN或子查询，因此您希望使用哪种查询，因为获取输出需要JOIN或子查询。请参阅代码中的上面的编辑。我已经粘贴了整个代码。