특정 열을 가져오기 위한 휴지 상태 조건 쿼리

특정 열을 가져오기 위한 휴지 상태 조건 쿼리

코드에서 기준 쿼리를 사용하고 있습니다.항상 불이 난다select * from ...

대신 쿼리에서 하나의 열(필드)은 바이트 단위로 저장된 데이터가 많기 때문에 무시하려고 합니다.그리고 그것이 퍼포먼스 문제를 일으킵니다.

그것에 대한 아이디어를 줄 수 있는 사람이 있나요?

---

일부 업데이트

쿼리에 투영을 추가했더니 다음과 같은 쿼리가 생성되었습니다.

select
    this_.TEMPLATE_ID as y0_,
    this_.TEMPLATE_NAME as y1_,
    this_.CREATE_DATE as y2_,
    this_.UPDATE_DATE as y3_,
    this_.STATUS_CODE as y4_,
    this_.USER_ID as y5_,
    this_.UPDATED_BY as y6_,
    this_.CATEGORY_ID as y7_,
    this_.PRACTICE_ID as y8_ 
from
    templates this_ 
inner join
    user user1_ 
        on this_.USER_ID=user1_.USER_ID 
inner join
    template_categories category2_ 
        on this_.CATEGORY_ID=category2_.CATEGORY_ID 
where
    y4_=? 
    and y8_=? 
    and y5_ in (
        ?, ?
    ) 
order by
    y1_ asc limit ?

그리고 지금 문제는... Unknown column 'y4_' in 'where clause'y8_, y5_에 대해서도 같은 에러가 발생했음을 나타냅니다.

Query like...로 수정했습니다.

select
    this_.TEMPLATE_ID as y0_,
    this_.TEMPLATE_NAME as y1_,
    this_.CREATE_DATE as y2_,
    this_.UPDATE_DATE as y3_,
    this_.STATUS_CODE as y4_,
    this_.USER_ID as y5_,
    this_.UPDATED_BY as y6_,
    this_.CATEGORY_ID as y7_,
    this_.PRACTICE_ID as y8_ 
from
    templates this_ 
inner join
    user user1_ 
        on this_.USER_ID=user1_.USER_ID 
inner join
    template_categories category2_ 
        on this_.CATEGORY_ID=category2_.CATEGORY_ID 
where
    this_.STATUS_CODE=1
    and this_.PRACTICE_ID=1 
    and this_.USER_ID in (
        1, 2
    ) 
order by
    y1_ asc limit ?

그리고 그것은 성공하였다.그런데 HQL에서는 어떻게 수정해야 하는지 모르겠어요.

투영을 사용하여 반환할 열을 지정합니다.

예

SQL 쿼리

SELECT user.id, user.name FROM user;

휴지 상태 대체

Criteria cr = session.createCriteria(User.class)
    .setProjection(Projections.projectionList()
      .add(Projections.property("id"), "id")
      .add(Projections.property("Name"), "Name"))
    .setResultTransformer(Transformers.aliasToBean(User.class));

  List<User> list = cr.list();

JPQL 및 JPA Criteria API를 사용하여 임의의 종류의 DTO 투영(선택한 열만 DTO 클래스에 매핑)을 수행할 수 있습니다.아래 코드 스니펫을 참조하여 모든 열을 선택하는 대신 다양한 열을 선택하는 방법을 보여 줍니다.다음 예에서는 여러 컬럼에 결합되어 있는 다양한 컬럼을 선택하는 방법도 보여 줍니다.이게 도움이 됐으면 좋겠어요.

JPQL 코드:

String dtoProjection = "new com.katariasoft.technologies.jpaHibernate.college.data.dto.InstructorDto"
                + "(i.id, i.name, i.fatherName, i.address, id.proofNo, "
                + " v.vehicleNumber, v.vechicleType, s.name, s.fatherName, "
                + " si.name, sv.vehicleNumber , svd.name) ";

        List<InstructorDto> instructors = queryExecutor.fetchListForJpqlQuery(
                "select " + dtoProjection + " from Instructor i " + " join i.idProof id " + " join i.vehicles v "
                        + " join i.students s " + " join s.instructors si " + " join s.vehicles sv "
                        + " join sv.documents svd " + " where i.id > :id and svd.name in (:names) "
                        + " order by i.id , id.proofNo , v.vehicleNumber , si.name , sv.vehicleNumber , svd.name ",
                CollectionUtils.mapOf("id", 2, "names", Arrays.asList("1", "2")), InstructorDto.class);

        if (Objects.nonNull(instructors))
            instructors.forEach(i -> i.setName("Latest Update"));

        DataPrinters.listDataPrinter.accept(instructors);

JPA Criteria API 코드:

