फ़िल्टर करें और डेटा सॉर्ट करें

आप डेटा को फ़िल्टर करने के लिए निम्नलिखित तरीकों का उपयोग कर सकते हैं (SQL WHERE clause).

• filter(*args, **kwargs) -> QuerySet

• exclude(*args, **kwargs) -> QuerySet

• प्राप्त करें (*Args, *\ * kwargs) -> नमूना

• get_or_none(*args, **kwargs) -> Optional[Model]

• get_or_create(_defaults: Optional[Dict[str, Any]] = None, *args, **kwargs) -> Tuple[Model, bool]

• all(*args, **kwargs) -> List[Optional[Model]]

• क्वेरी सेट एजेंट

  • QuerysetProxy.filter(*args, **kwargs) विधि
  • QuerysetProxy.exclude(*args, **kwargs) विधि
  • QuerysetProxy.get(*args, **kwargs) विधि
  • QuerysetProxy.get_or_none(*args, **kwargs) विधि
  • QuerysetProxy.get_or_create(_defaults: Optional[Dict[str, Any]] = None, *args, **kwargs) विधि
  • QuerysetProxy.all(*args, **kwargs) विधि

और निम्नलिखित विधि का उपयोग करके डेटा को सॉर्ट करें (SQL क्रमबद्ध करना by close).

• order_by(columns:Union[List, str, OrderAction]) -> QuerySet
• क्वेरी सेट एजेंट
  • QuerysetProxy.order_by(columns:Union[List, str, OrderAction]) विधि

फिल्टर

फिल्टर

filter(*args, **kwargs) -> QuerySet

आपको किसी भी नमूना विशेषता/फ़ील्ड द्वारा फ़िल्टर करने और FK संबंधों में फ़िल्टर का उपयोग करके उदाहरण प्राप्त करने की अनुमति देता है।

कक्षा अल्बूm (ormar. Model):
    ormar _ config = आधार _ ormar _ config कॉपी ()

    आईडी: int = ormar। पूर्णांक (primary_key = True)
    नाम: str = ormar। स्ट्रिंग (max_length = 100)
    is_best_seller: b= ormar। बूलियन (default = False)

क्लास ट्रैक (ormar. Model):
    ormar _ config = आधार _ ormar _ config कॉपी ()

    आईडी: int = ormar। पूर्णांक (primary_key = True)
    एल्बम: वैकल्पिक [एल्बम] = ormar। विदेशी (एल्बम)
    नाम: str = ormar। स्ट्रिंग (max_length = 100)
    स्थिति: int = ormar। पूर्णांक ()
    play_count: int = ormar। पूर्णांक (nullable = True)


ट्रैक = Tr.फ़िल्टर (name = "The Bird").मिल ()
# 'द बर्ड' बराबर नाम के साथ एक ट्रैक लौटाएगा

ट्रैक = Tr.फ़िल्टर (album__name = "Fantasies").all ()
# सभी ट्रैक लौटाएगा जहां कॉलम एल्बम का नाम = 'फंतासी'

Django- शैली फिल्टर

आप फ़िल्टर ऑपरेंड को बदलने के लिए एक विशेष फ़िल्टर प्रत्यय का उपयोग कर सकते हैं:

• सटीक - मूल्य के लिए सटीक मैच, sql कॉलम = \ * एल्बम \ _ \ के रूप में लिखा जा सकता है_नाम _\ _ सटीक = 'मालिबू'
• I- सटीक मैच sql कॉलम = (Not case sensitive)
  • एल्बम \ _ \ के रूप में लिखा जा सकता है_नाम _\ _ i= 'मालिबू'
• शामिल करें-sql कॉलम LIKE '%% '* को एल्बम _\ के रूप में लिखा जा सकता है_नाम _\ _ में = 'माल' है
• I-sql कॉलम LIKE '%% ' (case insensed) \ * को एल्बम \ _ \ के रूप में लिखा जा सकता है_नाम _\ _ आइकन = 'माल'
• -sql में column IN (<VALUE1>, <VALUE2>, ...) \ * के रूप में लिखा जा सकता है album__name__in=['Malibu', 'Barclay']
• null - sql कॉलम Nहै (और sql कॉलम NL नहीं है)
  • एल्बम \ _ \ के रूप में लिखा जा सकता है_नाम __null = सच (isnotnull एल्बम __नाम _\ _ isnull = गलत)
• Gt - sql कॉलम> (Greater than) \ * स्थिति \ _ \ _ gt = 3 के रूप में लिखा जा सकता है
• Gte - sql कॉलम> = (ग्रेटर से या के बराबर से अधिक) \ * स्थिति \ _ \ _ gte = 3 के रूप में लिखा जा सकता है
• लेफ्टिनेंट - sql कॉलम < (नीचे) \ * स्थिति \ _ \ _ lt = 3 के रूप में लिखा जा सकता है
• Lte - sql कॉलम <= (कम या के बराबर में)* स्थिति के रूप में लिखा जा सकता है __lte = 3
• स्टार्टविथ - sql कॉलम LIKE '% ' (exactive start match) \ * को एल्बम \ _ \ के रूप में लिखा जा सकता है_नाम _\ _ शुरुआत = 'माल'
• Itswith - sql कॉलम LIKE '% ' (केस असंवेदनशील) \ * के रूप में लिखा जा सकता है album__name__istartswith='mal'
• Endswith - sql कॉलम LIKE '%' (exact end match) \ * एल्बम \ _ \ के रूप में लिखा जा सकता है_नाम _\ _ endswith = 'ibu'
• Iendswith - sql कॉलम LIKE '%' (case insensed) \ * को एल्बम \ _ \ के रूप में लिखा जा सकता है_नाम _\ _ iendswith = 'IBU'

