विषय पर बढ़ें

जॉइन और सबक्वेरी

संबंधित मॉडल भी लोड करने के लिए क्रमबद्ध करना में एक तालिका से दूसरी तालिका में शामिल होने के लिए, आप निम्नलिखित विधि का उपयोग कर सकते हैं।

  • select_related(related: Union[List, str]) -> QuerySet

  • select_all(follow: bool = True) -> QuerySet

  • prefetch_related(related: Union[List, str]) -> QuerySet

  • नमूना

    • मॉडल.लोड () विधि

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

    • QuerysetProxy.select_related(related: Union[List, str]) विधि

    • QuerysetProxy.select_all(follow: bool=True) विधि
    • QuerysetProxy.prefetch_related(related: Union[List, str]) विधि

प्रासंगिक का चयन करें

select_related(related: Union[List, str]) -> QuerySet

संबंधित मॉडल को एक ही क्वेरी के दौरान प्रीफ़ेयर करने की अनुमति देता है।

चयन \ _ lated का उपयोग करते समय, डेटाबेस के खिलाफ हमेशा केवल एक क्वेरी चलती है, जो माध्य (sometimes complex) शामिल होने से उत्पन्न होता है और बाद में नेस्टेड मॉडल पायथन में संसाधित होते हैं।

संबंधित नमूना प्राप्त करने के लिए, विदेशी कुंजी नाम का उपयोग करें।

संबंधित नमूना संबंधों को जोड़ने के लिए, नामों के बीच दोहरे अंडरस्कोर का उपयोग करें।

!!!नोट यदि आप django से हैं, तो कृपया ध्यान दें कि django में ormar\ _ lated -> से अलग है जिसमें आप केवल एक ही संबंध प्रकार का चयन कर सकते हैं, जबकि ormar में आप एक विदेशी कुंजी संबंध में सहसंबंध का चयन कर सकते हैं, रिवर्स साइड एक विदेशी कुंजी (so वर्चुअल ऑटो-जनरेटेड कुंजी) और MTo क्षेत्र (और इसलिए वर्तमान संस्करण के सभी संबंध)।

!!!टिप यह नियंत्रित करने के लिए कि कौन नमूना फ़ील्ड चयनित हैं, फ़ील्ड () का उपयोग करें और \ _ फ़ील्ड () Queryविधियों को छोड़कर।

!!!टिप मॉडल के क्रमबद्ध करना को नियंत्रित करने के लिए (master or nested), क्रमबद्ध करना का उपयोग करें \ _ by () विधि।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
कक्षा अल्बू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)


# जांगो शैली
एल्बम = Album.objects.select_related का इंतजार करें ("tracks").all ()

# पायथन शैली
एल्बम = Album.objects.select_related का इंतजार करें (Album.tracks).सभी ()

# सभी कॉलम ट्रैक के साथ एल्बम लौटाएगा

आप एक स्ट्रिंग या स्ट्रिंग्स की सूची (या फ़ील्ड / फ़ील्ड की सूची) प्रदान कर सकते हैं।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
क्लास स्कूलक्लास (ormar. Model):
    ormar_config = base_ormar_config (टेबलनाम = "स्कूलक्लास")

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


कक्षा श्रेणी (ormar. Model):
    ormar_config = base_ormar_config (टेबलनाम = "श्रेणियाँ")

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


कक्षा का छात्र (ormar. Model):
    ormar _ config = आधार _ ormar _ config कॉपी ()

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


कक्षा शिक्षक (ormar. Model):
    ormar _ config = आधार _ ormar _ config कॉपी ()

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


# जांगो शैली
कक्षाएं = ol.select_related का इंतजार करें (
    ["शिक्षक __ श्रेणी", "छात्र"]).all ()

# पायथन शैली
कक्षाएं = ol.select_related का इंतजार करें (
    [SchoolClass.teachers.category, olClass.students]).all ()

# शिक्षकों और शिक्षकों की श्रेणियों के साथ कक्षाएं लौटाएंगे
# साथ ही कक्षा के छात्र

M2फ़ील्ड बिल्कुल वैसा ही व्यवहार करता है, जहाँ आप M2फ़ील्ड का नाम दर्ज कर सकते हैं और आपके लिए अंतिम नमूना प्राप्त कर सकते हैं।

