Est-il possible d'utiliser du SQL brut dans un référentiel Spring ?

Question

J'ai besoin d'utiliser du SQL brut dans un référentiel Spring Data, est-ce possible ? Tout ce que je vois autour de @Query est toujours basée sur l'entité.

Answer 1

L'annotation @Query permet d'exécuter des requêtes natives en définissant l'indicateur nativeQuery à true.

Citation de Spring Data JPA documents de référence .

Voir aussi cet article sur la façon de le faire avec une requête native nommée.

Answer 2

OUI, vous pouvez le faire de la manière suivante :

1. Par CrudRepository (Projection)

Les référentiels Spring Data renvoient généralement le modèle de domaine lors de l'utilisation des méthodes d'interrogation. Cependant, il peut arriver que vous ayez besoin de modifier la vue de ce modèle pour diverses raisons.

Supposons que votre entité soit comme ceci :

    import javax.persistence.*;
    import java.math.BigDecimal;

    @Entity
    @Table(name = "USER_INFO_TEST")
    public class UserInfoTest {
        private int id;
        private String name;
        private String rollNo;

        public UserInfoTest() {
        }

        public UserInfoTest(int id, String name) {
        this.id = id;
        this.name = name;
        }

        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        @Column(name = "ID", nullable = false, precision = 0)
        public int getId() {
            return id;
        }

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

        @Basic
        @Column(name = "name", nullable = true)
        public String getName() {
            return name;
        }

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

        @Basic
        @Column(name = "roll_no", nullable = true)
        public String getRollNo() {
            return rollNo;
        }

        public void setRollNo(String rollNo) {
            this.rollNo = rollNo;
        }
    }

Maintenant votre classe de Projection est comme ci-dessous. Elle peut contenir les champs dont vous avez besoin.

public interface IUserProjection {
     int getId();
     String getName();
     String getRollNo();
}

Et Your Data Access Object(Dao) is like bellow :

import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;

import java.util.ArrayList;

public interface UserInfoTestDao extends CrudRepository<UserInfoTest,Integer> {
    @Query(value = "select id,name,roll_no from USER_INFO_TEST where rollNo = ?1", nativeQuery = true)
    ArrayList<IUserProjection> findUserUsingRollNo(String rollNo);
}

Ahora ArrayList<IUserProjection> findUserUsingRollNo(String rollNo) vous donnera la liste des utilisateurs.

2. Utiliser EntityManager

Supposons que votre requête soit " select id,name from users where roll_no = 1001 ".

Ici, la requête retournera un objet avec les colonnes id et name. Votre classe de réponse est comme ci-dessous :

Votre classe de réponse est comme ceci :

public class UserObject{
        int id;
        String name;
        String rollNo;

        public UserObject(Object[] columns) {
            this.id = (columns[0] != null)?((BigDecimal)columns[0]).intValue():0;
            this.name = (String) columns[1];
        }

        public int getId() {
            return id;
        }

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

        public String getName() {
            return name;
        }

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

        public String getRollNo() {
            return rollNo;
        }

        public void setRollNo(String rollNo) {
            this.rollNo = rollNo;
        }
    }

Ici, le constructeur de UserObject obtiendra un tableau d'objets et définira les données avec l'objet.

public UserObject(Object[] columns) {
            this.id = (columns[0] != null)?((BigDecimal)columns[0]).intValue():0;
            this.name = (String) columns[1];
        }

Votre fonction d'exécution de la requête est la suivante :

public UserObject getUserByRoll(EntityManager entityManager,String rollNo) {

        String queryStr = "select id,name from users where roll_no = ?1";
        try {
            Query query = entityManager.createNativeQuery(queryStr);
            query.setParameter(1, rollNo);

            return new UserObject((Object[]) query.getSingleResult());
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }
    }

Ici, vous devez importer les paquets suivants :

import javax.persistence.Query;
import javax.persistence.EntityManager;

Maintenant, dans votre classe principale, vous devez appeler cette fonction. D'abord, récupérez EntityManager et appelez ceci getUserByRoll(EntityManager entityManager,String rollNo) fonction. La procédure d'appel est donnée ci-dessous :

Voici les importations

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

obtenir EntityManager de cette façon :

@PersistenceContext
private EntityManager entityManager;

UserObject userObject = getUserByRoll(entityManager,"1001");

Vous avez maintenant des données dans cet userObject.

Note :

query.getSingleResult() renvoie un tableau d'objets. Vous devez maintenir la position de la colonne et le type de données avec la position de la colonne de la requête.

select id,name from users where roll_no = 1001 

retourne un tableau et son [0] --> id and [1] -> name .

Plus d'informations sur ce site filetage y ce fil

Merci :)

Answer 3

Il est possible d'utiliser une requête brute dans un Spring Repository.

      @Query(value = "SELECT A.IS_MUTUAL_AID FROM planex AS A 
             INNER JOIN planex_rel AS B ON A.PLANEX_ID=B.PLANEX_ID  
             WHERE B.GOOD_ID = :goodId",nativeQuery = true)

      Boolean mutualAidFlag(@Param("goodId")Integer goodId);

Answer 4

Nous pouvons utiliser createNativeQuery("Here Native SQL Query ") ;

par exemple :

Query q = em.createNativeQuery("SELECT a.firstname, a.lastname FROM Author a");
List<Object[]> authors = q.getResultList();

Answer 5

Il est également possible d'utiliser Spring Data JDBC Il s'agit d'un projet Spring entièrement supporté, construit au-dessus de Spring Data Commons, qui permet d'accéder aux bases de données avec du SQL brut, sans utiliser JPA.

Elle est moins puissante que Spring Data JPA, mais si vous voulez une solution légère pour des projets simples sans utiliser un ORM comme Hibernate, c'est une solution qui vaut la peine d'être essayée.