कुछ नमूने:

#sql: product.name = 'टेस्ट' और product.rating> = 3.0)
t.फिल्टर (नाम = 'टेस्ट', रेटिंग __ gte = 3.0).गेट ()

#sql: product.name = 'टेस्ट' और product.rating> = 3.0)
#OR categories.name ('Toys', 'Books'))
t.फ़िल्टर (
    ओरमार। या _ (
        Ormar.and_ (नाम = 'टेस्ट', रेटिंग __ gte = 3.0),
        श्रेणियां __ नाम __ में = ['खिलौने', 'किताबें'])
    )। प्राप्त करें ()
# नोट: नीचे दिए गए जटिल फ़िल्टर अनुभाग और _ या _ के बारे में अधिक पढ़ने के लिए

पायथन-शैली फिल्टर

• सटीक - मूल्य के लिए सटीक मैच, sql कॉलम =
  • Track.album.name के रूप में लिखा जा सकता है
• I- सटीक मैच sql कॉलम = (Not case sensitive)
  • के रूप में लिखा जा सकता है Track.album.name.iexact('malibu')
• शामिल करें-sql कॉलम LIKE '%% '* Track.album.name के रूप में लिखा जा सकता है) * के रूप में लिखा जा सकता है Track.album.name.contains('Mal')
• I-sql कॉलम LIKE '%% ' (केस असंवेदनशील) \ * के रूप में लिखा जा सकता है Track.album.name.icontains('mal')
• -sql में column IN (<VALUE1>, <VALUE2>, ...) * के रूप में लिखा जा सकता है Track.album.name << ['Malibu', 'Barclay'] * के रूप में लिखा जा सकता है Track.album.name.in_(['Malibu', 'Barclay'])
• null - sql कॉलम IS NL (और sql कॉलम IS T NULL) * के रूप में लिखा जा सकता Track.album.name >> कोई नहीं * के रूप में लिखा जा सकता Track.album.name isnull (True) * के रूप में शून्य नहीं लिखा जा सकता है Track.album.name.isnull(False) * शून्य को ~ के रूप में नहीं लिखा जा सकता Track.album.name (>> Noone) \ * शून्य के रूप में नहीं लिखा जा सकता है ~(Track.album.name.isnull(True))
• Gt - sql कॉलम> (Greater than) \ * को Track.album.name लिखा जा सकता है> 3
• Gte - sql कॉलम> = (ग्रेटर से या के बराबर के रूप में लिखा जा सकता Track.album.name = 3
• लेफ्टिनेंट - sql कॉलम < (नीचे) \ * Track.album.name के रूप में लिखा जा सकता है <3
• Lte - sql कॉलम <= (कम या के बराबर के रूप में लिखा जा सकता Track.album.name <= 3
• स्टार्टविथ - sql कॉलम LIKE '% ' (except start match) \ * के रूप में लिखा जा सकता है Track.album.name.startswith('Mal')
• Itswith - sql कॉलम LIKE '% ' (केस असंवेदनशील) \ * के रूप में लिखा जा सकता है Track.album.name.istartswith('mal')
• Endswith - sql कॉलम LIKE '%' (exact end match) \ * के रूप में लिखा जा सकता है Track.album.name.endswith('ibu')
• Iendswith - sql कॉलम LIKE '%' (केस असंवेदनशील) \ * के रूप में लिखा जा सकता है Track.album.name.iendswith('IBU')

कुछ नमूने:

#sql: product.name = 'टेस्ट' और product.rating> = 3.0)
t.फ़िल्टर (
    Product.name = 'टेस्ट') और (Product.rating> = 3.0)
)। प्राप्त करें ()

#sql: product.name = 'टेस्ट' और product.rating> = 3.0)
#OR categories.name ('Toys', 'Books'))
t.फ़िल्टर (
        ((Product.name = 'टेस्ट') और (Product.rating> = 3.0)) |
        Product.categories.name <<['खिलौने', 'किताबें'])
    )। प्राप्त करें ()

!!!ध्यान दें कि सभी विधियां जो पंक्तियों को वापस नहीं करती हैं, स्पष्ट रूप से एक Queryउदाहरण लौटाती हैं ताकि आप उन्हें एक साथ लिंक कर सकें

तो संचालन पसंद है `filter()`, `select_related()`, `limit()` और `offset()` आदि का पीछा किया जा सकता है।

कुछ ऐसा `Track.object.select_related("album").filter(album__name="Malibu").offset(1).limit(1).all()`

!!!चेतावनी, कृपया ध्यान दें कि आपको इसमें और अन्य फ़िल्टर में % वाइल्ड-कार्ड निर्दिष्ट करने की आवश्यकता नहीं है, यह आपके लिए जोड़ा गया है। यदि आप खोज मान में % शामिल करते हैं, तो यह बच जाएगा और पाठ के भीतर शाब्दिक प्रतिशत संकेत के रूप में माना जाएगा।

