विषय पर बढ़ें

नमूना विधि

!!!डेटाबेस के साथ टिप की मुख्य बातचीत एक Queryऑब्जेक्ट के माध्यम से उजागर होती है, जो प्रत्येक नमूना पर Mo.के रूप में उजागर होती है, एक django orm के समान।

1
के बारे में अधिक पढ़ने के लिए **क्वेरिंग, टेबल में शामिल होना, खेतों को छोड़कर आदि का दौरा करना [प्रश्न][queries] अनुभाग।**

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

उपलब्ध तरीके इस प्रकार हैं।

पांडित्यपूर्ण विधि

ध्यान दें कि प्रत्येक ormar। मॉडल भी एक pydहै। बेसमॉडल, इसलिए सभी pydतरीकों का उपयोग नमूना पर भी किया जा सकता है, विशेष रूप से नमूना \ _ () और नमूना \ _ डंप \ _ json () तरीके, जो बहिष्करण, समावेशन और अन्य मापदंडों को भी स्वीकार कर सकते हैं।

अधिक पढ़ने के लिए, pydप्रलेखन देखें

मॉडल \ _ निर्माण ()

मॉडल _निर्माण का उपयोग एक नए उदाहरण के निर्माण के लिए किया जाता है।__इनिट _\ _ विधि के मूल समकक्ष।

अंतर यह है कि नमूना \ _ निर्माण सत्यापन को छोड़ देता है, इसलिए आपको इसका उपयोग करना चाहिए जब आप जानते हैं कि डेटा सही और भरोसेमंद है। निर्माण का उपयोग करने का लाभ लंघन सत्यापन के कारण निष्पादन की गति है।

!!!ध्यान दें कि pydantic.\ _ निर्माण विधि के विपरीत - ormar समकक्ष नेस्टेड संबंधित मॉडल को भी संभालेगा।

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

1
2
3
4
केवल दो चीजें जो अभी भी प्रदर्शन करती हैं, वे हैं:

*  प्रदान करना `default` फ़ील्ड सेट नहीं करने के लिए मान
*  यदि आप एक शब्दकोश या एक प्राथमिक कुंजी मान पास करते हैं तो नेस्टेड ऑर्मर मॉडल शुरू करें

मॉडल डंप ()

मॉडल \ _ डंप एक विधि है जो dसे विरासत में मिली है, लेकिन mar अपने स्वयं के मापदंडों को जोड़ता है और डिफ़ॉल्ट मूल्यों का उपयोग करने में कुछ बारीकियां हैं, इसलिए यह स्पष्टता के लिए यहां सूचीबद्ध है।

मॉडल \ _ डंप नमूना ट्री से शब्दकोश में डेटा निर्यात करता है।

मॉडल \ _ डंप पैरामीटर विवरण:

शामिल करें (or modify)

include: Union[Set, Dict] = None

लौटाए गए शब्दकोश में शामिल करने के लिए फ़ील्ड नाम या शब्दकोश का सेट।

ध्यान दें कि pydमें इंडेक्स द्वारा सूची से फ़ील्ड को शामिल / बाहर करने का एक असामान्य पैटर्न है (जैसा कि नेस्टेड नमूना है)। यदि आप सभी बच्चों से फ़ील्ड को बाहर करना चाहते हैं, तो आपको \ _ डालना होगा_सभी _\ _ कुंजी शब्दकोश में पारित की गई है।

आप dमें सेट में नेस्टेड मॉडल को बाहर नहीं कर सकते हैं, लेकिन आप मार में कर सकते हैं (रिश्ते के नाम में एक डबल अंडरस्कोर जोड़कर, यानी उन पुस्तकों के श्रेणी नामों को छोड़कर जिनका आप उपयोग कर सकते हैं)। exclude={"book__category__name"} )

मार सूचकांक बहिष्करण / समावेश का समर्थन नहीं करता है और एक सरलीकृत और अधिक उपयोगकर्ता के अनुकूल संकेतन को स्वीकार करता है।

