Opgeslagen procedures met slaapstand

1. Overzicht

Opgeslagen procedures zijn sets gecompileerde SQL-instructies woonachtig in de database. Ze worden gebruikt om logica in te kapselen en te delen met andere programma's, en profiteren van databasespecifieke functies zoals indexhints of specifieke trefwoorden.

Dit artikel laat zien hoe u Slaapstand om een opgeslagen procedure in een MySQL-database.

2. Opgeslagen procedures in MySQL

Voordat we bespreken hoe u een opgeslagen procedure vanuit Hibernate aanroept, moeten we deze maken.

Voor dit snelle MySQL-voorbeeld maken we een opgeslagen procedure om alle records van een foo tafel.

Om een ​​opgeslagen procedure te maken, maken we gebruik van de PROCEDURE MAKEN uitspraak:

DELIMITER // CREATE PROCEDURE GetAllFoos () TAAL SQL DETERMINISTIC SQL SECURITY DEFINER BEGIN SELECTEREN * VANAF foo; EINDE // DELIMITER;

Voordat de BEGINNEN statement, kunnen we optionele statements definiëren. U kunt inzoomen op de details van deze verklaringen door de officiële MySQL-documentatielink te volgen.

We kunnen de OPROEP verklaring om ervoor te zorgen dat onze procedure zich op de gewenste manier gedraagt:

BEL GetAllFoos ();

Nu we onze opgeslagen procedure in gebruik hebben, gaan we meteen door naar hoe we deze vanuit Hibernate kunnen aanroepen.

3. Roep een opgeslagen procedure met slaapstand op

Vanaf Hibernate 3 hebben we de mogelijkheid om onbewerkte SQL-instructies inclusief opgeslagen procedures te gebruiken om een ​​database te doorzoeken.

In dit gedeelte gaan we door een ogenschijnlijk eenvoudig voorbeeld dat illustreert hoe u de GetAllFoos () procedure met behulp van Slaapstand.

3.1. Configuratie

Voordat we beginnen met het schrijven van code die kan worden uitgevoerd, moeten we Hibernate in ons project hebben geconfigureerd.

En natuurlijk voor dat alles - de Maven-afhankelijkheden, MySQL-configuratie, Hibernate-configuratie en SessionFactory instantiatie - u kunt het Hibernate-artikel lezen.

3.2. Roep een opgeslagen procedure op met behulp van de CreateNativeSQL Methode

Hibernate maakt het mogelijk om vragen uit te drukken in native SQL formaat direct. Daarom kunnen we eenvoudig een native SQL-query maken en de OPROEP verklaring om de getAllFoos () opgeslagen procedure:

Queryquery = session.createSQLQuery ("CALL GetAllFoos ()"). AddEntity (Foo.class); Lijst allFoos = query.list (); 

De bovenstaande query retourneert een lijst waarin elk element een Foo object.

Wij gebruiken de addEntity () methode om entiteitsobjecten van de native SQL vraag, anders een ClassCastException wordt gegenereerd wanneer een opgeslagen procedure een niet-onbewerkte waarde retourneert.

3.3. Roep een opgeslagen procedure op met @NamedNativeQueries

Een andere manier om een ​​opgeslagen procedure aan te roepen, is door de @NamedNativeQueries annotatie.

@NamedNativeQueries wordt gebruikt om een ​​array van native SQL benoemde zoekopdrachten bereik naar de persistentie-eenheid:

@NamedNativeQueries ({@NamedNativeQuery (name = "callGetAllFoos", query = "CALL GetAllFoos ()", resultClass = Foo.class)}) @Entity public class Foo implementeert Serializable {// Model definition}

Elke benoemde query heeft duidelijk een naam attribuut, het werkelijke SQL-vraag, en de resultaatklassedie verwijst naar de Foo toegewezen entiteit.

Queryquery = session.getNamedQuery ("callGetAllFoos"); Lijst allFoos = query.list ();

De resultaatklasseattribuut speelt dezelfde rol als het addEntity () methode in ons vorige voorbeeld.

Beide benaderingen kunnen door elkaar worden gebruikt, aangezien er geen echte verschillen tussen de twee zijn als het gaat om prestaties of productiviteit.

3.4. Roep een opgeslagen procedure op met @NamedStoredProcedureQuery

Als u PPV 2.1 en de Slaapstand implementatie van de EntityManagerFactoryen EntityManager.

De @NamedStoredProcedureQuery annotatie kan worden gebruikt om een ​​opgeslagen procedure te declareren:

@NamedStoredProcedureQuery (name = "GetAllFoos", procedureName = "GetAllFoos", resultClasses = {Foo.class}) @Entity public class Foo implementeert Serializable {// Model Definition} 

Om onze benoemde opgeslagen procedure-query aan te roepen, moeten we een Entiteitsmanager, en bel dan het createNamedStoredProcedureQuery () methode om de procedure te maken:

StoredProcedureQuery spQuery = entityManager.createNamedStoredProcedureQuery ("getAllFoos"); 

We kunnen direct de lijst met Fooentiteiten door de uitvoeren () methode op StoredProcedureQueryvoorwerp.

4. Opgeslagen procedures met parameters

Voor bijna al onze opgeslagen procedures zijn parameters nodig. In deze sectie gaan we laten zien hoe u een opgeslagen procedure met parameters van aanroept Slaapstand.

Laten we een getFoosByName () opgeslagen procedure in MySQL.

Deze procedure retourneert een lijst met Foo objecten waarvan het naamkenmerk overeenkomt met de fooName parameter:

DELIMITER // CREATE PROCEDURE GetFoosByName (IN fooName VARCHAR (255)) TAAL SQL DETERMINISTIC SQL BEVEILIGINGSDEFINER BEGIN SELECTEREN * VANAF foo WAAR naam = fooName; EINDE // DELIMITER;

Om het GetFoosByName ()procedure zullen we benoemde parameters gebruiken:

Queryquery = session.createSQLQuery ("CALL GetFoosByName (: fooName)") .addEntity (Foo.class) .setParameter ("fooName", "New Foo");

Evenzo is de benoemde parameter : fooName kan worden gebruikt met de @NamedNativeQuery annotatie:

@NamedNativeQuery (name = "callGetFoosByName", query = "CALL GetFoosByName (: fooName)", resultClass = Foo.class)

De benoemde query zou als volgt worden aangeroepen:

Queryquery = session.getNamedQuery ("callGetFoosByName") .setParameter ("fooName", "New Foo");

Bij gebruik van de @NamedStoredProcedureQuery annotatie, kunnen we parameters specificeren met behulp van de @StoredProcedureParameter annotatie:

@NamedStoredProcedureQuery (name = "GetFoosByName", procedureName = "GetFoosByName", resultClasses = {Foo.class}, parameters = {@StoredProcedureParameter (name = "fooName", type = String.class, mode = ParameterMode.IN)}) 

We kunnen gebruik maken van de registerStoredProcedureParameter () methode om onze opgeslagen procedure aan te roepen met de fooName parameter:

StoredProcedureQuery spQuery = entityManager. createNamedStoredProcedureQuery ("GetFoosByName") .registerStoredProcedureParameter ("New Foo", String.class, ParameterMode.IN);

5. Conclusie

Dit artikel demonstreerde hoe u Hibernate gebruikt om een ​​opgeslagen procedure in een MySQL-database aan te roepen met verschillende benaderingen.

Dat is het vermelden waard niet alle RDBMS ondersteunen opgeslagen procedures.

Je kunt de voorbeelden in dit artikel bekijken in het gekoppelde GitHub-project.