बाहर

exclude(*args, **kwargs) -> QuerySet

यह फ़िल्टर के समान ही काम करता है, और सभी संशोधक (प्रत्यय) समान हैं, लेकिन स्थिति वापस नहीं आती है।

इसलिए यदि आप फ़िल्टर का उपयोग करते हैं (name = 'John'), जो के बराबर है जहां नाम = SQL में 'जॉन', फिर सिवाय (name = 'John') के बराबर है जहां नाम <> 'जॉन'।

कृपया ध्यान दें कि सभी शर्तें संक्षिप्त हैं, इसलिए यदि आप कई मूल्यों को पारित करते हैं, तो यह शर्तों का संघ बन जाता है।

बहिष्करण (नाम = 'जॉन', उम्र> = 35) बन जाता है where not (name='John' and age>=35)

कक्षा अल्बूm (ormar. Model):
    ormar _ config = आधार _ ormar _ config कॉपी ()

    आईडी: int = ormar। पूर्णांक (primary_key = True)
    नाम: str = ormar। स्ट्रिंग (max_length = 100)
    is_best_seller: b= ormar। बूलियन (default = False)

क्लास ट्रैक (ormar. Model):
    ormar _ config = आधार _ ormar _ config कॉपी ()

    आईडी: int = ormar। पूर्णांक (primary_key = True)
    एल्बम: वैकल्पिक [एल्बम] = ormar। विदेशी (एल्बम)
    नाम: str = ormar। स्ट्रिंग (max_length = 100)
    स्थिति: int = ormar। पूर्णांक ()
    play_count: int = ormar। पूर्णांक (nullable = True)


नोट्स = Tr.का इंतजार करें (position_gt = 3).सभी ()
# स्थिति <3 के साथ सभी ट्रैक लौटाता है

जटिल फिल्टर (including OR)

डिफ़ॉल्ट रूप से, दोनों फ़िल्टर () and except () mएथोड्स प्रदान किए गए फ़िल्टर विकल्पों को शर्त के साथ जोड़ते हैं ताकि filter(name="John", age__gt=30) में अनुवाद करें WHERE name = 'John' AND age > 30 ...

कभी-कभी उन स्थितियों का उपयोग करके डेटाबेस को क्वेरी करना उपयोगी होता है जिन्हें संयुक्त रूप से लागू नहीं किया जाना चाहिए, जैसे कि WHERE name = 'John' OR age > 30 या एक जटिल जहां क्वेरी का निर्माण करें जिसे आप अधिक नियंत्रण चाहते हैं। आखिरकार WHERE (name = 'John' OR age > 30) and city='New York' से पूरी तरह से अलग है WHERE name = 'John' OR (age > 30 and city='New York') ...

OR और नेस्टेड स्थितियों का निर्माण करने के लिए, mar दो कार्य प्रदान करता है जिनका उपयोग फ़िल्टर में किया जा सकता है () and except () Queryऔर QueryProमें।

!!!ध्यान दें कि आप इन विधियों को किसी अन्य विधि में प्रदान कर सकते हैं जो \ * arको स्वीकार करता है, जैसे कि प्राप्त करें () or all ().

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

इस तरह नमूना एक उदाहरण को देखते हुए:

base_ormar_config = ormar। marConfig (
    डेटाबेस = डेटाबेस। डेटाबेस (DATABASE_URL),
    मेटाडेटा = वर्गधर्मी। मेटाडेटा (),
)


कक्षा लेखक (ormar. Model):
    ormar _ config = आधार _ ormar _ config कॉपी ()

    आईडी: int = ormar। पूर्णांक (primary_key = True)
    नाम: str = ormar। स्ट्रिंग (max_length = 100)


क्लास बुक (ormar. Model):
    ormar _ config = आधार _ ormar _ config कॉपी ()

    आईडी: int = ormar। पूर्णांक (primary_key = True)
    लेखक: वैकल्पिक [लेखक] = ormar। विदेशी (लेखक)
    शीर्षक: str = ormar। स्ट्रिंग (max_length = 100)
    वर्ष: int = ormar। पूर्णांक (nullable = True)

आइए कुछ उदाहरण डेटा बनाएं:

टॉल्किन = लेखक का इंतजार करें (name = "J.R.R. Tolkien").save ()
प्रतीक्षारत पुस्तक (लेखक = tolkien, शीर्षक = "द हॉबिट", वर्ष = 1933)। बचाओ ()
प्रतीक्षारत पुस्तक (लेखक = tolkien, शीर्षक = "द लॉर्ड ऑफ द रिंग्स", वर्ष = 1955)। बचाओ ()
प्रतीक्षारत पुस्तक (लेखक = tolkien, शीर्षक = "द सिल्मारिलियन", वर्ष = 1977)। बचाओ ()
k= लेखक का इंतजार करें (name = "Andrzej Sapkowski").save ()
प्रतीक्षारत पुस्तक (लेखक = सैपकोव्स्की, शीर्षक = "द विचर", वर्ष = 1990)। बचाओ ()
प्रतीक्षारत पुस्तक (लेखक = सैपकोव्स्की, शीर्षक = "द टॉवर ऑफ फूल्स", वर्ष = 2002)। बचाओ ()

