जावा और जेपीए से संग्रहीत प्रक्रिया को कैसे कॉल करें

Question 1

मैं एक संग्रहीत प्रक्रिया को कॉल करने और कुछ डेटा पुनर्प्राप्त करने के लिए एक साधारण वेब एप्लिकेशन लिख रहा हूं। इसका एक बहुत ही सरल अनुप्रयोग है, जो क्लाइंट के डेटाबेस के साथ सहभागिता करता है। हम कर्मचारी आईडी और कंपनी आईडी पास करते हैं और संग्रहीत प्रक्रिया कर्मचारी विवरण वापस कर देगी।

वेब एप्लिकेशन डेटा को अपडेट / डिलीट नहीं कर सकता है और SQL सर्वर का उपयोग कर रहा है।

मैं अपने वेब एप्लिकेशन को Jboss AS में तैनात कर रहा हूं। क्या मुझे संग्रहीत कार्यविधि का उपयोग करने के लिए जेपीए का उपयोग करना चाहिए या CallableStatement। इस मामले में जेपीए का उपयोग करने का कोई फायदा।

इसके अलावा इस संग्रहीत प्रक्रिया को कॉल करने के लिए sql कथन क्या होगा। मैंने पहले कभी भी संग्रहीत प्रक्रियाओं का उपयोग नहीं किया है और मैं इससे जूझ रहा हूं। Google बहुत मदद नहीं कर रहा था।

यहाँ संग्रहीत प्रक्रिया है:

CREATE procedure getEmployeeDetails (@employeeId int, @companyId int)
as
begin
    select firstName, 
           lastName, 
           gender, 
           address
      from employee et
     where et.employeeId = @employeeId
       and et.companyId = @companyId
end

अपडेट करें:

किसी और को जेपीए के उपयोग से संग्रहीत प्रक्रिया को कॉल करने में समस्या हो सकती है ।

Query query = em.createNativeQuery("{call getEmployeeDetails(?,?)}",
                                   EmployeeDetails.class)           
                                   .setParameter(1, employeeId)
                                   .setParameter(2, companyId);

List<EmployeeDetails> result = query.getResultList();

मैंने जिन चीजों पर ध्यान दिया है:

पैरामीटर नाम मेरे लिए काम नहीं करते थे, इसलिए पैरामीटर इंडेक्स का उपयोग करने का प्रयास करें।
के {call sp_name(?,?)}बजाय सही एसक्यूएल बयानcall sp_name(?,?)
यदि संग्रहीत प्रक्रिया एक परिणाम सेट लौटा रही है, भले ही आप केवल एक पंक्ति के साथ जानते हों, getSingleResultअभ्यस्त काम
एक resultSetMappingनाम या परिणाम वर्ग विवरण पास करें

Question 2

JPA 2.1 अब Stored Procedure का समर्थन करता है, यहाँ जावा डॉक पढ़ें ।

उदाहरण:

StoredProcedureQuery storedProcedure = em.createStoredProcedureQuery("sales_tax");
// set parameters
storedProcedure.registerStoredProcedureParameter("subtotal", Double.class, ParameterMode.IN);
storedProcedure.registerStoredProcedureParameter("tax", Double.class, ParameterMode.OUT);
storedProcedure.setParameter("subtotal", 1f);
// execute SP
storedProcedure.execute();
// get result
Double tax = (Double)storedProcedure.getOutputParameterValue("tax");

विस्तृत उदाहरण यहाँ देखें ।

Question 3

मैं अपने वेब एप्लिकेशन को Jboss AS में तैनात कर रहा हूं। क्या मुझे संग्रहीत कार्यविधि या CallableStatement तक पहुँचने के लिए JPA का उपयोग करना चाहिए। इस मामले में जेपीए का उपयोग करने का कोई फायदा।

यह वास्तव में जेपीए द्वारा समर्थित नहीं है, लेकिन यह उल्लेखनीय है । फिर भी मैं इस तरह नहीं जाऊंगा:

कुछ बीन्स में संग्रहीत प्रक्रिया कॉल के परिणाम को मैप करने के लिए जेपीए का उपयोग करना वास्तव में बहुत अधिक है,
विशेष रूप से यह देखते हुए कि जेपीए संग्रहीत प्रक्रिया को कॉल करने के लिए वास्तव में उपयुक्त नहीं है (वाक्यविन्यास बहुत क्रियात्मक होगा)।