नेस्टेड फ़ील्ड सहित फ़ील्ड को शामिल / बाहर करने के तरीके की जांच करने के लिए, स्पष्टीकरण और व्यापक उदाहरणों के साथ फ़ील्ड अनुभाग देखें।

!!!इस तथ्य पर ध्यान दें कि मार में आप एक संग्रह से नेस्टेड मॉडल को बाहर कर सकते हैं, आप प्रतिक्रिया में पूरे नमूना पेड़ से बाहर कर सकते हैं \ _ मॉडल \ _ बाहर करें और प्रतिक्रिया \ _ मॉडल \ _ फास्टापी में शामिल करें!

छोड़कर (or modify)

exclude: Union[Set, Dict] = None

लौटाए गए शब्दकोश से बाहर करने के लिए फ़ील्ड नामों का संग्रह या शब्दकोश।

ध्यान दें कि pydमें इंडेक्स द्वारा सूची से फ़ील्ड को शामिल / बाहर करने का एक असामान्य पैटर्न है (जैसा कि नेस्टेड नमूना है)। यदि आप सभी बच्चों से फ़ील्ड को बाहर करना चाहते हैं, तो आपको \ _ डालना होगा_सभी _\ _ कुंजी शब्दकोश में पारित की गई है।

आप pydमें सेट में नेस्टेड मॉडल को बाहर नहीं कर सकते हैं, लेकिन आप ormar में कर सकते हैं (संबंधपरक नाम में एक डबल अंडरस्कोर जोड़कर, यानी आपके द्वारा उपयोग की जा रही पुस्तक के श्रेणी नाम को छोड़कर)exclude={"book__category__name"})।

मार सूचकांक बहिष्करण / समावेश का समर्थन नहीं करता है और एक सरलीकृत और अधिक उपयोगकर्ता के अनुकूल संकेतन को स्वीकार करता है।

नेस्टेड फ़ील्ड सहित फ़ील्ड को शामिल / बाहर करने के तरीके की जांच करने के लिए, स्पष्टीकरण और व्यापक उदाहरणों के साथ फ़ील्ड अनुभाग देखें।

!!!ध्यान दें कि वास्तव में, ormar में, आप एक संग्रह में नेस्टेड मॉडल को बाहर कर सकते हैं, और आप प्रतिक्रिया में पूरे नमूना पेड़ से बाहर कर सकते हैं \ _ मॉडल \ _ बाहर और प्रतिक्रिया \ _ मॉडल \ _ फास्टापी में शामिल!

सेटिंग्स को छोड़ें \ _ रद्द करें

सेट न करें: बूलियन = गलत

ध्वज इंगित करता है कि क्या फ़ील्ड जो स्पष्ट रूप से सेट नहीं किए गए थे जब नमूना बनाया गया था, उन्हें लौटाए गए शब्दकोश से बाहर रखा जाना चाहिए।

!!!चेतावनी, कृपया ध्यान दें कि डेटाबेस में डेटा सहेजने के बाद, प्रत्येक फ़ील्ड का अपना मान है -> , जो आपके द्वारा प्रदान किया जा सकता है, एक डिफ़ॉल्ट मान या कोई नहीं।

 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
यह माध्य कि जब आप डेटाबेस से डेटा लोड करते हैं, **सभी** फ़ील्ड सेट हैं, और यह ध्वज मूल रूप से काम करना बंद कर देता है!


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

    आईडी: int = ormar। पूर्णांक (primary_key = True)
    नाम: str = ormar। स्ट्रिंग (max_length = 100, डिफ़ॉल्ट = "Test")
    दृश्यता: बूल = ormar। बूलियन (default = True)


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

    आईडी: int = ormar। पूर्णांक (primary_key = True)
    नाम: str = ormar। स्ट्रिंग (max_length = 100)
    मूल्य: फ्लोट = ऑरमार। फ्लोट (default = 9.99)
    श्रेणी: सूची [श्रेणी] = ormar। MTo(श्रेणी)

श्रेणी = श्रेणी (name = "Test 2")
श्रेणी मॉडल _ डंप () = = {'आईडी': कोई नहीं, 'आइटम': [], 'नाम': 'टेस्ट 2',
                           'दृश्यता': सच}