हम कुछ उदाहरण जटिल प्रश्नों का निर्माण कर सकते हैं:

आइए 1970 के बाद लिखी गई टॉल्किन की पुस्तकों या पुस्तकों का चयन करें

SQL: WHERE ( authors.name = 'J.R.R. Tolkien' OR books.year > 1970 )

Django शैली

किताबें = (
    प्रतीक्षा करें
    । फ़िल्टर (ormar. or _ (लेखक __ नाम = "J.R.R. टोल्किन", वर्ष __ gt = 1970))
    । सभी ()
)
लेन (पुस्तकें) = = 5

अजगर शैली

किताबें = (
    प्रतीक्षा करें
    । फ़िल्टर Book.author.name = "जे.आर.आर. टोल्किन") | (Book.year > 1970))
    । सभी ()
)
लेन (पुस्तकें) = = 5

अब आइए 1960 के बाद या 1940 से पहले टोल्किन द्वारा लिखी गई पुस्तकों का चयन करें।

SQL: WHERE ( books.year > 1960 OR books.year < 1940 ) AND authors.name = 'J.R.R. Tolkien'

Django शैली

#OPTION 1 - विभाजित और अलग-अलग कॉल में
किताबें = (
    प्रतीक्षा करें
    । फ़िल्टर (ormar. or _ (year__gt = 1960, year__lt = 1940))
    । फ़िल्टर (लेखक __ नाम = "जेआरआर टोल्किन")
    । सभी ()
)
लेन (पुस्तकें) = = 2

# विकल्प 2 - सभी एक में
किताबें = (
    प्रतीक्षा करें
    । फिल्टर (
        ओरमार। और _ (
            ओरमार। या _ (वर्ष __ gt = 1960, वर्ष __ lt = 1940),
            लेखक __ नाम = "जे.आर.आर. टोल्किन",
        )
    )
    । सभी ()
)

लेन (पुस्तकें) = = 2
सम्मिलित पुस्तकें [0]। शीर्षक = = "द हॉबिट"
सम्मिलित पुस्तकें [1] । शीर्षक = = "द सिल्मारिलियन"

अजगर शैली

किताबें = (
    प्रतीक्षा करें
    । फ़िल्टर करें ((Book.year > 1960) | (Book.year < 1940))
    । फ़िल्टर Book.author.name = "जे.आर.आर. टोल्किन")
    । सभी ()
)
लेन (पुस्तकें) = = 2

# विकल्प 2 - सभी एक में
किताबें = (
    प्रतीक्षा करें
    । फिल्टर (
        (
            (Book.year > 1960) | (Book.year < 1940)
        ) और Book.author.name = "जे.आर.आर. टोल्किन")
    )
    । सभी ()
)

लेन (पुस्तकें) = = 2
सम्मिलित पुस्तकें [0]। शीर्षक = = "द हॉबिट"
सम्मिलित पुस्तकें [1] । शीर्षक = = "द सिल्मारिलियन"

2000 से पहले सैपकोव्स्की की किताबें या 1960 के बाद टॉल्किन की किताबें

SQL: WHERE ( ( books.year > 1960 AND authors.name = 'J.R.R. Tolkien' ) OR ( books.year < 2000 AND authors.name = 'Andrzej Sapkowski' ) )

Django शैली

किताबें = (
    प्रतीक्षा करें
    । फिल्टर (
        ओरमार। या _ (
            Ormar। और _ (year__gt = 1960, लेखक __ नाम = "J.R.R. टोल्किन"),
            Ormar। और _ (year__lt = 2000, लेखक __ नाम = "आंद्रेजेज सपकोव्स्की"),
        )
    )
    । सभी ()
)
लेन (पुस्तकें) = = 2

अजगर शैली

किताबें = (
    प्रतीक्षा करें
    । फिल्टर (
        ((Book.year > 1960) और Book.author.name = "जे.आर.आर. टोल्किन")) |
        ((Book.year < 2000) & Book.author.name = "आंद्रेजेज सपकोव्स्की"))
    )
    । सभी ()
)
लेन (पुस्तकें) = = 2

बेशक, इन कार्यों में से अधिक दो शर्तें हो सकती हैं, इसलिए यदि हम ऐसी किताबें चाहते हैं जिनमें "हॉबिट" शामिल हैं:

SQL: WHERE ( ( books.year > 1960 AND authors.name = 'J.R.R. Tolkien' ) OR ( books.year < 2000 AND os0cec_authors.name = 'Andrzej Sapkowski' ) OR books.title LIKE '%hobbit%' )

Django शैली

किताबें = (
    प्रतीक्षा करें
    । फिल्टर (
        ओरमार। या _ (
            Ormar। और _ (year__gt = 1960, लेखक __ नाम = "J.R.R. टोल्किन"),
            Ormar। और _ (year__lt = 2000, लेखक __ नाम = "आंद्रेजेज सपकोव्स्की"),
            शीर्षक __ आइकॉन = "हॉबिट",
        )
    )
    । सभी ()
)

अजगर शैली

किताबें = (
    प्रतीक्षा करें
    । फिल्टर (
        ((Book.year > 1960) और Book.author.name = "जे.आर.आर. टोल्किन")) |
        ((Book.year < 2000) & Book.author.name = "आंद्रेजेज सपकोव्स्की")) |
        (Book.title.icontains ("hobbit"))
    )
    । सभी ()
)