मैं इस प्रकार JDBC डेटा एक्सेस के लिए स्प्रिंग सपोर्ट , या MyBatis जैसे डेटा मैपर या अपने एप्लिकेशन की सादगी को देखते हुए कच्चे JDBC का उपयोग करने पर विचार करूंगाCallableStatement । दरअसल, JDBC शायद मेरी पसंद होगी। यहाँ एक बुनियादी किकऑफ उदाहरण है:

CallableStatement cstmt = con.prepareCall("{call getEmployeeDetails(?, ?)}");
cstmt.setInt("employeeId", 123);
cstmt.setInt("companyId", 456);
ResultSet rs = cstmt.executeQuery();

संदर्भ

JDBC प्रलेखन: जावा एसई 6

Question 4

आपको संग्रहीत कार्यविधि के लिए मापदंडों को पारित करने की आवश्यकता है।

कुछ इस तरह से इसे काम करना चाहिए:

    List result = em
      .createNativeQuery("call getEmployeeDetails(:employeeId,:companyId)")
      .setParameter("emplyoyeeId", 123L)
      .setParameter("companyId", 456L)
      .getResultList();

अपडेट करें:

या शायद यह नहीं होना चाहिए।

बुक ईजेबी 3 इन एक्शन में , यह पृष्ठ 383 पर कहता है, कि जेपीए संग्रहीत प्रक्रियाओं का समर्थन नहीं करता है (पृष्ठ केवल एक पूर्वावलोकन है, आपको पूर्ण पाठ नहीं मिलता है, पूरी पुस्तक इस एक सहित कई स्थानों पर डाउनलोड के रूप में उपलब्ध है , मुझे नहीं पता कि यह कानूनी है)।

वैसे भी, पाठ यह है:

JPA और डेटाबेस संग्रहीत कार्यविधियाँ

यदि आप SQL के बहुत बड़े प्रशंसक हैं, तो आप डेटाबेस संग्रहीत प्रक्रियाओं की शक्ति का दोहन करने के लिए तैयार हो सकते हैं। दुर्भाग्य से, JPA संग्रहीत प्रक्रियाओं का समर्थन नहीं करता है, और आपको अपने दृढ़ता प्रदाता के स्वामित्व सुविधा पर निर्भर रहना होगा। हालाँकि, आप मूल संग्रहीत कार्य (बिना मापदंडों के) को मूल SQL क्वेरी के साथ उपयोग कर सकते हैं।

Question 5

JPA का उपयोग करके संग्रहीत कार्यविधि उत्पादन पैरामीटर को कैसे प्राप्त करें (2.0 के लिए एक्लिप्स आयात और 2.1 की आवश्यकता नहीं है)

भले ही यह जवाब एक संग्रहीत प्रक्रिया से रिकॉर्डसेट वापस करने पर विस्तृत रूप से बताता है, मैं यहां पोस्ट कर रहा हूं, क्योंकि मुझे यह पता लगाने में उम्र लग गई और इस धागे ने मेरी मदद की।

मेरा एप्लिकेशन Eclipselink-2.3.1 का उपयोग कर रहा था, लेकिन मैं Eclipselink-2.5.0 में अपग्रेड करने के लिए मजबूर कर दूंगा, क्योंकि JPA 2.1 में संग्रहीत प्रक्रियाओं के लिए बेहतर समर्थन है।

EclipseLink-2.3.1 / JPA-2.0 का उपयोग करना: कार्यान्वयन-निर्भर

इस विधि को "org.eclipse.persistence" से एक्लिप्सलिंक कक्षाओं के आयात की आवश्यकता है, इसलिए यह एक्लिप्सलिंक कार्यान्वयन के लिए विशिष्ट है।

मैंने इसे " http://www.yenlo.nl/en/calling-oracle-stored-procedures-from-eclipselink-with-multiple-out-parameters " पर पाया ।

StoredProcedureCall storedProcedureCall = new StoredProcedureCall();
storedProcedureCall.setProcedureName("mypackage.myprocedure");
storedProcedureCall.addNamedArgument("i_input_1"); // Add input argument name.
storedProcedureCall.addNamedOutputArgument("o_output_1"); // Add output parameter name.
DataReadQuery query = new DataReadQuery();
query.setCall(storedProcedureCall);
query.addArgument("i_input_1"); // Add input argument names (again);
List<Object> argumentValues = new ArrayList<Object>();
argumentValues.add("valueOf_i_input_1"); // Add input argument values.
JpaEntityManager jpaEntityManager = (JpaEntityManager) getEntityManager();
Session session = jpaEntityManager.getActiveSession();
List<?> results = (List<?>) session.executeQuery(query, argumentValues);
DatabaseRecord record = (DatabaseRecord) results.get(0);
String result = String.valueOf(record.get("o_output_1")); // Get output parameter