श्रेणी निर्दिष्ट करें। मॉडल _ डंप (excout _ unset = True) = = {'items': [], 'name': 'Test 2'}

प्रतीक्षा category.save ()
श्रेणी 2 = प्रतीक्षा करें श्रेणी ()
श्रेणी निर्दिष्ट करें। model_dump () = = {'आईडी': 1, 'आइटम': [], 'नाम': 'टेस्ट 2',
                            'दृश्यता': सच}
#NOTE कैसे db से लोड करने के बाद सभी फ़ील्ड स्पष्ट रूप से सेट किए जाते हैं
# जैसा कि यह तब होता है जब आप db से एक नमूना को आबाद करते हैं
categymodel_dump (excout _ unset = True) == {'आईडी': 1, 'आइटम': [],
                                              'नाम': 'टेस्ट 2', 'दृश्यता': सच}

डिफ़ॉल्ट मान छोड़ें

exclude_defaults: bool = False

ध्वज दर्शाता है कि यह अपने डिफ़ॉल्ट मान के बराबर है (whether set or not) लौटाए गए शब्दकोश से बाहर रखा जाना चाहिए

 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
कक्षा श्रेणी (ormar. Model):
    ormar_config = base_ormar_config (टेबलनाम = "श्रेणियाँ")

    आईडी: int = ormar। पूर्णांक (primary_key = True)
    नाम: str = ormar। स्ट्रिंग (max_length = 100, डिफ़ॉल्ट = "Test")
    दृश्यता: बूल = ormar। बूलियन (default = True)

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

    आईडी: int = ormar। पूर्णांक (primary_key = True)
    नाम: str = ormar। स्ट्रिंग (max_length = 100)
    मूल्य: फ्लोट = ऑरमार। फ्लोट (default = 9.99)
    श्रेणी: सूची [श्रेणी] = ormar। MTo(श्रेणी)

श्रेणी = श्रेणी ()
# ध्यान दें कि इंटेगर पीके डिफ़ॉल्ट ऑटोइन्क्रिमेंट द्वारा वैकल्पिक है
श्रेणी निर्दिष्ट करें। model_dump () = {'id': None, 'items': [], 'name': 'Test', 'visibility': True}
श्रेणी निर्दिष्ट करें। model_dump (excout _defaults=True) = = {'items': []}

# डेटा को सहेजें और पुनः लोड करें
प्रतीक्षा category.save ()
श्रेणी 2 = प्रतीक्षा करें श्रेणी ()

श्रेणी 2. मॉडल _ डंप () = = {'id': 1, 'items': [], 'name': 'Test', 'visibility': True}
श्रेणी 2 निर्दिष्ट करें। मॉडल _ डंप (excout _ de= True) = = {'id': 1, 'items': []}

बाहर \ _ कोई नहीं

बहिष्करण \ _ कोई नहीं: बूलियन = गलत

ध्वज इंगित करता है कि क्या फ़ील्ड के बराबर किसी को भी लौटाए गए शब्दकोश से बाहर नहीं किया जाना चाहिए।

 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
कक्षा श्रेणी (ormar. Model):
    ormar_config = base_ormar_config (टेबलनाम = "श्रेणियाँ")

    आईडी: int = ormar। पूर्णांक (primary_key = True)
    नाम: str = ormar। स्ट्रिंग (max_length = 100, डिफ़ॉल्ट = "परीक्षण", अशक्त = सच)
    दृश्यता: बूल = ormar। बूलियन (default = True)


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

    आईडी: int = ormar। पूर्णांक (primary_key = True)
    नाम: str = ormar। स्ट्रिंग (max_length = 100)
    मूल्य: फ्लोट = ऑरमार। फ्लोट (default = 9.99)
    श्रेणी: सूची [श्रेणी] = ormar। MTo(श्रेणी)


श्रेणी = श्रेणी (name = None)
श्रेणी मॉडल _ डंप () == {'आईडी': कोई नहीं, 'आइटम': [], 'नाम': कोई नहीं,
                           'दृश्यता': सच}