यदि आप चाहते हैं या आवश्यकता है, तो आप आवश्यकतानुसार गहरी परिस्थितियों को घोंसला बना सकते हैं, जैसे कि निम्नलिखित क्वेरी को लागू करना:

SQL:

कहाँ ((books.year> 1960 या books.year <1940)
और authors.name = 'जे.आर.आर. टोल्किन ') या
(Books.year <2000 और authors.name = 'Andrzej Sapkowski'))

आप क्वेरी को निम्नानुसार संरचना कर सकते हैं:

Django शैली

किताबें = (
    प्रतीक्षा करें
    । फिल्टर (
        ओरमार। या _ (
            ओरमार। और _ (
                ओरमार। या _ (वर्ष __ gt = 1960, वर्ष __ lt = 1940),
                लेखक __ नाम = "जे.आर.आर. टोल्किन",
            ),
            Ormar। और _ (year__lt = 2000, लेखक __ नाम = "आंद्रेजेज सपकोव्स्की"),
        )
    )
    । सभी ()
)
लेन (पुस्तकें) = = 3
सम्मिलित पुस्तकें [0]। शीर्षक = = "द हॉबिट"
सम्मिलित पुस्तकें [1] । शीर्षक = = "द सिल्मारिलियन"
सम्मिलित पुस्तकें [2] । शीर्षक = = "द विचर"

अजगर शैली

किताबें = (
    प्रतीक्षा करें
    । फिल्टर (
        (
            (
            (Book.year > 1960) |
            (Book. year < 1940)
            ) &
            Book.author.name = = "जे.आर.आर. टोल्किन")
        ) |
        (
            (Book.year < 2000) और
            Book.author.name = = "आंद्रेज सपकोव्स्की")
        )
    )
    । सभी ()
)
लेन (पुस्तकें) = = 3
सम्मिलित पुस्तकें [0]। शीर्षक = = "द हॉबिट"
सम्मिलित पुस्तकें [1] । शीर्षक = = "द सिल्मारिलियन"
सम्मिलित पुस्तकें [2] । शीर्षक = = "द विचर"

अब आपको समझना चाहिए कि ormar.or _और ormar.and _कैसे काम करते हैं। बेशक, आप उन्हें क्वेरी सेट में किसी भी अन्य तरीके से लिंक कर सकते हैं, इसलिए उदाहरण में, एक पूरी तरह से मान्य क्वेरी इस तरह दिख सकती है:

किताबें = (
    प्रतीक्षा करें
    । फ़िल्टर (ormar. or _ (year__gt = 1980, लेखक __ नाम = "आंद्रेज सपकोव्स्की"))
    । फ़िल्टर (शीर्षक __ startswith = "द")
    । सीमा (1)
    । ऑफसेट (1)
    । आदेश _ द्वारा ("-id")
    । सभी ()
)
लेन (पुस्तकें) = = 1
सम्मिलित पुस्तकें [0]। शीर्षक = = "द विचर"

यह पायथन-शैली लिंकिंग और घोंसले के शिकार पर भी लागू होता है।

Django शैली

कृपया ध्यान दें कि Django शैली के साथ, आप एक ही कीवर्ड तर्क कई बार प्रदान नहीं कर सकते हैं, इसलिए filter(ormar.or_(name='Jack', name='John')) को निम्नानुसार क्वेरी करने की अनुमति नहीं है। यदि आप एक ही कॉलम के लिए कई मानों की जांच करना चाहते हैं, तो बस ऑपरेटर में उपयोग करें:filter(name__in=['Jack','John'])।

यदि केवल या _ या और _ यदि कोई फ़ंक्शन एक पैरामीटर पास करता है, तो यह केवल कोष्ठक में संलग्न है और वास्तविक क्वेरी पर कोई प्रभाव नहीं पड़ता है, इसलिए सभी तीन प्रश्न अंत में समान हैं:

प्रतीक्षारत .फ़िल्टर (शीर्षक = 'द हॉबिट').गेट ()
प्रतीक्षा करें
प्रतीक्षा करें

!!!नोट या _ और _ क्वेरी में ERE होगा (title = 'द हॉबिट'), लेकिन कोष्ठक निरर्थक हैं और इसका कोई व्यावहारिक प्रभाव नहीं है।

यदि आपको वास्तव में दो बार एक ही फ़ील्ड नाम का उपयोग करने की आवश्यकता है, तो आप इस सुविधा का उपयोग कर सकते हैं। याद रखें कि आप एक ही कीवर्ड तर्क को दो बार फ़ंक्शन में पास नहीं कर सकते हैं, इसलिए उदाहरण में क्वेरी कैसे करें WHERE (authors.name LIKE '%tolkien%') OR (authors.name LIKE '%sapkowski%')) ?

आप ऐसा नहीं कर सकते।

किताबें = (
    प्रतीक्षा करें
        । फ़िल्टर (ormar. or _)
        लेखक __ नाम __ आइकन = "टोल्किन",
        लेखक __ नाम __ = "सैपकोव्स्की" # आप एक ही कीवर्ड का उपयोग दो बार या _ में नहीं कर सकते हैं!
    )) # पायथन सिंटैक्स त्रुटि
        । सभी ()
)

लेकिन आप ऐसा कर सकते हैं:

किताबें = (
    प्रतीक्षा करें
        । फ़िल्टर (ormar. or _)
        Ormar.and_ (author__name__icontains = "tolkien"), # एक तर्क = = बस में लिपटे ()
        ओरमार और _ (लेखक __ नाम __ आइकन = "सैपकोव्स्की")
    ))
        । सभी ()
)
लेन (पुस्तकें) = = 5

अजगर शैली

कृपया ध्यान दें कि पायथन शैली के साथ, आप आवश्यक रूप से कई बार एक ही क्षेत्र का उपयोग कर सकते हैं।

किताबें = (
    प्रतीक्षा करें
        । फिल्टर (
        Book.author.name ("tolkien") |
        Book.author.name ("sapkowski")
    ))                                      
        । सभी ()
)

प्राप्त करें

प्राप्त करें (*Args, *\ * kwargs) -> नमूना

डेटाबेस से पहली पंक्ति प्राप्त करता है जो kwarसेट स्थितियों को संतुष्ट करता है।

किसी भी arऔर / या kwarपारित करते समय, यह कॉलिंग फिल्टर के बराबर है (*Args, *\ * kwargs).गेट () शॉर्टकट

!!!टिप फ़िल्टर के बारे में अधिक जानने के लिए, फ़िल्टर पर जाएं।