EclipseLink-2.5.0 / JPA-2.1 का उपयोग करना: कार्यान्वयन-स्वतंत्र (इस थ्रेड में पहले से ही प्रलेखित)

यह विधि स्वतंत्र रूप से लागू हो रही है (एक्लिप्सिन आयात की आवश्यकता नहीं है)।

StoredProcedureQuery query = getEntityManager().createStoredProcedureQuery("mypackage.myprocedure");
query.registerStoredProcedureParameter("i_input_1", String.class, ParameterMode.IN);
query.registerStoredProcedureParameter("o_output_1", String.class, ParameterMode.OUT);
query.setParameter("i_input_1", "valueOf_i_input_1");
boolean queryResult = query.execute();
String result = String.valueOf(query.getOutputParameterValue("o_output_1"));

Question 6

एक सरल संग्रहीत कार्यविधि के लिए जो इस तरह IN / OUT मापदंडों का उपयोग करता है

CREATE OR REPLACE PROCEDURE count_comments (  
   postId IN NUMBER,  
   commentCount OUT NUMBER )  
AS 
BEGIN 
    SELECT COUNT(*) INTO commentCount  
    FROM post_comment  
    WHERE post_id = postId; 
END;

आप इसे जेपीए से कह सकते हैं:

StoredProcedureQuery query = entityManager
    .createStoredProcedureQuery("count_comments")
    .registerStoredProcedureParameter(1, Long.class, 
        ParameterMode.IN)
    .registerStoredProcedureParameter(2, Long.class, 
        ParameterMode.OUT)
    .setParameter(1, 1L);

query.execute();

Long commentCount = (Long) query.getOutputParameterValue(2);

एक संग्रहीत प्रक्रिया के लिए जो एक SYS_REFCURSOROUT पैरामीटर का उपयोग करता है :

CREATE OR REPLACE PROCEDURE post_comments ( 
   postId IN NUMBER, 
   postComments OUT SYS_REFCURSOR ) 
AS 
BEGIN
    OPEN postComments FOR
    SELECT *
    FROM post_comment 
    WHERE post_id = postId; 
END;

आप इसे इस प्रकार कह सकते हैं:

StoredProcedureQuery query = entityManager
    .createStoredProcedureQuery("post_comments")
    .registerStoredProcedureParameter(1, Long.class, 
         ParameterMode.IN)
    .registerStoredProcedureParameter(2, Class.class, 
         ParameterMode.REF_CURSOR)
    .setParameter(1, 1L);

query.execute();

List<Object[]> postComments = query.getResultList();

SQL फ़ंक्शन के लिए जो निम्नानुसार दिखता है:

CREATE OR REPLACE FUNCTION fn_count_comments ( 
    postId IN NUMBER ) 
    RETURN NUMBER 
IS
    commentCount NUMBER; 
BEGIN
    SELECT COUNT(*) INTO commentCount 
    FROM post_comment 
    WHERE post_id = postId; 
    RETURN( commentCount ); 
END;

आप इसे इस तरह कह सकते हैं:

BigDecimal commentCount = (BigDecimal) entityManager
.createNativeQuery(
    "SELECT fn_count_comments(:postId) FROM DUAL"
)
.setParameter("postId", 1L)
.getSingleResult();

Hibernate 4.x और 5.x का उपयोग करते समय कम से कम क्योंकि JPA StoredProcedureQuerySQL FUNCTIONS के लिए काम नहीं करता है।

जेपीए और हाइबरनेट का उपयोग करते समय संग्रहीत प्रक्रियाओं और कार्यों को कैसे कॉल करें, इसके बारे में अधिक विवरण के लिए, निम्नलिखित लेख देखें

Question 7

मेरे लिए, केवल निम्नलिखित Oracle 11g और ग्लासफिश 2.1 (Toplink) के साथ काम किया है:

Query query = entityManager.createNativeQuery("BEGIN PROCEDURE_NAME(); END;");
query.executeUpdate();

घुंघराले ब्रेसिज़ वाले संस्करण का परिणाम ORA-00900 था।

Question 8

यदि EclipseLink का उपयोग कर रहे हैं, तो आप किसी भी संग्रहीत कार्यविधि को निष्पादित करने के लिए @NamedStoredProcedureQuery या StoreProcedureCall का उपयोग कर सकते हैं, जिनमें आउटपुट पैरामीटर, या शाप देने वाले शामिल हैं। संग्रहीत कार्यों और PLSQL डेटा-प्रकारों के लिए समर्थन भी उपलब्ध है।