# नोट आईडी अभी तक सेट नहीं है इसलिए कोई भी नहीं है और बाहर रखा गया है
श्रेणी निर्दिष्ट करें। model_dump (excout _none = True) = = {'items': [], 'visibility': True}

प्रतीक्षा category.save ()
श्रेणी 2 = प्रतीक्षा करें श्रेणी ()
श्रेणी निर्दिष्ट करें। model_dump () = = {'आईडी': 1, 'आइटम': [], 'नाम': कोई नहीं,
                            'दृश्यता': सच}
categymodel_dump (exocist_none = True) == {'आईडी': 1, 'आइटम': [],
                                             'दृश्यता': सच}

सिवाय \ _ प्राथमिक \ _ कुंजी (ormar only)

exclude_primary_keys: bool = False

ध्वज को ट्रू पर सेट करना नेस्टेड मॉडल सहित पेड़ के सभी प्राथमिक कुंजी स्तंभों को बाहर करता है।

1
2
3
4
5
6
7
8
9
कक्षा Item (ormar. Model):
    ormar _ config = आधार _ ormar _ config कॉपी ()

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

आइटम 1 = आइटम (आईडी = 1, नाम = "टेस्ट आइटम")
आइटम डालें। model_dump () = = {"id": 1, "name": "Test Item"}
आइटम 1.model_dump (बहिष्कार_प्राथमिक_कुंजी = सच) = = {"name": "Test Item"}

सिवाय \ _ के माध्यम से \ _ मॉडल (ormar only)

exclude_through_models: bool = False

पास-थ्रू मॉडल प्रत्येक कई-से-कई संबंधों के लिए स्वचालित रूप से जोड़े जाते हैं, और वे लिंक किए गए नमूना / तालिका पर अतिरिक्त पैरामीटर रखते हैं।

\ _ के माध्यम से \ _ मॉडल को छोड़कर सेट करना = सबमॉडल के लिए पासथ्रू मॉडल सहित सभी पासथ्रू मॉडल को बाहर करता है।

 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
कक्षा श्रेणी (ormar. Model):
    ormar_config = base_ormar_config (टेबलनाम = "श्रेणियाँ")

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


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

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

# मॉडल को परिभाषित करने वाले पेड़
आइटम_डिक्ट = {
            "नाम": "परीक्षण",
            "श्रेणियां": [{"name": "test cat"},{"name": "test cat2"}],
        }
# पूरे पेड़ को बचाओ
इसका इंतजार करेंm (** item_dict). सहेजें _ संबंधित (अनुसरण करें = True, save_all = True)

# सहेजे गए मान प्राप्त करें
आइटम = प्रतीक्षा करें I.objects.select_related ("categories").get ()

# डिफ़ॉल्ट रूप से आप मॉडल के माध्यम से देख सकते हैं (itemcategory)
आइटम डालें। model_dump () = = {'आईडी': 1, 'नाम': 'परीक्षण',
                       'श्रेणियां': [
                           {'आईडी': 1, 'नाम': 'टेस्ट कैट',
                            'ItemCategory': {'id': 1, 'category': None, 'item': None}}, 
                           {'आईडी': 2, 'नाम': 'टेस्ट कैट 2',
                            'ItemCategory':{'id': 2, 'category': None, 'item': None}}
                       ]}

# आप उन क्षेत्रों / मॉडलों को बाहर कर सकते हैं
आइटम असाइन करें। model_dump (exout_through_models=True) == {
                       'आईडी': 1, 'नाम': 'परीक्षण',
                       'श्रेणियां': [
                           {'id': 1, 'name': 'test cat'}, 
                           {'id': 2, 'name': 'test cat2'}
                       ]}

मॉडल \ _ डंप \ _ json ()

मॉडल \ _ डंप \ _ json () में नमूना \ _ डंप () के समान पैरामीटर हैं, इसलिए उपरोक्त की जांच करें।

बेशक, अंतिम परिणाम JSद्वारा दर्शाया गया एक स्ट्रिंग है, शब्दकोश नहीं।

प्राप्त करें \ _ pyd()

get_pydantic(include: Union[Set, Dict] = None, exclude: Union[Set, Dict] = None)

