Comment appeler une fonction Oracle à partir d'Hibernate avec un paramètre de retour?

Ma question est très bien comme L'obtention de la valeur de retour d'une fonction PL/SQL via Hibernate

J'ai une fonction qui ne quelques modifications à l'interne et elle renvoie une valeur.

L'origine, l'idée était de faire quelque chose comme ceci:

protected Integer checkXXX(Long id, Long transId)
        throws Exception {
    final String sql = "SELECT MYSCHEMA.MYFUNC(" + id + ", "
            + transId + ") FROM DUAL";
    final BigDecimal nr = (BigDecimal) this.getHibernateTemplate()
            .getSessionFactory().getCurrentSession().createSQLQuery(sql)
            .uniqueResult();
    return nr.intValue();
}

Malheureusement cela ne fonctionne pas avec Oracle. Quelle est la méthode recommandée pour faire quelque chose comme cela?

Est-il un moyen d'extraire les variables déclarées à partir de l'intérieur de ma déclaration?

source d'informationauteur Mauli

Session Hibernate fournit une doWork() méthode qui vous donne un accès direct à java.sql.Connexion. Vous pouvez ensuite créer et utiliser java.sql.CallableStatement pour l'exécution de votre fonction:

session.doWork(new Work() {
  public void execute(Connection connection) throws SQLException {
    CallableStatement call = connection.prepareCall("{ ? = call MYSCHEMA.MYFUNC(?,?) }");
    call.registerOutParameter( 1, Types.INTEGER ); //or whatever it is
    call.setLong(2, id);
    call.setLong(3, transId);
    call.execute();
    int result = call.getInt(1); //propagate this back to enclosing class
  }
});

Oui, vous avez besoin d'un paramètre de sortie. Si vous utilisez le doWork() la méthode, vous feriez quelque chose comme ceci:

session.doWork(new Work() {
   public void execute(Connection conn) {
      CallableStatement stmt = conn.prepareCall("? = call <some function name>(?)");
      stmt.registerOutParameter(1, OracleTypes.INTEGER);
      stmt.setInt(2, <some value>);
      stmt.execute();
      Integer outputValue = stmt.getInt(1);
      //And then you'd do something with this outputValue
   }
});

Code alternatif 🙂

si vous voulez conséquence directe vous pouvez utiliser le code ci-dessous

 int result = session.doReturningWork(new ReturningWork<Integer>() {
  @Override
   public Integer  execute(Connection connection) throws SQLException {
    CallableStatement call = connection.prepareCall("{ ? = call MYSCHEMA.MYFUNC(?,?) }");
    call.registerOutParameter( 1, Types.INTEGER ); //or whatever it is
    call.setLong(2, id);
    call.setLong(3, transId);
    call.execute();
    return call.getInt(1); //propagate this back to enclosing class
  }
});

http://keyurj.blogspot.com.tr/2012/12/dowork-in-hibernate.html

J'ai écrit un article sur les différentes façons de les appeler des procédures stockées Oracle et les fonctions de mise en veille prolongée donc, pour résumer, vous avez les options suivantes:

Avec un @NamedNativeQuery:

@org.hibernate.annotations.NamedNativeQuery(
    name = "fn_my_func",
    query = "{ ? = call MYSCHEMA.MYFUNC(?, ?) }",
    callable = true,
    resultClass = Integer.class
)

Integer result = (Integer) entityManager.createNamedQuery("fn_my_func")
    .setParameter(1, 1)
    .setParameter(2, 1)
    .getSingleResult();

Avec l'API JDBC:

Session session = entityManager.unwrap( Session.class );

final AtomicReference<Integer> result = 
    new AtomicReference<>();

session.doWork( connection -> {
    try (CallableStatement function = connection
            .prepareCall(
                "{ ? = call MYSCHEMA.MYFUNC(?, ?) }"
            )
        ) {
        function.registerOutParameter( 1, Types.INTEGER );
        function.setInt( 2, 1 );
        function.setInt( 3, 1 );
        function.execute();
        result.set( function.getInt( 1 ) );
    }
} );

Avec un natif Oracle requête:

Integer result = (Integer) entityManager.createNativeQuery(
    "SELECT MYSCHEMA.MYFUNC(:id, :transId) FROM DUAL")
    .setParameter("postId", 1)
    .setParameter("transId", 1)
    .getSingleResult();

public static void getThroHibConnTest() throws Exception {
logger.debug("UsersActiion.getThroHibConnTest() | BEG ");
Transaction tx = null;
Connection conn = null;
CallableStatement cs = null;
Session session = HibernateUtil.getInstance().getCurrentSession();
try {
tx = session.beginTransaction();
conn = session.connection();
System.out.println("Connection = "+conn);
if (cs == null)
{
cs = 
conn.prepareCall("{ ?=call P_TEST.FN_GETSUM(?,?) }");
}
cs.clearParameters();
cs.registerOutParameter(1,OracleTypes.INTEGER);
cs.setInt(2,1);
cs.setInt(3,2);
cs.execute();
int retInt=cs.getInt(1);
tx.commit();            
}catch (Exception ex) {  
logger.error("UsersActiion.getThroHibConnTest() | ERROR | " , ex);  
if (tx != null && tx.isActive()) {
try {
//Second try catch as the rollback could fail as well
tx.rollback();
} catch (HibernateException e1) {
logger.debug("Error rolling back transaction");
}
//throw again the first exception
throw ex;
}
}finally{
try {
if (cs != null) {
cs.close();
cs = null;
}
if(conn!=null)conn.close();
} catch (Exception ex){;}
}
logger.debug("UsersActiion.getThroHibConnTest() | END ");
}

Vous devez vous connecter pour publier un commentaire.