!!!चेतावनी: यदि आप सभी प्रश्नों के दौरान फ़ील्ड को गैर-अशक्त (और इसलिए आवश्यक) पर सेट करते हैं, तो गैर-अशक्त मॉडल स्वचालित रूप से पूर्वनिर्मित होते हैं, भले ही आप उन्हें चयन \ _ lated में शामिल न करें।

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

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

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

सभी का चयन करें

select_all(follow: bool = False) -> QuerySet

डिफ़ॉल्ट रूप से, जब आप सभी का चयन करते हैं तो कोई भी संबंध लोड नहीं होता है (), और फिर से, चयन \ _ lated () का उपयोग करते समय, आपको उन सभी संबंधों को स्पष्ट रूप से निर्दिष्ट करने की आवश्यकता होती है जिन्हें लोड किया जाना चाहिए। यदि आप नेस्टेड संबंधों को भी शामिल करना चाहते हैं तो यह बोझिल हो सकता है।

यही कारण है कि चयन \ _ all () पेश किया गया था, इसलिए नमूना के सभी रिश्ते डिफ़ॉल्ट रूप से लोड किए जाते हैं (जैसा कि सभी के विपरीत है) () method).

डिफ़ॉल्ट रूप से, केवल मूल नमूना से संबंधित मॉडल (जिससे क्वेरी चलती है) जोड़े जाते हैं।

यदि आप अनुसरण = सत्य सेट करते हैं, तो यह संबंधित मॉडल के संबंधित मॉडल भी जोड़ता है।

!!!क्रमबद्ध करना में जानकारी एक अनंत लूप में फंसने के लिए नहीं, क्योंकि संबंधित नमूना सेट तक पहुंचने नमूना नमूना सेट तक पहुंचने के लिए माता-पिता के साथ एक संबंध भी बनाए रखता है।

1
2
3
4
इस तरह पहले से ही देखे गए मॉडल जो नेस्टेड हैं, लोड किए जाते हैं, लेकिन लोड नहीं होते हैं
मॉडल ए inside.So उनका अनुसरण करें -> मॉडल बी -> मॉडल सी -> मॉडल ए -> मॉडल एक्स
दूसरा मॉडल A लोड करेगा लेकिन मॉडल X में कभी भी अनुसरण नहीं करेगा।
उन प्रकार के नेस्टेड संबंधों को मैन्युअल रूप से लोड करने की आवश्यकता है।

नमूना तिथियां इस प्रकार हैं:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
आधार _ ormar _ config = marConfig (
    डेटाबेस = डेटाबेस। डेटाबेस (DATABASE _ URL, बल _ रोलबैक = True),
    मेटाडेटा = वर्गधर्मी। मेटाडेटा (),
)


कक्षा का पता (ormar. Model):
    ormar_config = base_ormar_config (टेबलनाम = "पते")

    आईडी: int = ormar। पूर्णांक (primary_key = True)
    स्ट्रीट: str = ormar। स्ट्रिंग (max_length = 100, null= गलत)
    संख्या: int = ormar। पूर्णांक (nullable = False)
    post_code: str = ormar। स्ट्रिंग (max_length = 20, null= गलत)



कक्षा शाखा (ormar. Model):
    ormar_config = base_ormar_config (टेबलनाम = "शाखाएं")

    आईडी: int = ormar। पूर्णांक (primary_key = True)
    नाम: str = ormar। स्ट्रिंग (max_length = 100, null= गलत)
    पता = ormar। विदेशी (पता)


क्लास कंपनी (ormar. Model):
    ormar_config = base_ormar_config (टेबलनाम = "कंपनियां")

    आईडी: int = ormar। पूर्णांक (primary_key = True)
    नाम: str = ormar। स्ट्रिंग (max_length = 100, null= गलत, नाम = "company_name")
    स्थापित: int = ormar। पूर्णांक (nullable = True)
    शाखाएं = ormar। MTo(Branch)

सभी शाखाओं और पतों वाली सभी कंपनियों को चुनने के लिए, आपको बस पूछताछ करने की आवश्यकता है:

1
2
3
4
कंपनियां = Comp.select_all का इंतजार करें (follow = True).सभी ()