के बारे में अधिक पढ़ने के लिए `get` पर जाएं [पढ़ें / प्राप्त करें](../read/#get)

जाओ या कुछ नहीं

यह ठीक वैसा ही है जैसा ऊपर वर्णित है, लेकिन यदि मानदंडों से मेल खाने वाला कोई डेटाबेस रिकॉर्ड नहीं पाया जाता है, तो किसी अपवाद को फेंकने के बजाय कोई भी वापस नहीं किया जाता है।

प्राप्त करें या बनाएं

get_or_create(_defaults: Optional[Dict[str, Any]] = None, *args, **kwargs) -> Tuple[Model, bool]

विधियों का एक संयोजन बनाएं और प्राप्त करें।

किसी भी arऔर / या kwarपास करते समय, यह शॉर्टकट को कॉल करने के बराबर है filter(*args, **kwargs).get_or_create()

!!!टिप फ़िल्टर के बारे में अधिक जानने के लिए, फ़िल्टर पर जाएं।

के बारे में अधिक पढ़ने के लिए `get_or_create` पर जाएं [पढ़ें / प्राप्त करें _ या _ बनाएँ](../read/#get_or_create)

!!!चेतावनी जब कोई दिया गया आइटम मौजूद नहीं होता है, तो आपको नमूना के सभी आवश्यक क्षेत्रों के लिए kwarपास करने की आवश्यकता होती है, जिसमें प्राथमिक \ _ कुंजी कॉलम तक सीमित नहीं है (जब तक कि यह ऑटो-इन्क्रीमेंटिंग न हो)।

सभी

all(*args, **kwargs) -> List[Optional["Model"]]

सेट फ़िल्टर विकल्प के लिए, दिए गए नमूना के लिए डेटाबेस में सभी पंक्तियों को लौटाता है।

किसी भी kwarको पास करते समय, यह कॉलिंग फ़िल्टर के बराबर है (*Args, *Kwargs के लिए शॉर्टकट).all ()

!!!टिप फ़िल्टर के बारे में अधिक जानने के लिए, फ़िल्टर पर जाएं।

के बारे में अधिक पढ़ने के लिए `all` पर जाएं [सभी पढ़ें](../read/#all)

QueryProविधि

प्रासंगिक MToफ़ील्ड और seसीधे एक्सेस करते समय, संबंधित मॉडल की एक सूची वापस आ जाती है।

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

फिल्टर

ऊपर के रूप में एक ही फ़िल्टरिंग फ़ंक्शन, लेकिन आपको रिश्ते के दूसरे छोर से संबंधित वस्तुओं को फ़िल्टर करने की अनुमति देता है।

!!!QueryProके बारे में अधिक जानने के लिए, QueryProअनुभाग पर जाएं

बाहर

बहिष्करण फ़ंक्शन बिल्कुल ऊपर के समान है, लेकिन आपको रिश्ते के दूसरी तरफ से संबंधित वस्तुओं को फ़िल्टर करने की अनुमति देता है।

!!!QueryProके बारे में अधिक जानने के लिए, QueryProअनुभाग पर जाएं

प्राप्त करें

ऊपर दिए गए फ़ंक्शन के समान है, लेकिन आपको रिश्ते के दूसरे छोर से संबंधित वस्तुओं को फ़िल्टर करने की अनुमति देता है।

!!!QueryProके बारे में अधिक जानने के लिए, QueryProअनुभाग पर जाएं

जाओ या कुछ नहीं

यह ठीक वैसा ही है जैसा ऊपर वर्णित है, लेकिन यदि मानदंडों से मेल खाने वाला कोई डेटाबेस रिकॉर्ड नहीं पाया जाता है, तो किसी अपवाद को फेंकने के बजाय कोई भी वापस नहीं किया जाता है।

प्राप्त करें या बनाएं

वास्तव में ऊपर दिए गए फ़ंक्शन को प्राप्त करने के समान है, लेकिन आपको संबंध के दूसरे छोर से संबंधित वस्तुओं को फ़िल्टर करने की अनुमति देता है।

!!!QueryProके बारे में अधिक जानने के लिए, QueryProअनुभाग पर जाएं

सभी

उपरोक्त सभी के समान है, लेकिन आपको रिश्ते के दूसरी तरफ से संबंधित वस्तुओं को फ़िल्टर करने की अनुमति देता है।

!!!QueryProके बारे में अधिक जानने के लिए, QueryProअनुभाग पर जाएं

सॉर्ट करें

आदेश आधार

order_by(columns: Union[List, str, OrderAction]) -> QuerySet

क्रमबद्ध करना का उपयोग करके \ _ by (), आप अपने द्वारा चुने गए फ़ील्ड द्वारा डेटाबेस में परिणामों को सॉर्ट कर सकते हैं।

आप फ़ील्ड नामों के साथ एक स्ट्रिंग या विभिन्न फ़ील्ड के साथ स्ट्रिंग्स की सूची प्रदान कर सकते हैं।

SQL में सॉर्ट करना आपके द्वारा _ में प्रदान किए गए नामों के क्रमबद्ध करना क्रमबद्ध करना में लागू किया जाता है।

!!!टिप डिफ़ॉल्ट रूप से, यदि आप सभी प्राथमिक कुंजियों द्वारा छँटाई या स्पष्ट रूप से सॉर्ट प्रदान नहीं करते हैं

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

नमूना कच्चे डेटाबेस पंक्तियों के परिणाम (बच्चे नमूना द्वारा क्रमबद्ध किया गया):
```
MODEL: 1 - Child Model - 3
MODEL: 2 - Child Model - 2
MODEL: 1 - Child Model - 1
```

परिणामों की 2 पंक्तियों में परिणाम होगा:
```
MODEL: 1 - Child Models: [3, 1] # encountered first in result, all children rows combined
MODEL: 2 - Child Models: [2]
```

मुख्य नमूना परिणामों में कभी भी नकल नहीं करेंगे

नमूना दिया गया उदाहरण इस प्रकार है:

import asyncio

import databases
import ormar
import sqlalchemy
from examples import create_drop_database

DATABASE_URL = "sqlite:///test.db"

ormar_base_config = ormar.OrmarConfig(
    database=databases.Database(DATABASE_URL),
    metadata=sqlalchemy.MetaData(),
)


class Owner(ormar.Model):
    ormar_config = ormar_base_config.copy(tablename="owners")

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)


class Toy(ormar.Model):
    ormar_config = ormar_base_config.copy(tablename="toys")

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    owner: Owner = ormar.ForeignKey(Owner)


@create_drop_database(base_config=ormar_base_config)
async def run_query():
    # build some sample data
    aphrodite = await Owner.objects.create(name="Aphrodite")
    hermes = await Owner.objects.create(name="Hermes")
    zeus = await Owner.objects.create(name="Zeus")

    await Toy.objects.create(name="Toy 4", owner=zeus)
    await Toy.objects.create(name="Toy 5", owner=hermes)
    await Toy.objects.create(name="Toy 2", owner=aphrodite)
    await Toy.objects.create(name="Toy 1", owner=zeus)
    await Toy.objects.create(name="Toy 3", owner=aphrodite)
    await Toy.objects.create(name="Toy 6", owner=hermes)


asyncio.run(run_query())

मास्टर नमूना द्वारा सॉर्ट करने के लिए, बस फ़ील्ड नाम प्रदान करें

Django शैली

खिलौने = प्रतीक्षा करें Toy.objects.select_related ("owner") .order_by ("name").all ()
x.name ("Toy ", "") खिलौनों में x के लिए] == [
    एसटीआर (x + 1) रेंज में x के लिए (6)
]
आरोपित खिलौने [0]। मालिक = = ज़ीउस
आरोपित खिलौने [1] । मालिक = = कामोत्तेजक

अजगर शैली

खिलौने = प्रतीक्षा करें Toy.objects.select_related ("owner") order_by (Toy.name ()).सभी ()
x.name ("Toy ", "") खिलौनों में x के लिए] == [
    एसटीआर (x + 1) रेंज में x के लिए (6)
]
आरोपित खिलौने [0]। मालिक = = ज़ीउस
आरोपित खिलौने [1] । मालिक = = कामोत्तेजक

नेस्टेड मॉडल को सॉर्ट करने के लिए, डंडर का उपयोग करें '__'अलग क्षेत्र के नाम।

आप सभी संबंध प्रकारों को सॉर्ट कर सकते हैं -> ForeignKey, रिवर्स वर्चुअल FK, और MToफ़ील्ड इस तरह से।

Django शैली

खिलौने = प्रतीक्षा करें Toy.objects.select_related ("owner") .order_by ("owner__name").सभी ()
खिलौने डालें [0]। owner.name खिलौने [1] । owner.name
खिलौने डालें [2] । owner.name खिलौने [3] । owner.name
खिलौने डालें [4]। owner.name खिलौने [5]। owner.name = "ज़ीउस"

अजगर शैली

खिलौने = प्रतीक्षा करें Toy.objects.select_related ("owner") order_by (Toy.owner.name ()).सभी ()
खिलौने डालें [0]। owner.name खिलौने [1] । owner.name
खिलौने डालें [2] । owner.name खिलौने [3] । owner.name
खिलौने डालें [4]। owner.name खिलौने [5]। owner.name "ज़ीउस"

