वसंत JPA @Query पसंद के साथ

Question

मैं CrudRepository में एक विधि बनाने की कोशिश कर रहा हूं जो मुझे उन उपयोगकर्ताओं की सूची देने में सक्षम होगी, जिनके उपयोगकर्ता नाम LIKE हैं इनपुट पैरामीटर (न केवल इसके साथ शुरू होता है, बल्कि इसमें शामिल है)। मैंने विधि का उपयोग करने की कोशिश की "findUserByUsernameLike(@Param("username") String username)"लेकिन जैसा कि स्प्रिंग प्रलेखन में बताया गया है, यह विधि " where user.username like ?1" के बराबर है । यह मेरे लिए अच्छा नहीं है, जैसा कि मैंने पहले ही बताया था कि मैं उन सभी उपयोगकर्ताओं को प्राप्त करने की कोशिश कर रहा हूं जिनके उपयोगकर्ता नाम हैं ...

मैंने विधि के बारे में एक प्रश्न लिखा था, लेकिन यह भी तैनात नहीं है।

@Repository
public interface UserRepository extends CrudRepository<User, Long> {

@Query("select u from user u where u.username like '%username%'")
List<User> findUserByUsernameLike(@Param("username") String username);
}

क्या कोई मेरी इसके साथ मदद कर सकता है?

Comments

आप containingअनुक्रमित से लाभ के लिए उपयोग करना चाहते हैं, देख सकते

Answer 1

निम्नलिखित दृष्टिकोण का उपयोग करने का प्रयास करें (यह मेरे लिए काम करता है):

@Query("SELECT u.username FROM User u WHERE u.username LIKE CONCAT('%',:username,'%')")
List<String> findUsersWithPartOfName(@Param("username") String username);

सूचना: JPQL में तालिका का नाम एक बड़े अक्षर से शुरू होना चाहिए।

Comments

या WHERE UPPER(u.username) LIKE CONCAT('%',UPPER(:username),'%')केस-असंवेदनशील खोज करने के लिए

— ब्रैड मेस

एसक्यूएल-इंजेक्शन आपके समाधान का उपयोग करना संभव है? (concat की वजह से पूछ)

— ramden

@ श्रमण सभी पवित्र @Paramहैं, इसलिए नहीं।

— nurettin

आप बस ऐसा कर सकते हैं: उपयोगकर्ता नाम और फिर .setParameter ("उपयोगकर्ता नाम", "% फू%");

— मैथ्यू Daumen

कैसे सेट करें .setParameter ("उपयोगकर्ता नाम", "% फू%"); @ मैथ्यू

— डाउमेन

Answer 2

विधि नामों से क्वेरी निर्माण का उपयोग करते हुए , तालिका 4 देखें जहां वे कुछ कीवर्ड की व्याख्या करते हैं।

1. यूज़िंग लाइक: सेलेक्ट ... लाइक: यूज़रनेम

   List<User> findByUsernameLike(String username);

2. शुरुआत: चयन करें ... जैसे: उपयोगकर्ता नाम%

   List<User> findByUsernameStartingWith(String username);

3. EndingWith: चुनें ...% की तरह: उपयोगकर्ता नाम

   List<User> findByUsernameEndingWith(String username);

4. युक्त: चुनें ...% की तरह: उपयोगकर्ता नाम%

   List<User> findByUsernameContaining(String username);

ध्यान दें कि आप जिस उत्तर की तलाश कर रहे हैं वह नंबर 4 है । आपको @Query का उपयोग करने की आवश्यकता नहीं है

Comments

यह वास्तव में मददगार है, लेकिन अगर मैं युक्त खोजशब्द का उपयोग करना चाहता हूं, तो क्या मैं इसे असंवेदनशील बना सकता हूं? प्रलेखन में StringMatcher के बारे में कुछ कहा गया है। ऐसा लगता है कि अगर मैंने ExampleMatcher के साथ एक अलग फ़ंक्शन बनाया, तो यह काम करेगा, लेकिन क्या मैं किसी भी तरह से इस मामले में असंवेदनशीलता को जोड़ने के लिए अपने स्वयं के फ़ंक्शन को लिखने के लिए विधि नाम में घोषित कर सकता हूं?

— वी। संमा

बस यह जोड़ना चाहता था कि यदि आवश्यक हो, तो आप मामले को भी अनदेखा कर सकते हैं: List<User> findByUsernameContainingIgnoreCase(String username);

— रॉबर्ट

प्रतिशत का प्रतीक उल्टा होना चाहिए StartingWith: select ... like :username%और EndingWith: select ... like %:username... वैसे भी महान जवाब ... को स्वीकार किया जाना चाहिए। धन्यवाद।

— एलेसेंड्रो