यह विधि आपको सभी क्षेत्रों में फिर से प्रवेश किए बिना ormar मॉडल से dमॉडल उत्पन्न करने की अनुमति देती है।

कृपया ध्यान दें कि यदि आपके पास नेस्टेड मॉडल हैं, तो यह आपके लिए संपूर्ण नमूना ट्री उत्पन्न करेगा! लेकिन एक तरह से जो परिपत्र संदर्भ मुद्दों को रोकता है।

इसके अलावा, आप बहिष्करण पास कर सकते हैं और / या केवल उन क्षेत्रों को रखने के लिए पैरामीटर शामिल कर सकते हैं जिन्हें आप चाहते हैं, जिसमें नेस्टेड नमूना शामिल हैं।

यह माध्य आप Fमें अनुरोधों और प्रतिक्रियाओं के लिए आसानी से dमॉडल बना सकते हैं।

!!! नोट संभावित बहिष्करण / समावेशन के बारे में अधिक पढ़ने के लिए और बहिष्करण शब्दकोश या सेटिंग्स का निर्माण कैसे करें, कृपया प्रलेखन के क्षेत्र अनुभाग पर जाएं

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
base_ormar_config = ormar। marConfig (
    मेटाडेटा = वर्गधर्मी। मेटाडेटा (),
    डेटाबेस = डेटाबेस। डेटाबेस (DATABASE _ URL, बल _ रोलबैक = True),
)


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

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


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

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

आप एक साधारण कॉल के साथ एक नमूना उत्पन्न कर सकते हैं।

1
dantic= श्रेणी। get_pydantic (include ={"id", "name"})

यह निम्नलिखित के बराबर एक नमूना उत्पन्न करेगा:

1
2
3
कक्षा श्रेणी (बेसमॉडल):
    आईडी: वैकल्पिक [इंट]
    नाम: वैकल्पिक [str] = "परीक्षण"

!!! चेतावनी, एक मॉड्यूल में एक ही नाम के साथ कई कक्षाएं होना अच्छी आदत नहीं है, और यह फास्टापी प्रलेखन को तोड़ देगा। यही कारण है कि ormar कक्षा के नामों में यादृच्छिक 3 अपरकेस पत्र जोड़ता है। ऊपर दिए गए उदाहरण में, यह माध्य कि कक्षा को वास्तव में श्रेणी \ _ Xनाम दिया जाएगा (BaseModel).

नेस्टेड फ़ील्ड को बाहर करने या शामिल करने के लिए, आप एक शब्दकोश या डबल अंडरस्कोर का उपयोग कर सकते हैं।

1
2
3
# कॉल बराबर हैं
dantic= श्रेणी। get_pydantic (include ={"id", "items__id"})
dantic= श्रेणी। get_pydantic (include = {"id": ..., "आइटम":{"id"}})

परिणामी संरचना इस प्रकार है:

1
2
3
4
5
6
कक्षा आइटम (बेसमॉडल):
    आईडी: वैकल्पिक [इंट]

कक्षा श्रेणी (बेसमॉडल):
    आईडी: वैकल्पिक [इंट]
    आइटम: वैकल्पिक [सूची [आइटम]]

बेशक, आप एक गहरी नेस्टेड संरचना का भी उपयोग कर सकते हैं, और ओमार आपके लिए अपने dसमकक्ष उत्पन्न करेगा (एक तरह से जो छोरों को बाहर करता है)।

ध्यान दें कि ऊपर दिए गए आइटम नमूना श्रेणी का कोई संदर्भ नहीं है, भले ही संबंध द्विदिश हो (और ormar. आइटम में श्रेणियां क्षेत्र हैं)।

चेतावनी: परिणामी dनमूना मूल mar नमूना से सभी फ़ील्ड सत्यापनकर्ताओं को विरासत में मिला है, जिसमें dantic.validडेकोरेटर का उपयोग करके परिभाषित mar चयन सत्यापनकर्ता और सत्यापनकर्ता शामिल हैं।