देखें, http://en.wikibooks.org/wiki/Java_Persistence/Advanced_Topics#Stored_Procedures

Question 9

निम्नलिखित मेरे लिए काम करता है:

Query query = em.createNativeQuery("BEGIN VALIDACIONES_QPAI.RECALC_COMP_ASSEMBLY('X','X','X',0); END;");
query.executeUpdate();

Question 10

हो सकता है कि यह Sql Srver के लिए समान न हो, लेकिन यह मेरे लिए काम कर रहे लोगों के लिए oracle और eclipslink का उपयोग कर रहा है

पूर्व: एक प्रक्रिया जिसमें एक पैराम (टाइप CHAR) और दो OUT परम (NUMBER और VARCHAR) हैं

दृढ़ता में। xml दृढ़ता-इकाई की घोषणा करें:

<persistence-unit name="presistanceNameOfProc" transaction-type="RESOURCE_LOCAL">
    <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
    <jta-data-source>jdbc/DataSourceName</jta-data-source>
    <mapping-file>META-INF/eclipselink-orm.xml</mapping-file>
    <properties>
        <property name="eclipselink.logging.level" value="FINEST"/>
        <property name="eclipselink.logging.logger" value="DefaultLogger"/>
        <property name="eclipselink.weaving" value="static"/>
        <property name="eclipselink.ddl.table-creation-suffix" value="JPA_STORED_PROC" />
    </properties>
</persistence-unit>

और eclipselink-orm.xml में खरीद की संरचना घोषित करें

<?xml version="1.0" encoding="UTF-8"?><entity-mappings version="2.0"
xmlns="http://java.sun.com/xml/ns/persistence/orm" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm orm_2_0.xsd">
<named-stored-procedure-query name="PERSIST_PROC_NAME" procedure-name="name_of_proc" returns-result-set="false">
    <parameter direction="IN" name="in_param_char" query-parameter="in_param_char" type="Character"/>
    <parameter direction="OUT" name="out_param_int" query-parameter="out_param_int" type="Integer"/>
    <parameter direction="OUT" name="out_param_varchar" query-parameter="out_param_varchar" type="String"/>
</named-stored-procedure-query>

कोड में आपको बस अपनी खरीद को इस तरह से कॉल करना होगा:

try {
        final Query query = this.entityManager
                .createNamedQuery("PERSIST_PROC_NAME");
        query.setParameter("in_param_char", 'V'); 
        resultQuery = (Object[]) query.getSingleResult();

    } catch (final Exception ex) {
        LOGGER.log(ex);
        throw new TechnicalException(ex);
    }

दो आउटपुट पारम पाने के लिए:

Integer myInt = (Integer) resultQuery[0];
String myStr =  (String) resultQuery[1];

Question 11

इसने मेरे लिए काम किया।