@Test
    public void fetchFullDataWithCriteria() {
        CriteriaBuilder cb = criteriaUtils.criteriaBuilder();
        CriteriaQuery<InstructorDto> cq = cb.createQuery(InstructorDto.class);

        // prepare from expressions
        Root<Instructor> root = cq.from(Instructor.class);
        Join<Instructor, IdProof> insIdProofJoin = root.join(Instructor_.idProof);
        Join<Instructor, Vehicle> insVehicleJoin = root.join(Instructor_.vehicles);
        Join<Instructor, Student> insStudentJoin = root.join(Instructor_.students);
        Join<Student, Instructor> studentInsJoin = insStudentJoin.join(Student_.instructors);
        Join<Student, Vehicle> studentVehicleJoin = insStudentJoin.join(Student_.vehicles);
        Join<Vehicle, Document> vehicleDocumentJoin = studentVehicleJoin.join(Vehicle_.documents);

        // prepare select expressions.
        CompoundSelection<InstructorDto> selection = cb.construct(InstructorDto.class, root.get(Instructor_.id),
                root.get(Instructor_.name), root.get(Instructor_.fatherName), root.get(Instructor_.address),
                insIdProofJoin.get(IdProof_.proofNo), insVehicleJoin.get(Vehicle_.vehicleNumber),
                insVehicleJoin.get(Vehicle_.vechicleType), insStudentJoin.get(Student_.name),
                insStudentJoin.get(Student_.fatherName), studentInsJoin.get(Instructor_.name),
                studentVehicleJoin.get(Vehicle_.vehicleNumber), vehicleDocumentJoin.get(Document_.name));

        // prepare where expressions.
        Predicate instructorIdGreaterThan = cb.greaterThan(root.get(Instructor_.id), 2);
        Predicate documentNameIn = cb.in(vehicleDocumentJoin.get(Document_.name)).value("1").value("2");
        Predicate where = cb.and(instructorIdGreaterThan, documentNameIn);

        // prepare orderBy expressions.
        List<Order> orderBy = Arrays.asList(cb.asc(root.get(Instructor_.id)),
                cb.asc(insIdProofJoin.get(IdProof_.proofNo)), cb.asc(insVehicleJoin.get(Vehicle_.vehicleNumber)),
                cb.asc(studentInsJoin.get(Instructor_.name)), cb.asc(studentVehicleJoin.get(Vehicle_.vehicleNumber)),
                cb.asc(vehicleDocumentJoin.get(Document_.name)));

        // prepare query
        cq.select(selection).where(where).orderBy(orderBy);
        DataPrinters.listDataPrinter.accept(queryExecutor.fetchListForCriteriaQuery(cq));

    }

이 접근방식은 심플하고 깨끗하기 때문에 마음에 듭니다.

    String getCompaniesIdAndName = " select "
            + " c.id as id, "
            + " c.name as name "
            + " from Company c ";

    @Query(value = getCompaniesWithoutAccount)
    Set<CompanyIdAndName> findAllIdAndName();

    public static interface CompanyIdAndName extends DTO {
        Integer getId();

        String getName();

    }

이 클래스에 근거해 다른 엔티티를 매핑할 수 있습니다(두 개의 엔티티를 구별하기 위해서 entity-name 을 사용할 필요가 있습니다).두 번째 엔티티는 dto 가 됩니다(dto에 설계상의 문제가 있는 것을 잊습니다).두 번째 엔티티가 일반 엔티티가 아님을 명확히 하기 위해 두 번째 엔티티를 읽기 전용으로 정의하고 적절한 이름을 지정해야 합니다.참고로 몇 개의 컬럼만 선택하면 프로젝션이라고 불리므로 구글에서 검색하기가 더 쉬울 것입니다.

또는 필요한 필드 목록을 사용하여 명명된 쿼리를 만들거나(선택에 포함), 투영 기준을 사용할 수 있습니다.

사용할 수 있습니다.multiselect기능을 합니다.

   CriteriaBuilder cb=session.getCriteriaBuilder();
            CriteriaQuery<Object[]> cquery=cb.createQuery(Object[].class);
            Root<Car> root=cquery.from(User.class);
            cquery.multiselect(root.get("id"),root.get("Name"));
            Query<Object[]> q=session.createQuery(cquery);
            List<Object[]> list=q.getResultList();
            System.out.println("id        Name");
            for (Object[] objects : list) {
                System.out.println(objects[0]+"        "+objects[1]);
             }
            

이는 휴지 상태5에서 지원됩니다. createCriteria다음 버전의 휴지 상태에서는 권장되지 않습니다.이 때문에,criteria builder대신.

언급URL : https://stackoverflow.com/questions/11626761/hibernate-criteria-query-to-get-specific-columns