@ रॉबर्ट के पास अपरकेस के साथ एक कॉलम डेटा है और मैंने जेपीक्यूएल को विधि की तरह इस्तेमाल किया और कम केस वैल्यू और वैल्यू पाने में सक्षम है। IgnoreCase के बिना भी यह अनुचित मामलों के आंकड़े ला रहा है। यह अजीब व्यवहार क्यों हुआ?

— ग्रीनहॉर्न

@greenhorn कृपया एक अलग StackOverflow प्रश्न खोलें और तालिका में अपने डेटा का कुछ उदाहरण जोड़ें और जो आप क्वेरी कर रहे हैं।

— रॉबर्ट

Answer 3

दूसरा तरीका: CONCATफ़ंक्शन के बजाय हम डबल पाइप का उपयोग कर सकते हैं :: lastname || '%'

@Query("select c from Customer c where c.lastName LIKE :lastname||'%'")
List<Customer> findCustomByLastName( @Param("lastname") String lastName);

आप कहीं भी रख सकते हैं, उपसर्ग, प्रत्यय या दोनों

:lastname ||'%'  
'%' || :lastname  
'%' || :lastname || '%'  

Answer 4

List<User> findByUsernameContainingIgnoreCase(String username);

मामले के मुद्दों की अनदेखी करने के लिए

Comments

एसक्यूएल-इंजेक्शन आपके समाधान का उपयोग करना संभव है?

— xuezhongyu01

Answer 5

निम्नलिखित का उपयोग करना आसान है (कोई ज़रूरत नहीं CONCAT या ||) का उपयोग करें। "

@Query("from Service s where s.category.typeAsString like :parent%")
List<Service> findAll(@Param("parent") String parent);

इसमें प्रलेखित: http://docs.spring.io/spring-data/jpa/docs/current/reference/html ।

Answer 6

आपके मामले के लिए, आप सीधे जेपीए विधियों का उपयोग कर सकते हैं। यह बलो की तरह है:

युक्त: चुनें ...% की तरह: उपयोगकर्ता नाम%

List<User> findByUsernameContainingIgnoreCase(String username);

यहाँ, IgnoreCase आपको मामले की अनदेखी करने के साथ आइटम खोजने में मदद करेगा।

यहाँ कुछ संबंधित तरीके दिए गए हैं:

1. पसंद findByFirstnameLike

   ... जहां x.firstname पसंद है? 1

2. के साथ शुरू findByFirstnameStartingWith

   ... जहाँ x.firstname पसंद है? 1 (पैरामीटर संलग्न% के साथ)

3. EndingWith findByFirstnameEndingWith

   ... जहाँ x.firstname पसंद है? 1 (पूर्वनिर्मित% के साथ बाध्य पैरामीटर)

4. युक्त findByFirstnameContaining

   ... जहां x.firstname पसंद है? 1 (पैरामीटर बाउंड लिपटे%)

अधिक जानकारी, इस लिंक और इस लिंक को देखें

आशा है कि यह आपकी मदद करेगा :)

Comments

धन्यवाद! जेपीए सम्मेलनों का उपयोग करना सही तरीका लगता है।

— फिगेटन्यूटन

Answer 7

यह तरीका मेरे लिए काम करता है, (स्प्रिंग बूट संस्करण 2.0.1 का उपयोग करके। RELEASE):

@Query("SELECT u.username FROM User u WHERE u.username LIKE %?1%")
List<String> findUsersWithPartOfName(@Param("username") String username);

समझाते हुए: The? 1; 2; 3; आदि जगह धारक पहले, दूसरे, तीसरे पैरामीटर आदि हैं। इस मामले में पैरामीटर को% द्वारा घेरने के लिए पर्याप्त है जैसे कि यह एक मानक SQL क्वेरी थी लेकिन बिना एकल कोट।

Comments

आपको संख्याओं के बजाय नामित मापदंडों को पूर्व निर्धारित करना चाहिए:@Query("SELECT u.username FROM User u WHERE u.username LIKE %:username%")

— राल्फ

Answer 8

@Query("select u from user u where u.username LIKE :username")
List<User> findUserByUsernameLike(@Param("username") String username);

Comments

धन्यवाद, deplouing की समस्या यह थी कि jpql केस संवेदी है, अब यह तैनात है, लेकिन 'LIKE' वैसा काम नहीं करता जैसा मैं चाहता हूं। यह सिर्फ ऐसे रिकॉर्ड्स को खोजता है जो पूरी तरह से इनपुट पैरामीटर के बराबर हैं (इसे युक्त नहीं)।

— विक्टोरिया

Answer 9

@Query("select b.equipSealRegisterId from EquipSealRegister b where b.sealName like %?1% and b.deleteFlag = '0'" )
    List<String>findBySeal(String sealname);

मैंने इस कोड की कोशिश की है और यह काम करता है।