@Entity
@Table(name="acct")
@NamedNativeQueries({
 @NamedNativeQuery(callable=true, name="Account.findOne", query="call sp_get_acct(?), resultClass=Account.class)})
public class Account{
 // Code 
}

नोट: भविष्य में यदि आप findOne के डिफ़ॉल्ट संस्करण का उपयोग करने का निर्णय लेते हैं, तो बस NamedNativeQueries एनोटेशन पर टिप्पणी करें और JPA डिफ़ॉल्ट रूप से स्विच हो जाएगा

Question 12

यदि आपके पास इकाई प्रबंधक है तो यह उत्तर मददगार हो सकता है

मेरे पास अगली संख्या बनाने के लिए एक संग्रहीत प्रक्रिया थी और सर्वर साइड पर मेरे पास सीम फ्रेमवर्क है।

ग्राहक की ओर

 Object on = entityManager.createNativeQuery("EXEC getNextNmber").executeUpdate();
        log.info("New order id: " + on.toString());

डेटाबेस साइड (एसक्यूएल सर्वर) मेरे पास नामित प्रक्रिया है getNextNmber

Question 13

आप @Query(value = "{call PROC_TEST()}", nativeQuery = true)अपने भंडार में उपयोग कर सकते हैं । इसने मेरे लिए काम किया।

ध्यान दें: '{' और '}' का उपयोग करें अन्यथा यह काम नहीं करेगा।

Question 14

JPA 2.0 RETURN मानों का समर्थन नहीं करता, केवल कॉल करता है।

मेरा समाधान था प्रक्रिया बुला एक समारोह बनाएँ।

तो, जावा कोड के अंदर आप एक मौलिक प्रश्न को निष्पादित करते हैं, जो ऑरेकल फंक्शन को बुलाता है।

Question 15

संग्रहीत प्रक्रिया को कॉल करने के लिए हम java.sql पैकेज में Callable स्टेटमेंट का उपयोग कर सकते हैं।

Question 16

इस कोड को आज़माएं:

return em.createNativeQuery("{call getEmployeeDetails(?,?)}",
                               EmployeeDetails.class)           
                               .setParameter(1, employeeId)
                               .setParameter(2, companyId).getResultList();

Question 17

persistence.xml

 <persistence-unit name="PU2" transaction-type="RESOURCE_LOCAL">
<non-jta-data-source>jndi_ws2</non-jta-data-source>
<exclude-unlisted-classes>false</exclude-unlisted-classes>
<properties/>

कोडीवा जावा

  String PERSISTENCE_UNIT_NAME = "PU2";
    EntityManagerFactory factory2;
    factory2 = Persistence.createEntityManagerFactory(PERSISTENCE_UNIT_NAME);

    EntityManager em2 = factory2.createEntityManager();
    boolean committed = false;
    try {

        try {
            StoredProcedureQuery storedProcedure = em2.createStoredProcedureQuery("PKCREATURNO.INSERTATURNO");
            // set parameters
            storedProcedure.registerStoredProcedureParameter("inuPKEMPRESA", BigDecimal.class, ParameterMode.IN);
            storedProcedure.registerStoredProcedureParameter("inuPKSERVICIO", BigDecimal.class, ParameterMode.IN);
            storedProcedure.registerStoredProcedureParameter("inuPKAREA", BigDecimal.class, ParameterMode.IN);
            storedProcedure.registerStoredProcedureParameter("isbCHSIGLA", String.class, ParameterMode.IN);
            storedProcedure.registerStoredProcedureParameter("INUSINCALIFICACION", BigInteger.class, ParameterMode.IN);
            storedProcedure.registerStoredProcedureParameter("INUTIMBRAR", BigInteger.class, ParameterMode.IN);
            storedProcedure.registerStoredProcedureParameter("INUTRANSFERIDO", BigInteger.class, ParameterMode.IN);
            storedProcedure.registerStoredProcedureParameter("INTESTADO", BigInteger.class, ParameterMode.IN);
            storedProcedure.registerStoredProcedureParameter("inuContador", BigInteger.class, ParameterMode.OUT);

            BigDecimal inuPKEMPRESA = BigDecimal.valueOf(1);
            BigDecimal inuPKSERVICIO = BigDecimal.valueOf(5);
            BigDecimal inuPKAREA = BigDecimal.valueOf(23);
            String isbCHSIGLA = "";
            BigInteger INUSINCALIFICACION = BigInteger.ZERO;
            BigInteger INUTIMBRAR = BigInteger.ZERO;
            BigInteger INUTRANSFERIDO = BigInteger.ZERO;
            BigInteger INTESTADO = BigInteger.ZERO;
            BigInteger inuContador = BigInteger.ZERO;

            storedProcedure.setParameter("inuPKEMPRESA", inuPKEMPRESA);
            storedProcedure.setParameter("inuPKSERVICIO", inuPKSERVICIO);
            storedProcedure.setParameter("inuPKAREA", inuPKAREA);
            storedProcedure.setParameter("isbCHSIGLA", isbCHSIGLA);
            storedProcedure.setParameter("INUSINCALIFICACION", INUSINCALIFICACION);
            storedProcedure.setParameter("INUTIMBRAR", INUTIMBRAR);
            storedProcedure.setParameter("INUTRANSFERIDO", INUTRANSFERIDO);
            storedProcedure.setParameter("INTESTADO", INTESTADO);
            storedProcedure.setParameter("inuContador", inuContador);

            // execute SP
            storedProcedure.execute();
            // get result

            try {
                long _inuContador = (long) storedProcedure.getOutputParameterValue("inuContador");
                varCon = _inuContador + "";
            } catch (Exception e) {
            } 
        } finally {

        }
    } finally {
        em2.close();
    }

Question 18

JPA 2.1 से, JPA डायनेमिक StoredProcedureQuery और घोषणात्मक @NamedStoredProcedureQuery का उपयोग करके संग्रहीत प्रक्रियाओं को कॉल करने का समर्थन करता है।

Question 19

मेरा समाधान था प्रक्रिया बुला एक समारोह बनाएँ।

तो, जावा कोड के अंदर आप एक मौलिक प्रश्न को निष्पादित करते हैं, जो ऑरेकल फंक्शन को बुलाता है।