1
लेकिन, एक ही समय में सभी रूट सत्यापनकर्ता मौजूद हैं `ormar` मॉडल करेंगे **नहीं** उत्पन्न पाइडेंटिक नमूना में कॉपी किया जाए।

चूंकि रूट सत्यापनकर्ता सभी फ़ील्ड पर काम कर सकते हैं और एक उपयोगकर्ता पाइडेंटिक मॉडल की पीढ़ी के दौरान कुछ फ़ील्ड को बाहर कर सकता है, इसलिए उन सत्यापनकर्ताओं को कॉपी करना सुरक्षित नहीं है। यदि आवश्यक हो, तो आपको pydमॉडल उत्पन्न करने के लिए उन्हें फिर से परिभाषित / मैन्युअल रूप से कॉपी करने की आवश्यकता है।

लोड ()

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

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

1
2
3
4
5
6
7
ट्रैक = Tr.का इंतजार करें (name = 'The Bird')
track.album.pk # मालिबू एल्बम pk (1) लौटाएगा
track.album.name # कोई नहीं लौटेगा

# आपको वास्तव में पहले डेटा लोड करने की आवश्यकता है
प्रतीक्षा ट्रैक.एल्बम.लोड ()
track.album.name # लौटेगी 'मालिबू'

सभी लोड करें ()

load_all(follow: bool = False, exclude: Union[List, str, Set, Dict] = None) -> Model

विधि लोड करने के लिए समान रूप से काम करती है (), लेकिन यह विधि नामक नमूना के सभी संबंधों पर भी पुनरावृत्ति करता है और उन्हें डेटाबेस से पुनः लोड करता है।

डिफ़ॉल्ट रूप से, लोड \ _ सभी विधि केवल उन मॉडलों को लोड करती है जो सीधे संबंधित हैं (one step away) उस नमूना को जो विधि कहता है।

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

चेतावनी: अनुसरण = सही सेटिंग के साथ आवर्ती अपडेट से बचने के लिए, लोड \ _ सभी विज़िट किए गए मॉडल का एक सेट रखता है और विज़िट किए गए मॉडल पर नेस्टेड लोड नहीं करता है।

1
2
3
4
5
6
इसलिए यदि आपके पास एक हीरा या परिपत्र संबंध प्रकार हैं, तो आपको मैनुअल तरीके से भार करने की आवश्यकता है।

```python
# in example like this the second Street (coming from City) won't be load_all, so ZipCode won't be reloaded
Street -> District -> City -> Street -> ZipCode
```

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

तरीके एक डेटाबेस क्वेरी करते हैं और इसलिए लोड करने के लिए नेस्टेड कॉल की तुलना में अधिक कुशल हैं () and all () on संबंधित मॉडल।

!!!टिप बहिष्करण के बारे में अधिक जानने के लिए, \ _ फ़ील्ड को छोड़कर पढ़ें

!!!चेतावनी सभी रिश्तों को लोड \ _ all () पर मंजूरी दे दी जाती है, इसलिए यदि आप कुछ नेस्टेड मॉडल को बाहर करते हैं, तो वे कॉल के बाद खाली हो जाएंगे।

सहेजें ()

सहेजें () -> स्व

आप Query.() विधि का उपयोग कर सकते हैं या नमूना को एक सामान्य dके रूप में आरंभ कर सकते नमूना और फिर एक नया नमूना बनाने के लिए () विधि को कॉल कर सकते हैं।

सहेजें () का उपयोग किसी नमूना में किए गए परिवर्तनों को सहेजने के लिए भी किया जा सकता है, बशर्ते कि प्राथमिक कुंजी सेट नहीं है या नमूना डेटाबेस में मौजूद नहीं है।

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

1
2
3
4
5
ट्रैक = ट्रैक (name = 'The Bird')
प्रतीक्षा track.save () # डेटाबेस में नमूना को बनाए रखेगा

ट्रैक = Tr.का इंतजार करें (name = 'The Bird')
प्रतीक्षा track.save () # अखंडता त्रुटि बढ़ाएगा क्योंकि pk आबादी है

अद्यतन ()

update(_columns: List[str] = None, **kwargs) -> self