# जो इसके बराबर है:
कंपनियां = Comp.select_related का इंतजार करें ('branches__address').सभी ()

बेशक, इस मामले में, चुनिंदा \ _ lated में स्पष्ट संबंध नाम जारी करना बहुत आसान है, लेकिन जब आपके कई रिश्ते होते हैं तो चुनिंदा \ _ all () के लाभ स्पष्ट हो जाते हैं।

उदाहरण के लिए, यदि कंपनी के 3 संबंध हैं, और सभी 3 संबंधों के अपने 3 संबंध हैं, तो आपको \ _ lated का चयन करने के लिए 9 संबंध स्ट्रिंग्स जारी करने होंगे, और \ _ all () का चयन करें जो संबंध नाम नहीं बदल सकता है।

!!!ध्यान दें कि आप अन्य Queryविधियों जैसे फ़िल्टर, बहिष्करण \ _ फ़ील्ड्स आदि के साथ \ _ all () का चयन कर सकते हैं। किसी संबंध को बाहर करने के लिए, सिवाय \ _ फ़ील्ड () के साथ कॉल का उपयोग करें (also nested) बाहर करने के लिए रिश्ते का नाम।

प्रीफेच सहसंबंध

prefetch_related(related: Union[List, str]) -> QuerySet

इसे प्रश्नों के दौरान संबंधित मॉडल को प्रीफ़ेच करने की अनुमति है - लेकिन जैसा कि \ _ lated का चयन करने के लिए विरोध किया गया है, प्रत्येक बाद के नमूना को एक अलग डेटाबेस क्वेरी में प्राप्त किया जाता है।

pre\ _ lated के साथ, प्रत्येक नमूना डेटाबेस के खिलाफ एक क्वेरी चलाता है, जो माध्य आप एक के बाद एक कई प्रश्नों को निष्पादित करेंगे।

संबंधित नमूना प्राप्त करने के लिए, विदेशी कुंजी नाम का उपयोग करें।

संबंधित नमूना संबंधों को जोड़ने के लिए, नामों के बीच दोहरे अंडरस्कोर का उपयोग करें।

!!!टिप यह नियंत्रित करने के लिए कि कौन नमूना फ़ील्ड चयनित हैं, फ़ील्ड () का उपयोग करें और \ _ फ़ील्ड () Queryविधियों को छोड़कर।

!!!टिप मॉडल के क्रमबद्ध करना को नियंत्रित करने के लिए (master or nested), क्रमबद्ध करना का उपयोग करें \ _ by () विधि।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
कक्षा अल्बू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)


# जांगो शैली
एल्बम = एल्बम का इंतजार करें। prefet_related ("tracks").all ()

# पायथन शैली
एल्बम = एल्बम का इंतजार करें। prefet_related (Album.tracks).सभी ()


# वापसी एल्बम सभी कॉलम ट्रैक करेगा

आप एक स्ट्रिंग या स्ट्रिंग्स की सूची प्रदान कर सकते हैं

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
क्लास स्कूलक्लास (ormar. Model):
    ormar_config = base_ormar_config (टेबलनाम = "स्कूलक्लास")

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


कक्षा श्रेणी (ormar. Model):
    ormar_config = base_ormar_config (टेबलनाम = "श्रेणियाँ")

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


कक्षा का छात्र (ormar. Model):
    ormar _ config = आधार _ ormar _ config कॉपी ()

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


कक्षा शिक्षक (ormar. Model):
    ormar _ config = आधार _ ormar _ config कॉपी ()

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


# जांगो शैली
कक्षाएं = ol.prefet_related का इंतजार करें (
    ["शिक्षक __ श्रेणी", "छात्र"]).all ()

# पायथन शैली
कक्षाएं = ol.prefet_related का इंतजार करें (
    [SchoolClass.teachers.category, olClass.students]).all ()
# शिक्षकों और शिक्षकों की श्रेणियों के साथ कक्षाएं लौटाएंगे
# साथ ही कक्षा के छात्र

M2फ़ील्ड बिल्कुल वैसा ही व्यवहार करता है, जहाँ आप M2फ़ील्ड का नाम दर्ज कर सकते हैं और आपके लिए अंतिम नमूना प्राप्त कर सकते हैं।

