sqlalchemy कई कॉलम फ़िल्टर करता है


82

मैं दो कॉलम कैसे जोड़ूं और फ़िल्टर कैसे लागू करूं? उदाहरण के लिए, मैं एक ही समय में "Firstname" और "lastname" कॉलम दोनों में खोजना चाहता हूं। यहाँ है कि मैं यह कैसे कर रहा हूँ अगर केवल एक कॉलम खोज रहा है:

query = meta.Session.query(User).filter(User.firstname.like(searchVar))

4
मुझे लगा कि यह प्रश्न उस मुद्दे से मेल खाता है जो मेरे पास है, लेकिन उत्तर मेरे विशेष परिदृश्य पर लागू नहीं होते हैं। यदि Firstname "joe" है और lastname "smith" है, तो मैं एक फ़िल्टर स्टेटमेंट की तलाश कर रहा हूं जो कि आपूर्ति की गई खोज से मेल खाता हो जब "joe smith" हो। यानी, परीक्षण किए जाने से पहले खेतों को समतल किया जाना चाहिए। एक बहुत ही वास्तविक दुनिया परिदृश्य की तरह लगता है।
Groovee60

1
@ Groovee60 यह वही है जिसकी मुझे तलाश है। अगर आप एक मिल जाए तो मैं आपकी सराहना करूंगा।
लिलीलक्षी

जवाबों:


84

इसे करने के कई तरीके हैं:

filter()( और ऑपरेटर) का उपयोग करना

query = meta.Session.query(User).filter(
    User.firstname.like(search_var1),
    User.lastname.like(search_var2)
    )

filter_by()( और ऑपरेटर) का उपयोग करना

query = meta.Session.query(User).filter_by(
    firstname.like(search_var1),
    lastname.like(search_var2)
    )

जंजीर filter()या filter_by()( और ऑपरेटर)

query = meta.Session.query(User).\
    filter_by(firstname.like(search_var1)).\
    filter_by(lastname.like(search_var2))

का उपयोग कर or_(), and_()औरnot()

from sqlalchemy import and_, or_, not_

query = meta.Session.query(User).filter(
    and_(
        User.firstname.like(search_var1),
        User.lastname.like(search_var2)
    )
)

2
क्या इन विभिन्न तरीकों के लिए कोई उल्लेखनीय प्रदर्शन अंतर हैं?
मीक

2
अधिकांश अलग-अलग दृष्टिकोण एक ही क्वेरी को उत्पन्न करेंगे, इसलिए अधिकांश मामलों में आपको प्रदर्शन अंतर दिखाई नहीं देगा।
आसा स्टेलार्ड

मैं थोड़ा उलझन में हूँ। filter_byडॉक्स का कहना है कि यह कीवर्ड तर्क से छानने के लिए है: query(Foo).filter_by(bar='baz')। उपरोक्त वाक्य में आपके द्वारा उपयोग किए गए वाक्यविन्यास से कैसे संबंधित है?
टेल

76

आप बस filterकई बार कॉल कर सकते हैं :

query = meta.Session.query(User).filter(User.firstname.like(searchVar1)). \
                                 filter(User.lastname.like(searchVar2))

36
क्या कई filter()तरीकों का उपयोग करने और एक ही ( mysql) टेबल पर एक एकल में ( or_या and_) कई स्थितियों के संयोजन का उपयोग करने के बीच कोई अंतर-अंतर है filter?
एक्सएरेस

6
क्या मल्टीपल filterकॉल ए की ANDबजाय तार्किक की तरह काम करेगा OR?
दिनोदोनोव

6
मैं ऐसा नहीं सोचूंगा - जब आप str (User.filter (cond1) .filter (cond2)) को देखते हैं, तो केवल स्थितियों "" और "ed" के साथ अंतिम sql उत्पन्न करता है।
शंकर ARUL 10

60

आप एक से अधिक कॉलम में खोजने के लिए SQLAlchemy के or_फ़ंक्शन का उपयोग कर सकते हैं (पायथन के अपने से अलग करने के लिए अंडरस्कोर आवश्यक है or)।

यहाँ एक उदाहरण है:

from sqlalchemy import or_
query = meta.Session.query(User).filter(or_(User.firstname.like(searchVar),
                                            User.lastname.like(searchVar)))

7
आप |इसके बजाय ऑपरेटर का उपयोग कर सकते हैं or_, जैसे - (User.firstname.like(searchVar)) | (User.lastname.like(searchVar))हालांकि, आपको |पूर्ववर्तीता के साथ सावधान रहना चाहिए , बिना कोष्ठक के बिना यह बहुत ही अप्रत्याशित परिणाम पैदा कर सकता है जब मजबूरी ऑपरेटरों के साथ मिलाया जाता है।
डैनियल क्लेव 17

1
यह नहीं होना चाहिए filter.or_( case1, case 2)?
फेडोरक्वी 'एसओ ने

2
यह गलत है, क्योंकि सवाल ORM के बारे में है, लेकिन लिंक अभिव्यक्ति की ओर जाता है।
user2846569

1
मैं पहले कई फिल्टर स्टेटमेंट्स का उपयोग कर रहा था जिससे नाटकीय रूप से विलंबता बढ़ गई। मैंने इसे or_ में बदल दिया और यह MUCH को तेज़ी से लौटा रहा है। धन्यवाद @ gclj5
जिमी

2

एक सामान्य टुकड़ा कोड जो कई कॉलमों के लिए काम करेगा। यह भी इस्तेमाल किया जा सकता है अगर आवेदन में सशर्त रूप से खोज कार्यक्षमता को लागू करने की आवश्यकता है।

search_key = "abc"
search_args = [col.ilike('%%%s%%' % search_key) for col in ['col1', 'col2', 'col3']]
query = Query(table).filter(or_(*search_args))
session.execute(query).fetchall()

नोट: %%क्वेरी को प्रारूपित करने के लिए% छोड़ना महत्वपूर्ण है।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.