ओरमार

[! पाइपी संस्करण ] (https://pypi.org/project/ormar) ! [कवरेज] ] (https://codecov.io/gh/collerek/ormar)! [कोडफैक्टर] ] (https://www.codefactor.io/repository/github/collerek/ormar)

अवलोकन

Ormar पैकेज पायथन के लिए एक अतुल्यकालिक ORM है जो postgres, SQL और SQLite का समर्थन करता है।

ormar का उपयोग करने के मुख्य लाभ हैं:

• एक अतुल्यकालिक ओआरएम प्राप्त करें जिसका उपयोग अतुल्यकालिक ढांचे (फास्टापी, स्टारलेट, आदि) के साथ किया जा सकता है।
• बस एक नमूना बनाए रखें - आपको pydऔर अन्य orm मॉडल (sqlalchemy, peewee, gino, etc.) बनाए रखने की ज़रूरत नहीं है।

लक्ष्य एक सरल ओआरएम बनाना है जिसका उपयोग सीधे डेटा सत्यापन के लिए Pydantic- आधारित Fके साथ किया जा सकता है (अनुरोध और प्रतिक्रिया नमूना के रूप में)।

ormar - इसके नाम में स्पष्ट "ORM" से अलग - स्वीडिश ormar से अपना नाम प्राप्त करता है, जो सांप माध्य है, और क्रोएशियाई ormar (e), जो कैबिनेट माध्य है।

पायथन ओआरएम के लिए, स्नेक्स कैबिनेट से बेहतर नाम क्या है?

यदि आप ormar पसंद करते हैं, तो Hub में रिपॉजिटरी को स्टार करना याद रखें!

हम जितना बड़ा समुदाय बनाते हैं, उतना ही आसान होगा बग को स्पॉट करना और योगदानकर्ताओं को आकर्षित करना।

दस्तावेज़

विवरण के लिए प्रलेखन की जाँच करें।

कृपया ध्यान दें कि संक्षिप्तता के लिए, अधिकांश प्रलेखन टुकड़े डेटाबेस के निर्माण और निर्धारित अतुल्यकालिक चल रहे कार्यों के निष्पादन को छोड़ देते हैं।

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

लेकिन ध्यान रखें कि ये सिर्फ परीक्षण हैं, और सभी समाधान वास्तविक जीवन के उपयोग के लिए उपयुक्त नहीं हैं।

Fपारिस्थितिकी तंत्र का हिस्सा

Fपारिस्थितिकी तंत्र के हिस्से के रूप में, mar चयनित पुस्तकालयों में समर्थित है जो किसी तरह से डेटाबेस के साथ काम करते हैं।

ormar अभी भी SQL बोली अज्ञेय है - इसलिए केवल कॉलम जो सभी समर्थित बैकएंड में काम करते हैं, लागू किए जाते हैं।

ormar के विस्तार के रूप में, विशिष्ट बोलियों के लिए स्तंभों को लागू करना अपेक्षाकृत आसान है।

पोस्टग्रेस कॉलम-विशिष्ट कार्यान्वयन: ormar-postgres-extensions

यदि आप एक अलग लाइब्रेरी को बनाए रखते हैं या उपयोग करते हैं और चाहते हैं कि यह ormar का समर्थन करे, तो कृपया हमें बताएं कि हम कैसे सहायता कर सकते हैं।

निर्भरता

ओरमार का निर्माण है:

• प्रश्नों के निर्माण के लिए SQL कीमिया कोर।
• क्रॉस-डेटाबेस अतुल्यकालिक समर्थन के लिए डेटाबेस।
• dका उपयोग डेटा सत्यापन के लिए किया जाता है।

लाइसेंस

मार को ओपन-सोर्स सॉफ्टवेयर के रूप में बनाया गया है और यह पूरी तरह से मुफ्त रहेगा (MIT लाइसेंस के तहत)।

जब मैं काम पर रोजमर्रा की समस्याओं को हल करने या एक मजबूत पायथन समुदाय को बढ़ावा देने और बनाने के लिए ओपन-सोर्स कोड लिखता हूं, तो आप धन्यवाद कह सकते हैं और मुझे एक प्याला कॉफी या मासिक अनुदान खरीद सकते हैं ताकि यह सुनिश्चित किया जा सके कि मेरा काम मुफ्त और बनाए रखा गया है। ।

प्रायोजक

sqlalchऔर मौजूदा डेटाबेस से प्रवासन

यदि आप वर्तमान में sqlalchका उपयोग कर रहे हैं और ormar पर स्विच करना चाहते हैं, तो स्वचालित अनुवाद उपकरण देखें, जो आपको मौजूदा sqlalchorm मॉडल अनुवाद में मदद कर सकता है ताकि आपको मैन्युअल रूप से ऐसा न करना पड़े।

बीटा संस्करण github पर पाए जा सकते हैं: sqlalchemistry-to-ormar या बस pip install sqlalchemy-to-ormar

Sqlalchemy-to-ormar का उपयोग sqoen के साथ स्वचालित रूप से मैप करने / मौजूदा डेटाबेस से ormar मॉडल उत्पन्न करने के लिए किया जा सकता है, भले ही आपकी परियोजना sqlalchका उपयोग न करे।

प्रवासन और डेटाबेस निर्माण

क्योंकि ormar SQL कीमिया कोर पर बनाया गया है, आप डेटाबेस माइग्रेशन (जो आपको वास्तव में उत्पादन कोड के लिए करना चाहिए) प्रदान करने के लिए एलेम्बिक का उपयोग कर सकते हैं।

परीक्षण और बुनियादी अनुप्रयोगों के लिए, वर्गचिकित्सा पर्याप्त है।

# नोट यह नीचे एक आंशिक स्निपेट पूर्ण कार्य उदाहरण है
# 1. आयात
आयात sqlalchआयात करें
आयात डेटाबेस
आयात करें

# 2। आरंभीकरण
DATABASE_URL = "स्क्लाइट: //db.sqlite"
base_ormar_config = ormar। marConfig (
    मेटाडेटा = वर्गधर्मी। मेटाडेटा (),
    डेटाबेस = डेटाबेस। डेटाबेस (DATABASE_URL),
    इंजन = sqlal (DATABASE_URL),
)

यहां मॉडल परिभाषित करें

# 3। डेटाबेस निर्माण और टेबल निर्माण
आधार _ ormar _ config मेटाडेटा बनाएँ _ all (engine)

एलेम्बिक के नमूना कॉन्फ़िगरेशन और माइग्रेशन और डेटाबेस निर्माण के बारे में अधिक जानकारी के लिए, माइग्रेशन प्रलेखन अनुभाग पर जाएं।

पैक संस्करण

ormar अभी भी विकास में है: हम किसी भी निर्भरता को ठीक करने की सलाह देते हैं (यानी ormar ~= 0.9.1

ऑर्मर रिलीज़ नंबरिंग का भी अनुसरण करता है, अर्थात् प्रमुख परिवर्तन प्रमुख संस्करण संख्या को बढ़ाते हैं, जबकि अन्य परिवर्तन और सुधार मामूली संस्करण संख्या को बढ़ाते हैं, इसलिए बाद के लिए आपको अपडेट करने के लिए सुरक्षित होना चाहिए, लेकिन पहले रिलीज़ प्रलेखन को पढ़ना सुनिश्चित करें।example: (0.5.2 -> 0.6.0 - breaking, 0.5.2 -> 0.5.3 - non breaking)।

अतुल्यकालिक अजगर

कृपया ध्यान दें कि ormar एक अतुल्यकालिक ORM है, जो माध्य आपको एक विधि के लिए कॉल का इंतजार करना होगा जो इवेंट लूप में निष्पादित करने के लिए निर्धारित है। पायथन में एक अंतर्निहित मॉड्यूल, asyncio है, जो आपको ऐसा करने की अनुमति देता है।

कृपया ध्यान दें कि अधिकांश "सामान्य" पायथन दुभाषिया प्रतीक्षा को किसी फ़ंक्शन के बाहर निष्पादित करने की अनुमति नहीं देते हैं (क्योंकि आप वास्तव में निष्पादन को स्थगित करने के लिए इस फ़ंक्शन को शेड्यूल करते हैं और तत्काल परिणाम प्राप्त नहीं करते हैं)।

Fजैसे आधुनिक वेब फ्रेमवर्क में, फ्रेमवर्क आपके लिए इसे संभाल लेगा, लेकिन यदि आप स्वयं ऐसा करने की योजना बनाते हैं, तो आपको इसे मैन्युअल रूप से करने की आवश्यकता होगी, जैसा कि नीचे दिए गए क्विकस्टार्ट में वर्णित है।

त्वरित शुरुआत

कृपया ध्यान दें कि आप Hub पर उदाहरण फ़ोल्डर में एक ही स्क्रिप्ट पा सकते हैं।

टाइपिंग से वैकल्पिक आयात

आयात डेटाबेस

आयात करें
आयात sqlalchआयात करें

DATABASE_URL = "स्क्लाइट: //db.sqlite"
base_ormar_config = ormar। marConfig (
    मेटाडेटा = वर्गधर्मी। मेटाडेटा (),
    डेटाबेस = डेटाबेस। डेटाबेस (DATABASE_URL),
    इंजन = sqlal (DATABASE_URL),
)

# ध्यान दें कि यह चरण वैकल्पिक है -> सभी ormar देखभाल नाम के साथ एक क्षेत्र है
#ormar_config # और उचित पैरामीटर, लेकिन इस तरह से आपको दोहराना नहीं है
# समान पैरामीटर यदि आप केवल एक डेटाबेस का उपयोग करते हैं
#
# ध्यान दें कि सभी प्रकार के संकेत वैकल्पिक हैं
# नीचे एक पूरी तरह से मान्य नमूना घोषणा है
# वर्ग लेखक (ormar. Model):
# ormar_config = base_ormar_config (टेबलनाम = "लेखक")
#
# आईडी = ormar। पूर्णांक (primary_key = True ) # <= कोई तनाव नहीं क्षेत्र प्रकार
# नाम = ormar। स्ट्रिंग (max_length = 100)


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

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


क्लास बुक (ormar. Model):
    ormar_config = आधार_ormar_config (tablename = "books")

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


# डेटाबेस बनाएं
# ध्यान दें कि उत्पादन में आपको पलायन का उपयोग करना चाहिए
# ध्यान दें कि यदि आप किसी मौजूदा डेटाबेस से कनेक्ट करते हैं तो इसकी आवश्यकता नहीं है
# यह सुनिश्चित करने के लिए कि हमने पहले db को मंजूरी दे दी है
आधार _ ormar _ config मेटाडेटा ड्रॉप _ सभी (इंजन)
आधार _ ormar _ config मेटाडेटा बनाएँ _ all (engine)


# नीचे दिए गए सभी कार्यों को कार्यक्षमता श्रेणियों में विभाजित किया गया है
# ध्यान दें कि सभी कार्यों को async के साथ कैसे परिभाषित किया गया है - इसलिए प्रतीक्षा और जरूरतों का उपयोग कर सकते हैं
# अपने दम पर इंतजार कर रहे हैं
nc def बनाएँ ():
    # Query.विधि के माध्यम से काम करने के लिए कुछ रिकॉर्ड बनाएं।
    # ध्यान दें कि क्वेरी प्रत्येक मॉडल की कक्षा पर ऑब्जेक्ट के रूप में उजागर होती है
    टॉल्किन = लेखक का इंतजार करें। नाम = "जेआरआर टॉल्किन")
    प्रतीक्षारत .(लेखक = tolkien, शीर्षक = "द हॉबिट", वर्ष = 1937)
    प्रतीक्षारत .(लेखक = tolkien, शीर्षक = "द लॉर्ड ऑफ द रिंग्स", वर्ष = 1955)
    प्रतीक्षारत .(लेखक = tolkien, शीर्षक = "द सिल्मारिलियन", वर्ष = 1977)

    # 2 चरणों में विभाजित वस्तुओं का वैकल्पिक निर्माण
    सैपकोव्स्की = लेखक (नाम = "आंद्रेजेज सैपकोव्स्की")
    # कुछ सामान
    प्रतीक्षा sapkowski.save ()

    # या सहेजें () आरंभीकरण के बाद
    प्रतीक्षारत पुस्तक (लेखक = सैपकोव्स्की, शीर्षक = "द विचर", वर्ष = 1990)। बचाओ ()
    प्रतीक्षारत पुस्तक (लेखक = सैपकोव्स्की, शीर्षक = "द टॉवर ऑफ फूल्स", वर्ष = 2002)। बचाओ ()

    # डेटाबेस में डेटा डालने के बारे में अधिक पढ़ने के लिए
    # यात्रा: https://collerek.github.io/ormar/queries/create /


nc def पढ़ें ():
    # एक उदाहरण प्राप्त करें, उस पर एक विदेशी कुंजी संबंध लोड किए बिना।
    # जांगो शैली
    पुस्तक = प्रतीक्षा करें
    # या अजगर शैली
    पुस्तक = प्रतीक्षा करें
    2 = प्रतीक्षा करें

    #first () निम्न प्राथमिक कुंजी मान के साथ उदाहरण प्राप्त करता है
    पुस्तक = = पुस्तक 2

    # आप लोड किए गए मॉडल पर सभी फ़ील्ड तक पहुंच सकते हैं
    पुस्तक का उच्चारण करें। शीर्षक = = "द हॉबिट"
    पुस्तक का उच्चारण करें

    # जब कोई शर्त पास नहीं होती है ()
    # यह प्राथमिक कुंजी कॉलम के आधार पर अंतिम () के रूप में व्यवहार करता है
    3 = प्रतीक्षा करें
    पुस्तक 3.शीर्षक = = "मूर्खों का टॉवर"

    # जब आपका कोई संबंध होता है, तो ormar हमेशा आपके लिए एक संबंधित नमूना को परिभाषित करता है
    # जब आप सभी लोड करते हैं तो इस उदाहरण की तरह एक विदेशी कुंजी मान होता है
    जोर देना उदाहरण है (book.author, Author)
    # प्राथमिक कुंजी पुस्तकों की तालिका में संग्रहीत विदेशी कुंजी से आबाद है
    book.author.pk = = 1
    # चूंकि संबंधित नमूना लोड नहीं किया गया था अन्य सभी फ़ील्ड कोई नहीं हैं
    book.author.name कोई नहीं है

    # डेटाबेस से संबंध लोड करें जब आपके पास पहले से ही संबंधित नमूना
    # वैकल्पिक रूप से नीचे दिए गए अनुभाग को देखें
    प्रतीक्षा book.author ()
    book.author.name = = "जे.आर.आर. टोल्किन"

    # दिए गए नमूना के लिए सभी पंक्तियों को प्राप्त करें
    लेखक = or.all का इंतजार करें ()
    अभिकथन लेन (लेखक) == 2

    # डेटाबेस से डेटा पढ़ने के बारे में अधिक पढ़ने के लिए
    # यात्रा: https://collerek.github.io/ormar/queries/read /


nc def अपडेट ():
    # db से मौजूदा पंक्तियों को पढ़ें
    टॉल्किन = प्रतीक्षा करें or.(name = "J.R.R. टॉल्किन")
    tolkien.name = = "जे.आर.आर. टोल्किन"
    tolkien_id = tolkien.id

    # चयनित गुणों को बदलें
    tolkien.name = "जॉन रोनाल्ड रेउल टोल्किन"
    एक नमूना उदाहरण पर #call अपडेट
    प्रतीक्षा कर रहा है। ()

    # पुष्टि करें कि ऑब्जेक्ट अपडेट किया गया था
    टॉल्किन = लेखक का इंतजार करें। (नाम = "जॉन रोनाल्ड रीएल टॉल्किन")
    tolkien.name करें
    tolkien.id करें

    # लोड किए बिना वैकल्पिक रूप से डेटा अपडेट करें
    Aor.फ़िल्टर का इंतजार करें (name__ines="Tolkien").(name="J.R.R. Tolkien")

    # डेटाबेस में डेटा अपडेट करने के बारे में अधिक पढ़ने के लिए
    # यात्रा: https://collerek.github.io/ormar/queries/update /


nc def हटाएं ():
    सिल्मारिलियन = प्रतीक्षा करें (year = 1977)
    # कॉल डिलीट () उदाहरण पर
    सिल्मारिलियन डिलीट का इंतजार ()

    # वैकल्पिक रूप से लोड किए बिना हटाएं
    प्रतीक्षारत .(शीर्षक = "मूर्खों का टॉवर")

    # ध्यान दें कि जब कोई रिकॉर्ड नहीं होता है तो ormar Noअपवाद उठाता है
    कोशिश:
        प्रतीक्षा कर रहा है (year = 1977)
    ओमार को छोड़कर। NoMatch:
        प्रिंट ("1977 से कोई किताब नहीं!")

    # डेटाबेस से डेटा हटाने के बारे में अधिक पढ़ने के लिए
    # यात्रा: https://collerek.github.io/ormar/queries/delete /

    # ध्यान दें कि इस तथ्य के बावजूद कि रिकॉर्ड अब डेटाबेस में मौजूद नहीं है
    # ऊपर दी गई वस्तु अभी भी सुलभ है और आप इसका उपयोग कर सकते हैं i.e.save ()) फिर से।
    टॉल्किन = silmarillion.author
    प्रतीक्षारत .(लेखक = tolkien, शीर्षक = "द सिल्मारिलियन", वर्ष = 1977)


Ac def जुड़ता है:
    # दो मॉडल में शामिल हों select_related का उपयोग करें

    # जांगो शैली
    पुस्तक = प्रतीक्षा करें
    # पायथन शैली
    पुस्तक = प्रतीक्षा करें (Book.author).प्राप्त करें)
        पुस्तक .शीर्षक == "द हॉबिट"
    )

    # लेखक पहले से ही पूर्वनिर्मित है
    book.author.name = = "जे.आर.आर. टोल्किन"

    # डिफ़ॉल्ट रूप से आपको संबंध का दूसरा पक्ष भी मिलता है
    # लोअरकेस स्रोत नमूना नाम + 's' के रूप में निर्मित (books in this case)
    # आप पैरामीटर संबंधित_नाम के साथ कस्टम नाम भी प्रदान कर सकते हैं

    # जांगो शैली
    लेखक = लेखक का इंतजार करें
    # पायथन शैली
    लेखक = लेखक का इंतजार करें (Author.books).सभी (
        Author.name = = "जे.आर.आर. टोल्किन"
    )
    लेन डालें (author [0] .books) == 3

    # रिवर्स और कई संबंधों के लिए आप प्रीफेक_संबंधित भी कर सकते हैं
    # जो संबंधित मॉडल में से प्रत्येक के लिए एक अलग क्वेरी निष्पादित करता है

    # जांगो शैली
    लेखक = लेखक का इंतजार करें
    # पायथन शैली
    लेखक = लेखक का इंतजार करें (Author.books).प्राप्त करें)
        Author.name = = "जे.आर.आर. टोल्किन"
    )
    लेन डालें (author.books) == 3

    # संबंधों के बारे में अधिक पढ़ने के लिए
    # यात्रा: https://collerek.github.io/ormar/relations /

    # जॉइन और सबक्वेरी के बारे में अधिक पढ़ने के लिए
    # यात्रा: https://collerek.github.io/ormar/queries/joins-and-subqueries /


Ac def फ़िल्टर _ और _ सॉर्ट ():
    # क्वेरी को फ़िल्टर करने के लिए आप फ़िल्टर () का उपयोग कर सकते हैं या कुंजी-मान पार्स पास कर सकते हैं
    # गेट (), all () आदि।
    # डबल का उपयोग करके विशेष तरीकों या संबंधित नमूना क्षेत्रों का उपयोग करने के लिए
    #underscore लेखक के नाम से फ़िल्टर करना पसंद करता है लेखक __ नाम का उपयोग करता है
    # जांगो शैली
    पुस्तकें = प्रतीक्षा करें .all (author__name = "J.R.R. Tolkien")
    # अजगर शैली
    पुस्तकें = प्रतीक्षा करें Book.author.name = = "जे.आर.आर. टोल्किन")
    लेन (पुस्तकें) = = 3

    #filters डबल अंडरस्कोर के साथ अलग किए गए विशेष तरीकों को भी स्वीकार कर सकते हैं
    # वर्ग प्रश्न जारी करने के लिए ` where authors.name like "%tolkien%"` वह नहीं है
    # केस संवेदनशील (इसलिए टोल्किन में छोटा टी)
    # जांगो शैली
    पुस्तकें = प्रतीक्षा करें
    # अजगर शैली
    किताबें = प्रतीक्षा करें .फ़िल्टर Book.author.name आइकन ("tolkien")).all ()
    लेन (पुस्तकें) = = 3

    # क्वेरी के ऑर्डर_बाय () फ़ंक्शन का उपयोग करने के लिए सॉर्ट करें
    # क्षेत्र नाम से पहले हाइफ़न का उपयोग करके कम करने के लिए सॉर्ट करें
    # फ़िल्टर के साथ आप संबंधित फ़ील्ड तक पहुंचने के लिए डबल अंडरस्कोर का उपयोग कर सकते हैं
    # जांगो शैली
    किताबें = (
        प्रतीक्षा करें
        । आदेश _ द्वारा ("-year")
        । सभी ()
    )
    # अजगर शैली
    किताबें = (
        प्रतीक्षा करें (icontains Book.author.name ("tolkien"))
        आदेश_बाय (Book.year.desc ())
        । सभी ()
    )
    लेन (पुस्तकें) = = 3
    सम्मिलित पुस्तकें [0]। शीर्षक = = "द सिल्मारिलियन"
    सम्मिलित पुस्तकें [2] । शीर्षक = = "द हॉबिट"

    # फ़िल्टरिंग और ऑर्डर करने के बारे में अधिक पढ़ने के लिए
    # यात्रा: https://collerek.github.io/ormar/queries/filter-and-sort /


Ac def सबसेट _ of _ कॉलम ():
    # डेटाबेस को क्वेरी करते समय कुछ स्तंभों को लोडिंग से बाहर करने के लिए
    # आप फ़ाइल () विधि का उपयोग कर सकते हैं
    हॉबिट = प्रतीक्षा करें
    # ध्यान दें कि फ़ील्ड में शामिल फ़ील्ड खाली नहीं हैं (set to None)
    शौक का दावा करें। साल कोई नहीं है
    hobbit.author कोई नहीं है

    # चयनित क्षेत्र है
    hob.शीर्षक = = "द हॉबिट"

    # वैकल्पिक रूप से आप उन स्तंभों को प्रदान कर सकते हैं जिन्हें आप बाहर करना चाहते हैं
    हॉबिट = प्रतीक्षा करें .objects.oxit_fields (["year"]).गेट (शीर्षक = "द हॉबिट")
    # वर्ष अभी भी सेट नहीं है
    शौक का दावा करें। साल कोई नहीं है
    # लेकिन लेखक वापस आ गया है
    hobbit.author कोई नहीं है

    # इसके अलावा आप प्राथमिक कुंजी कॉलम को बाहर नहीं कर सकते - यह हमेशा होता है
    # अगर आप इसे पूरी तरह से बाहर करते हैं तो यह वहां होगा

    # ध्यान दें कि प्रत्येक नमूना पास प्राथमिक_कुंजी कॉलम के लिए एक शॉर्टकट है जो पीके है
    # और आप नीचे दिए गए इस उपनाम द्वारा मानों को फ़िल्टर / एक्सेस / सेट कर सकते हैं
    hobbit.pk कोई नहीं है

    # ध्यान दें कि आप उन क्षेत्रों को बाहर नहीं कर सकते हैं जो अशक्त नहीं हैं
    # (आवश्यक) नमूना परिभाषा में
    कोशिश:
        प्रतीक्षा करें .objects.exoct_fields (["title"]).गेट (title="द हॉबिट")
    सिवाय pydantic के। मान्य त्रुटि:
        प्रिंट ("गैर-अशक्त फ़ील्ड शीर्षक को बाहर नहीं कर सकता")

    # स्तंभों के सबसेट का चयन करने के बारे में अधिक पढ़ने के लिए
    # यात्रा: https://collerek.github.io/ormar/queries/select-columns /


एसिंक डिफ पेजिनेशन ():
    # लौटाई गई पंक्तियों की संख्या सीमित करने के लिए उपयोग सीमा ()
    किताबें = प्रतीक्षा करें (1).all ()
    लेन (पुस्तकें) = = 1
    सम्मिलित पुस्तकें [0]। शीर्षक = = "द हॉबिट"

    # लौटाए गए पंक्तियों की ऑफसेट संख्या ऑफसेट () का उपयोग करें
    किताबें = प्रतीक्षा करें (1).offset (1).सभी ()
    लेन (पुस्तकें) = = 1
    सम्मिलित पुस्तकें [0]। शीर्षक = = "द लॉर्ड ऑफ द रिंग्स"

    # वैकल्पिक रूप से पेजिनेट का उपयोग करें जो दोनों को जोड़ती है
    पुस्तकें = प्रतीक्षा करें ।objects.paginate (page = 2, page_size=2).all ()
    लेन (पुस्तकें) = = 2
    # ध्यान दें कि हमने सैपकोव्स्की की एक पुस्तक को हटा दिया ()
    # और सिलमारिलियन को फिर से बनाया - डिफ़ॉल्ट रूप से जब कोई ऑर्डर_बाय सेट नहीं होता है
    प्राथमिक_कुंजी कॉलम द्वारा #ordering प्रकार
    सम्मिलित पुस्तकें [0]। शीर्षक = = "द विचर"
    सम्मिलित पुस्तकें [1] । शीर्षक = = "द सिल्मारिलियन"

    # पेजिनेशन और पंक्तियों की संख्या के बारे में अधिक पढ़ने के लिए
    # यात्रा: https://collerek.github.io/ormar/queries/pagination-and-rows-number /


Ac def एकत्रीकरण ():
    #गिनती:
    2 = = प्रतीक्षा करें or..()

    # मौजूद है
    जोर से इंतजार है .फ़िल्टर (शीर्षक = "द हॉबिट") .()

    # अधिकतम
    1990 का दावा करें = .का इंतजार करें (columns = ["year"])

    # न्यूनतम
    जोर से = = प्रतीक्षा करें (columns = ["year"])

    # औसत
    1964.75 = = का इंतजार करें (columns = ["year"])

    # योग
    7859 = = का इंतजार करेंm (columns = ["year"])

    # एकत्रित कार्यों के बारे में अधिक पढ़ने के लिए
    # यात्रा: https://collerek.github.io/ormar/queries/aggregations /


Ac def raw_data ():
    # डिक्ट्स या ट्यूपल के रूप में कच्चे डेटा को निकालें
    # ध्यान दें कि यह सत्यापन (!) को मॉडल के रूप में छोड़ देता है
    # पार्स किए गए डेटा से नहीं बनाया गया

    # डिक्ट्स के रूप में वस्तुओं की सूची प्राप्त करें
    जोर से प्रतीक्षा करें
        {"id": 1, "author": 1, "title": "The Hobbit", "year": 1937},
        {"id": 2, "author": 1, "title": "The Lord of the Rings", "year": 1955},
        {"id": 4, "author": 2, "title": "The Witcher", "year": 1990},
        {"id": 5, "author": 1, "title": "The Silmarillion", "year": 1977},
    ]

    # ट्यूपल के रूप में वस्तुओं की सूची प्राप्त करें
    जोर से प्रतीक्षा करें Book.objects.values_list () = [
        (1, 1, "द हॉबिट", 1937),
        (2, 1, "द लॉर्ड ऑफ द रिंग्स", 1955),
        (4, 2, "द विचर", 1990),
        (5, 1, "द सिल्मारिलियन", 1977),
    ]

    #filter डेटा - ध्यान दें कि आपको हमेशा एक सूची कैसे मिलती है
    जोर से प्रतीक्षा करें .फ़िल्टर (शीर्षक = "द हॉबिट").मान () =[
        {"id": 1, "author": 1, "title": "The Hobbit", "year": 1937}
    ]

    # केवल वांछित फ़ील्ड का चयन करें
    जोर से प्रतीक्षा करें .फ़िल्टर (शीर्षक = "द हॉबिट").मान (["id", "title "]) = = [
        {"id": 1, "title": "The Hobbit"}
    ]

    # यदि आप केवल एक कॉलम का चयन करते हैं तो आप इसे मान _ सूची के साथ समतल कर सकते हैं
    जोर से प्रतीक्षा करें Book.objects.values_list ("शीर्षक", समतल = सच) == [
        "द हॉबिट",
        "द लॉर्ड ऑफ द रिंग्स",
        "चुड़ैल",
        "द सिल्मारिलियन",
    ]

    # कच्चे मूल्यों को निकालने के बारे में अधिक पढ़ने के लिए
    # यात्रा: https://collerek.github.io/ormar/queries/aggregations /


Ac def with _ कनेक्ट (function):
    # ध्यान दें कि स्क्लाइट की तुलना में किसी अन्य बैकएंड के लिए आपको वास्तव में आवश्यकता है
    # db संचालन करने के लिए डेटाबेस से कनेक्ट करें
    डेटाबेस के साथ एसिंक:
        प्रतीक्षा समारोह ()

    # ध्यान दें कि यदि आप फ्रेमवर्क का उपयोग करते हैं जैसे `fastapi` आपको कनेक्ट नहीं करना चाहिए
    # अपने समापन बिंदुओं में लेकिन एक वैश्विक कनेक्शन पूल है
    # db कनेक्शन के साथ https://collerek.github.io/ormar/fastapi/and अनुभाग की जाँच करें


# सभी कार्यों को इकट्ठा करें और निष्पादित करें
# नोट - सामान्य रूप से आयात फ़ाइल की शुरुआत में होना चाहिए
आयात asyncio

# ध्यान दें कि आम तौर पर आप कई कार्यों को चलाने के लिए इकट्ठा () फ़ंक्शन का उपयोग करते हैं
# समवर्ती रूप से लेकिन हम वास्तव में डेटा को संशोधित करते हैं और हम कार्यों के क्रमबद्ध करना पर भरोसा करते हैं
में दुर्गंध के लिए [
    बनाएं,
    पढ़ना,
    अद्यतन,
    हटाएं,
    शामिल होता है,
    फ़िल्टर _ और _ सॉर्ट करें,
    सबसेट _ ऑफ _ कॉलम,
    पेजिनेशन,
    समूह,
    कच्चा _ डेटा,
]:
    प्रिंट (f "निष्पादन: {func.__name__}")
    asyncio.run (with _ connect (func))

# डेटाबेस तालिकाओं को छोड़ दें
ड्रॉप _ सभी (इंजन)

उमर विनिर्देशों

क्वेरी सेट विधि

• बनाएँ (**Kwargs): -> मॉडल
• get(*args, **kwargs): -> Model
• get_or_none(*args, **kwargs): -> Optional[Model]
• get_or_create(_defaults: Optional[Dict[str, Any]] = None, *args, **kwargs) -> Tuple[Model, bool]
• first(*args, **kwargs): -> Model
• update(each: bool = False, **kwargs) -> int
• update_or_create(**kwargs) -> Model
• bulk_create(objects: List[Model]) -> None
• bulk_update(objects: List[Model], columns: List[str] = None) -> None
• delete(*args, each: bool = False, **kwargs) -> int
• all(*args, **kwargs) -> List[Optional[Model]]
• iterate(*args, **kwargs) -> AsyncGenerator[Model]
• filter(*args, **kwargs) -> QuerySet
• exclude(*args, **kwargs) -> QuerySet
• select_related(related: Union[List, str]) -> QuerySet
• prefetch_related(related: Union[List, str]) -> QuerySet
• limit(limit_count: int) -> QuerySet
• offset(offset: int) -> QuerySet
• count(distinct: bool = True) -> int
• अस्तित्व () -> बूलियन
• max(columns: List[str]) -> Any
• min(columns: List[str]) -> Any
• avg(columns: List[str]) -> Any
• sum(columns: List[str]) -> Any
• fields(columns: Union[List, str, set, dict]) -> QuerySet
• exclude_fields(columns: Union[List, str, set, dict]) -> QuerySet
• order_by(columns:Union[List, str]) -> QuerySet
• values(fields: Union[List, str, Set, Dict])
• values_list(fields: Union[List, str, Set, Dict])

संबंध प्रकार

• एक-से-कई - विदेशी का उपयोग करना (to: Model)
• कई से कई - साथ ManyToMany(to: Model, Optional[through]: Model)

मॉडल फ़ील्ड प्रकार

उपलब्ध नमूना फ़ील्ड (आवश्यक मापदंडों के साथ - दस्तावेज़ में वैकल्पिक):

• स्ट्रिंग (maximum length)
• पाठ ()
• बूलियन ()
• पूर्णांक ()
• फ्लोट ()
• दिनांक ()
• समय ()
• दिनांक समय ()
• JSON()
• बड़ा पूर्णांक ()
• छोटा पूर्णांक ()
• दशमलव (दशमलव स्थानों की संख्या, सटीक)
• UUID()
• बड़े बाइनरी (maximum length)
• गणना (गणना वर्ग)
• फील्ड-जैसी गणना - चयन को किसी अन्य फील्ड प्रकार में पारित करके
• एन्क्रिप्टेड स्ट्रिंग - एन्क्रिप्ट \ _ गुप्त और एन्क्रिप्ट \ _ बैकएंड पास करें
• विदेशी कुंजी (से)
• कई से कई (से)

उपलब्ध क्षेत्र विकल्प

सभी फ़ील्ड प्रकार निम्नलिखित कीवर्ड मापदंडों का समर्थन करते हैं।

• प्राथमिक कुंजी: बूलियन
• अशक्त: बूलियन
• डिफ़ॉल्ट मान: कोई भी
• सर्वर डिफॉल्ट: कोई भी
• सूचकांक: बूलियन
• अद्वितीय: बूलियन
• नाम: str

सभी फ़ील्ड की आवश्यकता होती है जब तक कि निम्नलिखित में से एक सेट न हो:

• Null- एक nullकॉलम बनाएं। डिफ़ॉल्ट को गलत पर सेट करें। अधिक जानकारी के लिए फ़ील्ड सामान्य पैरामीटर पढ़ें।
• SQL \ _ null- pydऔर डेटाबेस के लिए विभिन्न सेटिंग्स सेट करने के लिए उपयोग करें। डिफ़ॉल्ट को नल मान पर सेट करें। विवरण के लिए फ़ील्ड सामान्य पैरामीटर पढ़ें।
• डिफ़ॉल्ट - किसी फ़ील्ड के लिए डिफ़ॉल्ट मान सेट करता है। संबंधपरक फ़ील्ड पर लागू नहीं है
• सर्वर \ _ डिफ़ॉल्ट - सर्वर-साइड फ़ील्ड के लिए डिफ़ॉल्ट मान सेट करता है, जैसे कि func.now () sqlalchके लिए। संबंधपरक फ़ील्ड पर लागू नहीं है
• ऑटो-इन्क्रीमेंट के साथ प्राथमिक कुंजी - जब एक कॉलम को प्राथमिक कुंजी के रूप में सेट किया जाता है और ऑटो-इन्क्रीमेंट उस कॉलम पर सेट किया जाता है। डिफ़ॉल्ट रूप से, int प्राथमिक कुंजी ऑटो-इन्क्रीमेंट सेट करती है।

उपलब्ध संकेत

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

• पूर्व-बचत
• बचाने के बाद
• पूर्व-अद्यतन
• अपडेट के बाद
• प्री-डिलीट
• हटाने के बाद
• पूर्व-संबंध जोड़
• पोस्ट रिलेशनशिप ऐड
• पूर्व-संबंध विलोपन
• रिश्ते मिटाने के बाद