!!!चेतावनी: यदि आप सभी प्रश्नों के दौरान फ़ील्ड को गैर-अशक्त (और इसलिए आवश्यक) पर सेट करते हैं, तो गैर-अशक्त मॉडल स्वचालित रूप से पूर्वनिर्मित होते हैं, भले ही आप उन्हें चयन \ _ lated में शामिल न करें।

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

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

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

सहसंबंध बनाम प्रीफेच सहसंबंध का चयन करें

आपको किस -> का चयन करना चाहिए \ _ lated या pre\ _ lated का उपयोग करना चाहिए?

खैर, यह वास्तव में आपके डेटा पर निर्भर करता है। सबसे अच्छा जवाब यह है कि इसे अपने लिए आज़माएं और देखें कि कौन सा आपकी सिस्टम सीमाओं के भीतर तेजी से / बेहतर प्रदर्शन करता है।

क्या याद रखें:

प्रदर्शन

प्रश्नों की संख्या: का चयन करें \ _ lated हमेशा डेटाबेस के खिलाफ एक क्वेरी करता है, जबकि pre\ _ lated कई प्रश्न करता है। क्वेरी (I / O) संचालन आमतौर पर होते हैं, लेकिन जरूरी नहीं कि सबसे धीमा।

पंक्तियों की संख्या: मान लीजिए कि तालिका ए में 10,000 वस्तुएं हैं, प्रत्येक वस्तु में तालिका बी में 3 बाल वस्तुएं हैं, और फिर तालिका बी में प्रत्येक वस्तु में तालिका सी में 2 बाल वस्तुएं हैं।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
                     मॉडल सी
                   /
           मॉडल बी - मॉडल सी
         / 
मॉडल ए - मॉडल बी - मॉडल सी
       \           \ 
        \ मॉडल सी
         \
           मॉडल बी - मॉडल सी
                   \ 
                     मॉडल सी

यह माध्य जो \ _ lated का चयन करता है, हमेशा 60 000 पंक्तियों को लौटाएगा (10 000 * 3 * 2), बाद में 10,000 मॉडल तक संकुचित हो गया।

कितनी लाइनें प्रीफेच \ _ लेटेड वापस आएंगी?

खैर, यह निर्भर करता है, यदि प्रत्येक मॉडल बी और सी अद्वितीय है, तो यह पहली क्वेरी में 10,000 पंक्तियों और दूसरी क्वेरी में 30,000 पंक्तियों को लौटाएगा (तालिका बी में ए के 3 सबआइटम) इनमें से प्रत्येक अद्वितीय है), और 60,000 पंक्तियाँ (तालिका बी में प्रत्येक बच्चा अद्वितीय है)। तालिका सी में मॉडल बी के 2 बच्चे तीसरी क्वेरी में अद्वितीय हैं)।

इस मामले में, का चयन करें \ _ lated एक बेहतर विकल्प की तरह लगता है, न केवल यह 3 pre\ _ lated की तुलना में एक क्वेरी चलाएगा, बल्कि यह 100 000 pre\ _ lated की तुलना में 60 वापस आ जाएगा (10 + 30 + 60k) 000 लाइनें।

लेकिन क्या होगा अगर हर नमूना ए में ठीक उसी तरह के तीन नमूना बी हैं, और हर नमूना सी में ठीक उसी तरह नमूना सी है? का चयन करें \ _ lated अभी भी 60,000 पंक्तियों को लौटाएगा, जबकि pre\ _ lated नमूना A के लिए 10,000 पंक्तियाँ, नमूना B के लिए 3 पंक्तियाँ और नमूना C के लिए 2 पंक्तियाँ लौटाएगा। तो कुल 10,006 पंक्तियाँ। अब, नमूना की संरचना के आधार पर (यानी, अगर यह एक लंबा पाठ है () field, etc.), pre\ _ lated तेज हो सकता है, हालांकि इसे एक के बजाय तीन अलग-अलग प्रश्नों को निष्पादित करने की आवश्यकता है।

मेमोरी

लोड किए गए मॉडल के लिए regeको बनाए नहीं रखता है।

यह माध्य कि ऊपर दिए गए चुनिंदा \ _ lated उदाहरण में, आपके पास हमेशा 10,000 मॉडल A, 30,000 मॉडल B होंगे (भले ही डेटाबेस में अद्वितीय पंक्तियों की संख्या 3 हो - चयन \ _ lated प्रसंस्करण प्रत्येक माता-पिता के लिए एक नया उत्पन्न करता नमूना सबमॉडल)। और 60 000 मॉडल सी।