आप Query.() विधि का उपयोग करके नमूना को अपडेट कर सकते हैं या नमूना गुणों को अपडेट करके (fields) और अपडेट () विधि को कॉल करके।

यदि आप प्राथमिक कुंजी सेट किए बिना नमूना अपडेट करने का प्रयास करते हैं, ModelPersistenceError अपवाद फेंक दिया जाता है।

नए बनाए गए नमूना को बनाए रखने के लिए, सहेजें () या upsert का उपयोग करें (**Kwargs) विधि।

1
2
ट्रैक = Tr.का इंतजार करें (name = 'The Bird')
प्रतीक्षारत ट्रैक.अपडेट (नाम = 'द बर्ड्स स्ट्राइक्स अगेन')

डेटाबेस में नमूना में केवल चयनित स्तंभों को अपडेट करने के लिए, \ _ कॉलम पैरामीटर में अपडेट किए गए स्तंभों की एक सूची प्रदान करें।

उदाहरण में:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
क्लास मूवी (ormar. Model):
    ormar _ config = आधार _ ormar _ config कॉपी ()

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

टर्मिनेटर = प्रतीक्षा मूवी (नाम = 'टर्मिनेटर', वर्ष = 1984, लाभ = 0.078).सेव ()

terminator.name = "टर्मिनेटर 2"
टर्मिनेटर .वर्ष = 1991
टर्मिनेटर .लाभ = 0.520

# अपडेट केवल नाम
प्रतीक्षा करें (_columns = ["name"])

# ध्यान दें कि टर्मिनेटर उदाहरण को फिर से लोड नहीं किया गया था
अनुमानित टर्मिनेटर = = 1991

# लेकिन एक बार जब आप db से डेटा लोड करते हैं तो आप देखते हैं कि यह अपडेट नहीं किया गया था
प्रतीक्षा टर्मिनेटर लोड ()
अनुमानित टर्मिनेटर = = 1984

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

अद्यतन सम्मिलित करें ()

अपसर्ट (**kwargs) -> स्व

यह उपरोक्त सेव () या अपडेट (**kwargs) विधियों के लिए एक प्रॉक्सी है।

यदि प्राथमिक कुंजी -> पर सेट है, तो अद्यतन विधि कहा जाता है।

यदि pk सेट नहीं है, तो सहेजें () विधि कहा जाता है।

1
2
3
4
5
ट्रैक = ट्रैक (name = 'The Bird')
Atrack.upsert () # कॉल सेव करेगा क्योंकि pk खाली है

ट्रैक = Tr.का इंतजार करें (name = 'The Bird')
प्रतीक्षा कर रहा है tra.upsert (name = 'द बर्ड स्ट्राइक्स अगेन') # कॉल अपडेट होगा क्योंकि pk पहले से ही आबाद है

हटाएं ()

आप Query.() विधि का उपयोग कर सकते हैं या अपने नमूना का उपयोग कर सकते हैं और किसी नमूना को हटाने के लिए हटाएं () विधि को कॉल कर सकते हैं।

1
2
ट्रैक = Tr.का इंतजार करें (name = 'The Bird')
प्रतीक्षा कर रहा है। () # डेटाबेस से नमूना को हटा देगा

!!!कृपया ध्यान दें कि ट्रेस ऑब्जेक्ट अपरिवर्तित रहता है, केवल डेटाबेस में रिकॉर्ड हटा दिए जाते हैं।

संबंधित सहेजें ()

save_related(follow: bool = False, save_all: bool = False, exclude=Optional[Union[Set, Dict]]) -> None

विधि नमूना के सभी संबंधों पर पुनरावृत्ति करती है जिसे विधि कहा जाता है और प्रत्येक असहेजे गए नमूना पर upsert () विधि को कॉल करता है।

यह पता लगाने के लिए कि नमूना कब सहेजा जाता है, ऊपर स्थिति सहेजें अनुभाग देखें।

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

लेकिन आप नेस्टेड मॉडल के माध्यम से पुनरावृत्ति करने के लिए अनुसरण = सही पैरामीटर निर्दिष्ट कर सकते हैं और उन सभी को संबंधपरक पेड़ में बचा सकते हैं।

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

यदि आप सभी संबंधित तरीकों को सहेजने के लिए मजबूर करना चाहते हैं, तो सहेजें \ _ all = ट्रू फ्लैग का उपयोग करें, जो सभी संबंधित मॉडलों को अपडेट करेगा, भले ही उनकी सहेजें स्थिति।

यदि आप कुछ संबंधों को सहेजना छोड़ना चाहते हैं, तो आप बहिष्करण पैरामीटर पास कर सकते हैं।

बहिष्कृत अपने स्वयं के नमूना संबंधों का एक सेट हो सकता है, या एक शब्दकोश जिसमें नेस्टेड आइटम भी हो सकते हैं।

!!!ध्यान दें कि सहेजें \ _ lated में बहिष्करण पैरामीटर केवल संबंधपरक फ़ील्ड नामों को स्वीकार करता है, इसलिए यदि आप किसी अन्य फ़ील्ड को पास करते हैं, तो वे वैसे भी सहेजे जाएंगे

!!!नोट बहिष्करण के लिए पारित संभावित मूल्यों की संरचना के बारे में अधिक जानने के लिए, Query.विधि प्रलेखन की जांच करें।

चेतावनी: अनुसरण = सही सेटिंग के साथ आवर्ती अपडेट से बचने के लिए, सहेजें \ _ lated संबंधपरक पेड़ की प्रत्येक शाखा पर विज़िट किए गए मॉडल का एक सेट रखता है और विज़िट किए गए मॉडल पर नेस्टेड सेव \ _ lated नहीं करता है।

1
इसलिए यदि आपके पास परिपत्र संबंध प्रकार हैं तो आपको मैनुअल तरीके से अपडेट करने की आवश्यकता है।

ध्यान दें कि \ _ all = सत्य और अनुसरण करें = सत्य के साथ आप एक ही बार में पूरे पेड़ को बचाने के लिए \ _ lated () का उपयोग कर सकते हैं।

उदाहरण:

 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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
कक्षा विभाग (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)
    कोर्स_नाम: str = ormar। स्ट्रिंग (max_length = 100)
    पूर्ण: बूल = ormar। बूलियन ()
    विभाग: वैकल्पिक [विभाग] = ormar। विदेशी (विभाग)


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

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

बचाने के लिए = {
            "विभाग_नाम": "ओरमार",
            "पाठ्यक्रम": [
                {"कोर्स_नाम": "बेसिक 1",
                 "पूरा": सच है,
                 "छात्र": [
                     {"name": "Jack"},
                     {"name": "Abi"}
                 ]},
                {"कोर्स_नाम": "बेसिक 2",
                 "पूरा": सच है,
                 "छात्र": [
                     {"name": "Kate"},
                     {"name": "Miranda"}
                 ]
                 },
            ],
        }
# पूरे पेड़ को इनिशियलाइज़ करें
विभाग = विभाग (** to_save)

# एक बार में सभी को बचाओ (one after another)
Aविभाग सहेजें _ संबंधित (अनुसरण करें = True, save_all = True)

विभाग_चेक = प्रतीक्षा विभाग.objects.select_all (follow = True).मिल ()

को _ बाहर करना = {
    "आईडी": ...,
    "पाठ्यक्रम": {
        "आईडी": ...,
        "छात्र": {"id", "studentcourse"}
    }
}
# आईडी को छोड़कर और मॉडल के माध्यम से आपको सटीक समान पेलोड मिलता है जिसका उपयोग किया जाता है
# पूरे पेड़ का निर्माण करें
विभाग _ चेक मॉडल _ डंप डालें (exclude = to_exclude) == बचाने के लिए

चेतावनी सहेजें \ _ lated () सभी संबंधों और सभी मॉडलों पर पुनरावृत्ति करता है और उन्हें एक-एक करके अपडेट करता है, इसलिए यह सभी मॉडलों को बचाएगा, लेकिन डेटाबेस प्रश्नों की संख्या के संदर्भ में इष्टतम नहीं हो सकता है।