अवरोही क्रमबद्ध करना में सॉर्ट करने के लिए, फ़ील्ड नाम से पहले एक हाइफ़न प्रदान करें

Django शैली

मालिक = (
    AOwner.objects.select_related ("toys")
        । आदेश _ द्वारा ("- toys__name")
        । फिल्टर (name = "Zeus")
        । प्राप्त करें ()
)
owner.toys करें [0]। नाम = = "खिलौना 4"
owner.toys नाम = = "खिलौना 1"

अजगर शैली

मालिक = (
    AOwner.objects.select_related ("toys")
        । आदेश _ द्वारा (Owner.toys.name ())
        । फ़िल्टर Owner.name = "ज़ीउस")
        । प्राप्त करें ()
)
owner.toys करें [0]। नाम = = "खिलौना 4"
owner.toys नाम = = "खिलौना 1"

!!!ध्यान दें कि सभी विधियां जो पंक्तियों को वापस नहीं करती हैं, स्पष्ट रूप से एक Queryउदाहरण लौटाती हैं ताकि आप उन्हें एक साथ लिंक कर सकें

तो संचालन पसंद है `filter()`, `select_related()`, `limit()` और `offset()` आदि का पीछा किया जा सकता है।

कुछ ऐसा `Track.object.select_related("album").filter(album__name="Malibu").offset(1).limit(1).all()`

ओमार में डिफ़ॉल्ट छँटाई

चूंकि डेटाबेस में पंक्तियों की क्रमबद्ध करना की गारंटी नहीं दी जा सकती है, ऑर्मर हमेशा प्रत्येक (आंशिक) क्वेरी के लिए sql क्लॉज द्वारा एक क्रमबद्ध करना जारी करता है, भले ही आप स्वयं क्रमबद्ध करना प्रदान न करें।

डिफ़ॉल्ट रूप से, किसी दिए गए नमूना के साथ डेटाबेस को क्वेरी करते समय, मॉडल प्राथमिक \ _ कुंजी स्तंभों द्वारा आरोही क्रमबद्ध करना में सॉर्ट किए जाते हैं। यदि आप डिफ़ॉल्ट व्यवहार को बदलना चाहते हैं, तो आप आदेश \ _ पैरामीटर द्वारा ormar \ _ config की आपूर्ति करके ऐसा कर सकते हैं।

!!! टिप नमूना सॉर्टिंग क्रमबद्ध करना के बारे में अधिक जानने के लिए, प्रलेखन के मॉडल अनुभाग पर जाएं

डिफ़ॉल्ट रूप से, रिश्ते समान क्रमबद्ध करना का पालन करते हैं, लेकिन आप उस क्रमबद्ध करना को संशोधित कर सकते हैं जिसमें संबंधित मॉडल किसी क्वेरी के दौरान ऑर्डर \ _ बाय और संबंधित \ _ ऑर्डर \ _ मापदंडों के साथ संबंध की आपूर्ति करके लोड किए जाते हैं।

!!! टिप नमूना छँटाई क्रमबद्ध करना के बारे में अधिक पढ़ने के लिए, दस्तावेज़ के संबंध अनुभाग पर जाएँ

आदेश \ _ द्वारा खंड निम्नलिखित क्रमबद्ध करना में लागू किए जाते हैं:

• क्वेरी में क्रमबद्ध करना \ _ by () कॉल को स्पष्ट रूप से पास करें
• आदेशों द्वारा संबंध \ _ by और संबंधित \ _ आदेश \ _ by (if present)
• मॉडल ormar \ _ कॉन्फिग ऑब्जेक्ट ऑर्डर \ _ by
• आरोही क्रमबद्ध करना में मॉडल का प्राथमिक \ _ कुंजी कॉलम (फॉलबैक, यदि उपरोक्त में से कोई भी प्रदान नहीं किया गया है तो उपयोग किया जाता है)

प्रत्येक नमूना में केवल एक स्रोत से ऑर्डर लागू करें (ताकि आप इसे हमेशा एक ही क्वेरी में ओवरराइड कर सकें)।

यह माध्य है कि यदि आप क्वेरी में दिए गए लिंक के लिए एक स्पष्ट क्रमबद्ध करना नमूना के लिए एक स्पष्ट विवरण प्रदान करते हैं, तो संबंध और नमूना क्रमबद्ध करना छोड़ दिया जाएगा।

यदि आप संबंध एक प्रदान करते हैं, तो नमूना आदेश देना छोड़ दिया जाता है।

अंत में, यदि आप एक मॉडल प्रदान करते हैं, तो प्राथमिक \ _ कुंजी के लिए डिफ़ॉल्ट मान छोड़ दिया जाता है।

QueryProविधि

प्रासंगिक MToफ़ील्ड और seसीधे एक्सेस करते समय, संबंधित मॉडल की एक सूची वापस आ जाती है।

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

आदेश आधार

वास्तव में ऊपर दिए गए फ़ंक्शन द्वारा क्रमबद्ध करना \ _ के समान है, लेकिन आपको संबंध के दूसरी तरफ से संबंधित वस्तुओं को सॉर्ट करने की अनुमति देता है।

!!!QueryProके बारे में अधिक जानने के लिए, QueryProअनुभाग पर जाएं