यदि पंक्तियाँ 1, 10, 100, आदि समान नमूना B साझा करती हैं, और आप उनमें से एक को अपडेट करते हैं, तो शेष पंक्तियाँ जो समान बच्चे को साझा करती हैं, उन्हें तुरंत अपडेट नहीं किया जाएगा। यदि आप डेटाबेस में अपने परिवर्तनों को सहेजते हैं, तो परिवर्तन केवल पुनः लोड करने के बाद उपलब्ध होते हैं (प्रत्येक चाइल्ड आइटम को व्यक्तिगत रूप से लोड करना या संपूर्ण क्वेरी को पुनः लोड करना)। यह माध्य जो \ _ lated का चयन करता है, अधिक मेमोरी का उपयोग करेगा क्योंकि प्रत्येक चाइल्ड ऑब्जेक्ट एक नई ऑब्जेक्ट के रूप में त्वरित है

  • जाहिर है, उन्होंने अपने स्थान का उपयोग किया।

!!!ध्यान रखें कि यदि हम कैशिंग शुरू करने का निर्णय लेते हैं तो यह भविष्य की रिलीज में बदल सकता है।

चेतावनी: डिफ़ॉल्ट रूप से, सभी बच्चे (या घटनाएं जहां एक ही नमूना दो बार से अधिक लोड किया जाता है) पूरी तरह से अलग और अलग पायथन ऑब्जेक्ट हैं, भले ही वे डेटाबेस में एक ही पंक्ति का प्रतिनिधित्व करते हों।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
वे तुलना करने पर सत्य का मूल्यांकन करेंगे, इसलिए ऊपर दिए गए उदाहरण में:

```python
# will return True if child1 of both rows is the same child db row 
row1.child1 == row100.child1

# same here:
model1 = await Model.get(pk=1)
model2 = await Model.get(pk=1) # same pk = same row in db
# will return `True`
model1 == model2
```

but

```python
# will return False (note that id is a python `builtin` function not ormar one).
id(row1.child1) == id(ro100.child1)

# from above - will also return False
id(model1) == id(model2)
```

इसके बजाय, pre\ _ lated के साथ, प्रत्येक विशिष्ट रूप से अलग बच्चे नमूना केवल एक बार तत्काल किया जाता है, और एक ही बच्चे नमूना सभी माता-पिता मॉडल के बीच साझा किया जाता है। यह माध्य कि ऊपर दिए गए pre\ _ lated उदाहरण में, यदि तालिका B में 3 अलग-अलग मॉडल हैं और तालिका C में 2 अलग-अलग मॉडल हैं, तो सभी मॉडल A उदाहरणों के बीच केवल 5 सबनेस्टेड मॉडल साझा किए जाएंगे। यह भी माध्य है कि यदि आप किसी भी संपत्ति को अपडेट करते हैं, तो सभी मूल ऑब्जेक्ट उस संपत्ति को अपडेट करेंगे क्योंकि वे एक ही चाइल्ड ऑब्जेक्ट साझा करते हैं।

नमूना विधि

प्रत्येक नमूना उदाहरण में स्वयं को सहेजने, अपडेट करने या लोड करने के तरीकों का एक सेट होता है।

लोड

आप लोड () विधि को कॉल करके एक विदेशी कुंजी संबंधित नमूना लोड कर सकते हैं।

लोड () का उपयोग डेटाबेस से नमूना को ताज़ा करने के लिए किया जा सकता है यदि इसे किसी अन्य प्रक्रिया द्वारा बदल दिया गया है।

!!!टिप नमूना विधि में लोड () विधि के बारे में अधिक पढ़ें

QueryProविधि

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

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

प्रासंगिक का चयन करें

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

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

सभी का चयन करें

बिल्कुल ऊपर दिए गए चयन \ _ सभी फ़ंक्शन के समान है, लेकिन आपको रिश्ते के दूसरे छोर से संबंधित ऑब्जेक्ट प्राप्त करने की अनुमति देता है।

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

प्रीफेच सहसंबंध

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

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