Question

我的标准如下：

public List<role> searchByFormStatus(boolean status) {
    Criteria criteria = this.getSession().createCriteria(this.getPersistentClass());
    List<role> result = (List<role>) criteria                               
                        .setFetchMode("role", FetchMode.JOIN)
                        .setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY)
                        .createAlias("formApprovals", "f")
                        .add(Restrictions. eq("f.latestApproval", true))
                        .list();
    return result;                          
}

首先看它应该工作，但无论我在参数中发送true或false值，结果总是

[{
    "roleIsActive": true,
    "roleName": "role1",
    "roleNotes": "note",
    "formApprovals": [
        {
            "approvalNotes": "good",
            "approvedDate": 1449900000000,
            "fkapprovedBy": 1,
            "idformApproval": 1,
            "latestApproval": true
        },
        {
            "approvalNotes": "bad",
            "approvedDate": 1449900000000,
            "fkapprovedBy": 1,
            "idformApproval": 2,
            "latestApproval": false
        }
}]

正如您所看到的，＆＃34; formApprovals＆＃34;即使我创建了对latestApproval属性的限制

，也会将所有寄存器都包含在数据库中

父对象（角色）中的属性声明是：

@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER, mappedBy="role")
public Set<FormApproval> getFormApprovals() {
    return this.formApprovals;
}

public void setFormApprovals(Set<FormApproval> formApprovals) {
    this.formApprovals = formApprovals;
}

检查控制台，我可以看到hibernate正在正确生成where子句，但是，我可以看到之后还有其他查询，这些查询是否可能（我不知道它们为什么存在）是否覆盖了我的标准？

有什么想法吗？

修改

FormApproval Class

@Entity
@Table(name="FormApproval"
    ,catalog="catalog"
)
public class FormApproval  implements java.io.Serializable {

    private static final long serialVersionUID = 8L;
     private int idformApproval;
     private role role;
     private Integer fkapprovedBy;
     private Date approvedDate;
     private String approvalNotes;
     private boolean latestApproval;

    public FormApproval() {
    }


    public FormApproval(int idformApproval, role role) {
        this.idformApproval = idformApproval;
        this.role = role;
    }
    public FormApproval(int idformApproval, role role, Integer fkapprovedBy, Date approvedDate, String approvalNotes, boolean latestApproval) {
       this.idformApproval = idformApproval;
       this.role = role;
       this.fkapprovedBy = fkapprovedBy;
       this.approvedDate = approvedDate;
       this.approvalNotes = approvalNotes;
       this.latestApproval = latestApproval; 
    }

     @Id @GeneratedValue(strategy = IDENTITY) 

    @Column(name="IDFormApproval", unique=true, nullable=false)
    public int getIdformApproval() {
        return this.idformApproval;
    }

    public void setIdformApproval(int idformApproval) {
        this.idformApproval = idformApproval;
    }

@JsonIgnore
@ManyToOne(fetch=FetchType.EAGER)
    @JoinColumn(name="FKRole", nullable=false)
    public role getrole() {
        return this.role;
    }

    public void setrole(role role) {
        this.role = role;
    }


    @Column(name="LatestApproval")
    public boolean getLatestApproval() {
        return this.latestApproval;
    }

    public void setLatestApproval(boolean latestApproval) {
        this.latestApproval = latestApproval;
    }

    @Column(name="FKApprovedBy")
    public Integer getFkapprovedBy() {
        return this.fkapprovedBy;
    }

    public void setFkapprovedBy(Integer fkapprovedBy) {
        this.fkapprovedBy = fkapprovedBy;
    }
    @Temporal(TemporalType.DATE)
    @Column(name="ApprovedDate", length=10)
    public Date getApprovedDate() {
        return this.approvedDate;
    }

    public void setApprovedDate(Date approvedDate) {
        this.approvedDate = approvedDate;
    }

    @Column(name="ApprovalNotes")
    public String getApprovalNotes() {
        return this.approvalNotes;
    }

    public void setApprovalNotes(String approvalNotes) {
        this.approvalNotes = approvalNotes;
    }
}

角色等级

@Entity
@Table(name="Role"
    ,catalog="catalog"
)    
public class Role  implements java.io.Serializable {

    private static final long serialVersionUID = 1L;
    private int idRole;
     private WorkType workType;
     private String roleName;
     private String roleNotes;
     private boolean roleIsActive;
     private Set<FormApproval> formApprovals = new HashSet<FormApproval>(0);
     private Set<Topicrole> topicRoles = new HashSet<TopicRole>(0);
     private Set<FormFeedBack> formFeedBacks = new HashSet<FormFeedBack>(0);
     private Set<UserRole> userRoles = new HashSet<UserRrole>(0);
     private Set<Interview> interviews = new HashSet<Interview>(0);

    public Role() {
    }


    public Role(int idRole, WorkType workType, String roleName, boolean roleIsActive) {
        this.idRole = idRole;
        this.workType = workType;
        this.RoleName = RoleName;
        this.roleIsActive = roleIsActive;
    }
    public Role(int idRole, WorkType workType, String roleName, String roleNotes, boolean roleIsActive, Set<FormApproval> formApprovals, Set<TopicRole> topicRoles, Set<FormFeedBack> formFeedBacks, Set<UserRole> userRoles, Set<Interview> interviews) {
       this.idRole = idRole;
       this.workType = workType;
       this.RoleName = RoleName;
       this.roleNotes = roleNotes;
       this.roleIsActive = roleIsActive;
       this.formApprovals = formApprovals;
       this.topicRoles = topicRoles;
       this.formFeedBacks = formFeedBacks;
       this.userRoles = userRoles;
       this.interviews = interviews;
    }

