HQL Hibernate INNER DOŁĄCZ

Question

Jak mogę zrobić to zdanie SQL w Hibernate? Chciałbym użyć Hibernate do tworzenia zapytań, a nie tworzenia bazy danych.

SELECT * FROM Employee e INNER JOIN Team t ON e.Id_team=t.Id_team 

stworzyłem klas encji w SQLServer2008,

@Entity 
@Table(name="EMPLOYEE") 
public class Employee 
{ 
    @Id @GeneratedValue 
    @Column(name="ID_EMPLOYEE") 
    private int id_employee; 
    @Column(name="SURNAME") 
    private String surname; 
    @Column(name="FIRSTNAME") 
    private String firstname; 
    @Column(name="ID_PROFESSION") 
    private int id_profession; 
    @Column(name="ID_BOSS") 
    private int id_boss; 
    @Column(name="HIRED_DATE") 
    private Date hired; 
    @Column(name="SALARY") 
    private double salary; 
    @Column(name="SALARY_ADD") 
    private double salary_add; 
    @Column(name="ID_TEAM") 
    private int id_team; 
//set and get 

@Entity 
@Table(name="TEAM") 
public class Team 
{ 
    @Id @GeneratedValue 
    @Column(name="ID_TEAM") 
    private int id_team; 
    @Column(name="TEAMNAME") 
    private String teamname; 
    @Column(name="ADDRESS") 
    private String address; 
//set and get 

Próbowałem zbudować kwerendę wybierającą działa na wiele sposobów, ale nadal nie działa.

  SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory(); 
      Session session = sessionFactory.openSession();     
      session.beginTransaction(); 
      String select = "FROM Employee e INNER JOIN Team t ON e.Id_team=t.Id_team"; 
      Query query = session.createQuery(select); 
      List elist = query.list(); 
      session.getTransaction().commit(); 
      session.close();  

Może coś jest nie tak z podmiotami?

Answer 1

Przystawki można używać tylko wtedy, gdy istnieje powiązanie między nimi. Twój pracownik nie powinien mieć pola o nazwie id_team, typu int, zmapowanego do kolumny. Powinna ona mieć związek ManyToOne z podmiotem drużyn odwzorowany jako JoinColumn:

@ManyToOne 
@JoinColumn(name="ID_TEAM") 
private Team team; 

Następnie następujące zapytanie będzie działać bez zarzutu:

select e from Employee e inner join e.team 

Który będzie ładować wszystkich pracowników, z wyjątkiem tych, które aren jest związany z dowolnym zespołem.

To samo dotyczy wszystkich innych pól, które są kluczem obcym do innej tabeli odwzorowanej jako jednostka, oczywiście (id_boss, id_profession).

Czas przeczytać dokumentację hibernacji, ponieważ pominąłeś niezwykle ważną część tego, czym jest i jak działa.

Answer 2

import java.io.Serializable; 
import java.util.ArrayList; 
import java.util.List; 
import javax.persistence.CascadeType; 
import javax.persistence.Column; 
import javax.persistence.Entity; 
import javax.persistence.GeneratedValue; 
import javax.persistence.GenerationType; 
import javax.persistence.Id; 
import javax.persistence.OneToMany; 
import javax.persistence.Table; 

@Entity 
@Table(name="empTable") 
public class Employee implements Serializable{ 
private static final long serialVersionUID = 1L; 
private int id; 
private String empName; 

List<Address> addList=new ArrayList<Address>(); 


@Id 
@GeneratedValue(strategy=GenerationType.IDENTITY) 
@Column(name="emp_id") 
public int getId() { 
    return id; 
} 
public void setId(int id) { 
    this.id = id; 
} 
public String getEmpName() { 
    return empName; 
} 
public void setEmpName(String empName) { 
    this.empName = empName; 
} 

@OneToMany(mappedBy="employee",cascade=CascadeType.ALL) 
public List<Address> getAddList() { 
    return addList; 
} 

public void setAddList(List<Address> addList) { 
    this.addList = addList; 
} 
} 

Posiadamy dwa podmioty: Pracownika i Adres z jedną do wielu relacji.

import java.io.Serializable; 
import javax.persistence.Entity; 
import javax.persistence.GeneratedValue; 
import javax.persistence.GenerationType; 
import javax.persistence.Id; 
import javax.persistence.JoinColumn; 
import javax.persistence.ManyToOne; 
import javax.persistence.Table; 

@Entity 
@Table(name="address") 
public class Address implements Serializable{ 

private static final long serialVersionUID = 1L; 

private int address_id; 
private String address; 
Employee employee; 

@Id 
@GeneratedValue(strategy=GenerationType.IDENTITY) 
public int getAddress_id() { 
    return address_id; 
} 
public void setAddress_id(int address_id) { 
    this.address_id = address_id; 
} 
public String getAddress() { 
    return address; 
} 
public void setAddress(String address) { 
    this.address = address; 
} 

@ManyToOne 
@JoinColumn(name="emp_id") 
public Employee getEmployee() { 
    return employee; 
} 
public void setEmployee(Employee employee) { 
    this.employee = employee; 
} 
} 

W ten sposób możemy realizować sprzężenie wewnętrzne między dwiema tabelami

import java.util.List; 
import org.hibernate.Query; 
import org.hibernate.Session; 

public class Main { 

public static void main(String[] args) { 
    saveEmployee(); 

    retrieveEmployee(); 

} 

private static void saveEmployee() { 
    Employee employee=new Employee(); 
    Employee employee1=new Employee(); 
    Employee employee2=new Employee(); 
    Employee employee3=new Employee(); 

    Address address=new Address(); 
    Address address1=new Address(); 
    Address address2=new Address(); 
    Address address3=new Address(); 

    address.setAddress("1485,Sector 42 b"); 
    address1.setAddress("1485,Sector 42 c"); 
    address2.setAddress("1485,Sector 42 d"); 
    address3.setAddress("1485,Sector 42 a"); 

    employee.setEmpName("Varun"); 
    employee1.setEmpName("Krishan"); 
    employee2.setEmpName("Aasif"); 
    employee3.setEmpName("Dut"); 

    address.setEmployee(employee); 
    address1.setEmployee(employee1); 
    address2.setEmployee(employee2); 
    address3.setEmployee(employee3); 

    employee.getAddList().add(address); 
    employee1.getAddList().add(address1); 
    employee2.getAddList().add(address2); 
    employee3.getAddList().add(address3); 

    Session session=HibernateUtil.getSessionFactory().openSession(); 

    session.beginTransaction(); 

    session.save(employee); 
    session.save(employee1); 
    session.save(employee2); 
    session.save(employee3); 
    session.getTransaction().commit(); 
    session.close(); 
} 

private static void retrieveEmployee() { 
    try{ 

    String sqlQuery="select e from Employee e inner join e.addList"; 

    Session session=HibernateUtil.getSessionFactory().openSession(); 

    Query query=session.createQuery(sqlQuery); 

    List<Employee> list=query.list(); 

    list.stream().forEach((p)->{System.out.println(p.getEmpName());});  
    session.close(); 
    }catch(Exception e){ 
     e.printStackTrace(); 
    } 
} 
} 

Użyłem Java 8 pętli dla priting nazwiska. Upewnij się, że posiadasz jdk 1.8 z tomcat 8. Dodaj więcej rekordów, aby lepiej zrozumieć.

public class HibernateUtil { 
private static SessionFactory sessionFactory ; 
static { 
    Configuration configuration = new Configuration(); 

    configuration.addAnnotatedClass(Employee.class); 
    configuration.addAnnotatedClass(Address.class); 
        configuration.setProperty("connection.driver_class","com.mysql.jdbc.Driver"); 
    configuration.setProperty("hibernate.connection.url", "jdbc:mysql://localhost:3306/hibernate");         
    configuration.setProperty("hibernate.connection.username", "root");  
    configuration.setProperty("hibernate.connection.password", "root"); 
    configuration.setProperty("dialect", "org.hibernate.dialect.MySQLDialect"); 
    configuration.setProperty("hibernate.hbm2ddl.auto", "update"); 
    configuration.setProperty("hibernate.show_sql", "true"); 
    configuration.setProperty(" hibernate.connection.pool_size", "10"); 


    // configuration 
    StandardServiceRegistryBuilder builder = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties()); 
    sessionFactory = configuration.buildSessionFactory(builder.build()); 
} 
public static SessionFactory getSessionFactory() { 
    return sessionFactory; 
} 
} 

Answer 3

Możesz to zrobić bez konieczności tworzenia prawdziwego mapowania Hibernacji. Wypróbuj to:

SELECT * FROM Employee e, Team t WHERE e.Id_team=t.Id_team