     @Id @GeneratedValue(strategy = IDENTITY) 

    @Column(name="IDRole", unique=true, nullable=false)
    public int getIdrole() {
        return this.idRole;
    }

    public void setIdrole(int idRole) {
        this.idRole = idRole;
    }
@ManyToOne(fetch=FetchType.EAGER)
    @JoinColumn(name="FKWorkType", nullable=false)
    public WorkType getWorkType() {
        return this.workType;
    }

    public void setWorkType(WorkType workType) {
        this.workType = workType;
    }

    @Column(name="RoleName", nullable=false)
    public String getRoleName() {
        return this.roleName;
    }

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }

    @Column(name="RoleNotes")
    public String getRoleNotes() {
        return this.roleNotes;
    }

    public void setRoleNotes(String roleNotes) {
        this.roleNotes = roleNotes;
    }

    @Column(name="RoleIsActive", nullable=false)
    public boolean isRoleIsActive() {
        return this.roleIsActive;
    }

    public void setRoleIsActive(boolean roleIsActive) {
        this.roleIsActive = roleIsActive;
    }

@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER, mappedBy="role")
    public Set<FormApproval> getFormApprovals() {
        return this.formApprovals;
    }

    public void setFormApprovals(Set<FormApproval> formApprovals) {
        this.formApprovals = formApprovals;
    }

@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER, mappedBy="role")
    public Set<TopicRole> getTopicRoles() {
        return this.topicRoles;
    }

    public void setTopicRoles(Set<TopicRole> topicRoles) {
        this.topicRoles = topicRoles;
    }

@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER, mappedBy="role")
@JsonManagedReference
    public Set<FormFeedBack> getFormFeedBacks() {
        return this.formFeedBacks;
    }

    public void setFormFeedBacks(Set<FormFeedBack> formFeedBacks) {
        this.formFeedBacks = formFeedBacks;
    }

@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER, mappedBy="role")
    public Set<UserRole> getUserRoles() {
        return this.userRoles;
    }

    public void setUserRoles(Set<UserRole> userRoles) {
        this.userRoles = userRoles;
    }

@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER, mappedBy="acnrole")
    public Set<Interview> getInterviews() {
        return this.interviews;
    }

    public void setInterviews(Set<Interview> interviews) {
        this.interviews = interviews;
    }

}

Answer 1

您可以尝试在协会之上使用限制作为ON子句的一部分。

@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER, mappedBy="role")
@Where(clause=" latestApproval='true' ")
public Set<FormApproval> getFormApprovals() {
    return this.formApprovals;
}

此外，您可以使用方法FetchMode.JOIN

指向关联路径，从而取消设置org.hibernate.Criteria.createAlias(String associationPath, String alias, JoinType joinType)设置

public List<role> searchByFormStatus(boolean status) {
    Criteria criteria = this.getSession().createCriteria(Role.class, "role")
            .setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY)
            .createAlias("role.formApprovals", "formApprovals", JoinType.LEFT_OUTER_JOIN);
    return criteria.list();
}

<强>更新

对于旧版本的hibernate，请使用下面的其他方法。对于joinType，LEFT_OUTER_JOIN值为1，并且join子句可以作为第4个参数传递。

public Criteria createAlias(String associationPath, String alias, int joinType, Criterion withClause) throws HibernateException;

Answer 2

使用

修复

# testing
library(Rcpp)
library(microbenchmark)

parameters <- list()
indices <- list()
indices_trad <- list()

set.seed(2)
for (i in 4:12){
    size <- 4^i
    window_size <- 100
    parameters[[i-3]] <- runif(size)
    indices[[i-3]] <- floor(runif(window_size)*size)
    temp <- rep(0, size)
    for (j in 1:window_size){
        temp[indices[[i-3]][j] + 1] <- temp[indices[[i-3]][j] + 1] + 1
    }
    indices_trad[[i-3]] <- temp
}

microbenchmark(
    x <- sapply(1:9, function(i) dot_prod(indices[[i]], parameters[[i]])),
    x_c <- sapply(1:9, function(i) dot_prod_c(indices[[i]], parameters[[i]])),
    x_base <- sapply(1:9, function(i) indices_trad[[i]] %*% parameters[[i]])
)
all.equal(x, x_base) # is true, does work
all.equal(x_c, x_base) # not true - C++ version returns only NAs

1强制查询中的左外连接

Answer 3

使用EAGER提取类型，嵌套标准应适用于这种情况：

public List<role> searchByFormStatus(boolean status) {
    Criteria criteria = this.getSession().createCriteria(this.getPersistentClass());
    List<role> result = (List<role>) criteria                               
                        .createCriteria("formApprovals")
                             .add(Restrictions.eq("latestApproval", true))
                        .list();
    return result;                          
}

连接表上的Hibernate Criterion显示意外结果

3 个答案: