विषय पर बढ़ें

मॉडल

नमूना परिभाषित करें

एक ormar नमूना परिभाषित करके, आप संबंधित dनमूना और Sqlalchतालिका मुफ्त में प्राप्त कर सकते हैं। वे पृष्ठभूमि में प्रबंधित किए जाते हैं और आपको उन्हें स्वयं बनाने की आवश्यकता नहीं है।

मॉडल क्लास

एक ormar नमूना बनाने के लिए, आपको बस ormar विरासत में मिला है। मॉडल वर्ग।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

क्षेत्र को परिभाषित करें

अगला, एक या अधिक फ़ील्ड को वर्ग-स्तरीय चर के रूप में सौंपा गया है।

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

प्रत्येक तालिका में एक प्राथमिक कुंजी स्तंभ होना चाहिए, जिसे आप चयनित फ़ील्ड पर प्राथमिक \ _ कुंजी = सत्य सेट करके निर्दिष्ट कर सकते हैं।

केवल एक प्राथमिक कुंजी कॉलम की अनुमति है।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

!!!चेतावनी, प्राथमिक \ _ कुंजी स्तंभों को आवंटित नहीं करना या से अधिक एक स्तंभ प्रति नमूना आवंटित करना अपवाद ModelDefinitionError फेंक देगा।

डिफ़ॉल्ट रूप से, ऑटो-इंक्रीमेंट विकल्प सही पर सेट है यदि प्राथमिक कुंजी एक पूर्णांक फ़ील्ड को असाइन की गई है।

आप ऑटोइन्क्रिमेंट = गलत पास करके इसे अक्षम कर सकते हैं।

1
आईडी: int = ormar। पूर्णांक (प्राथमिक_key = सही, ऑटोइन्क्रिमेंट = गलत)

गैर-डेटाबेस फ़ील्ड

कृपया ध्यान दें कि यदि आपको अपने नमूना में एक सामान्य dफ़ील्ड की आवश्यकता है नमूना पर मान संग्रहीत करने या कुछ मान पारित करने के लिए), तो आप हमेशा की तरह dमें एक फ़ील्ड को परिभाषित कर सकते हैं।

इस तरह से बनाए गए फ़ील्ड को pydनमूना फ़ील्ड में जोड़ा जाता है -> इसलिए फ़ील्ड प्रकार के आधार पर मान्य किया जाता है और नमूना में भी दिखाई देता है \ _ () और नमूना \ _ डंप \ _ json () परिणाम।

अंतर यह है कि ये फ़ील्ड डेटाबेस में सहेजे नहीं गए हैं। इसलिए वे अंतर्निहित SQL कीमिया कॉलम या टेबल चर में शामिल नहीं हैं (यदि आवश्यक हो तो इन तक पहुंचने का तरीका जानने के लिए नीचे दिए गए आंतरिक अनुभाग की जांच करें)।

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

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

!!! चेतावनी pydफ़ील्ड हमेशा वैकल्पिक होना चाहिए और इसे बदला नहीं जा सकता है (अन्यथा डेटाबेस लोड सत्यापन विफल हो जाएगा)।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
import databases
import ormar
import pydantic
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)
    non_db_field: str = pydantic.Field(max_length=100)

यदि आप डिफ़ॉल्ट मापदंडों के साथ pydफ़ील्ड सेट करते हैं और अनुरोध में वास्तविक मान पास नहीं करते हैं, तो आपको हमेशा डिफ़ॉल्ट मान मिलेगा। चूंकि यह एक फ़ंक्शन हो सकता है, आप डिफ़ॉल्ट = datetime.datetime.now सेट कर सकते हैं और हर बार जब आप समापन बिंदु आदि को कॉल करते हैं तो वर्तमान टाइमस्टैम्प प्राप्त कर सकते हैं।

Fमें गैर-डेटाबेस फ़ील्ड

ध्यान दें कि दोनों pydऔर गणना की गई \ _ फ़ील्ड संशोधक फ़ील्ड को नमूना \ _ डंप () और फास्टापी प्रतिक्रियाओं में शामिल / बहिष्कृत किया जा सकता है, इसी समावेश / बहिष्करण और प्रतिक्रिया के साथ \ _ मॉडल \ _ शामिल / प्रतिक्रिया \ _ मॉडल \ _ बहिष्कार।

 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
# <= स्पष्टता के लिए हटाए गए संबंधित कोड का हिस्सा ~~>
base_ormar_config = ormar। marConfig (
    डेटाबेस = डेटाबेस। डेटाबेस (DATABASE_URL),
    मेटाडेटा = वर्गधर्मी। मेटाडेटा (),
    इंजन = sqlal (DATABASE_URL),
)


कक्षा उपयोगकर्ता (ormar. Model):
    ormar_config = आधार_ormar_config (tablename = "users2")

    आईडी: int = ormar। पूर्णांक (primary_key = True)
    ईमेल: str = ormar। स्ट्रिंग (max_length = 255, null= गलत)
    पासवर्ड: str = ormar। स्ट्रिंग (max_length = 255)
    पहला_नाम: str = ormar। स्ट्रिंग (max_length = 255)
    last_name: str = ormar। स्ट्रिंग (max_length = 255)
    श्रेणी: str = ormar। स्ट्रिंग (max_length = 255, null= True)
    टाइमस्टैंप: date.datetime = pydantic। फील्ड (
        डिफ़ॉल्ट = datetime.datetime.now
    )

# <= स्पष्टता के लिए हटाए गए संबंधित कोड का हिस्सा ~~>
ऐप = F()

@ app.post ("/users/")
Ac def create_user (user: User):
    वापसी user.save ()

# <= स्पष्टता के लिए हटाए गए संबंधित कोड का हिस्सा ~~>

Dपरीक्षण _ को छोड़कर _ फ़ील्ड _ इन _ एंडपॉइंट्स ():
    क्लाइंट = टेस्टक्लाइंट (ऐप)
    ग्राहकों के रूप में ग्राहकों के साथ:
        टाइमस्टैम्प = datetime.datetime.now ()

        उपयोगकर्ता = {
            "ईमेल": test@domain.com
            "पासवर्ड": "^*^% A** IAAA",
            "पहला_नाम": "जॉन",
            "अंतिम_नाम": "डो",
            "टाइमस्टैम्प": str (timestamp),
        }
        प्रतिक्रिया = client.post ("/ उपयोगकर्ता /", json = उपयोगकर्ता)
        सूची डालें (response.json ().चाबियाँ ()) = [
            "आईडी",
            "ईमेल",
            "पहला नाम",
            "अंतिम नाम",
            "श्रेणी",
            "टाइमस्टैम्प",
        ]
        # लौटा वही टाइमस्टैम्प है
        प्रतिक्रिया दें। json ().get ("timestam") == str (timestam). (" ", " T ")


# <= स्पष्टता के लिए हटाए गए संबंधित कोड का हिस्सा ~~>

फ़ील्ड नाम और स्तंभ नाम

डिफ़ॉल्ट फ़ील्ड नामों का उपयोग अंतर्निहित dऔर नमूना और SQL कीमिया तालिकाओं के लिए किया जाता है।

यदि किसी कारण से आप डेटाबेस में नाम बदलना चाहते हैं, लेकिन नमूना में नाम छोड़ दें, तो आप फ़ील्ड घोषणा के दौरान नाम पैरामीटर निर्दिष्ट करके ऐसा कर सकते हैं

यहाँ एक बदले हुए नाम नमूना एक उदाहरण है

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
import databases
import ormar
import sqlalchemy

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

database = databases.Database(DATABASE_URl, force_rollback=True)
metadata = sqlalchemy.MetaData()


class Child(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        tablename="children",
    )

    id: int = ormar.Integer(name="child_id", primary_key=True)
    first_name: str = ormar.String(name="fname", max_length=100)
    last_name: str = ormar.String(name="lname", max_length=100)
    born_year: int = ormar.Integer(name="year_born", nullable=True)

कृपया ध्यान दें कि आप विदेशी कुंजी स्तंभ नाम भी बदल सकते हैं

 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
from typing import Optional

import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///test.db", force_rollback=True)
metadata = sqlalchemy.MetaData()


class Artist(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        tablename="artists",
    )

    id: int = ormar.Integer(name="artist_id", primary_key=True)
    first_name: str = ormar.String(name="fname", max_length=100)
    last_name: str = ormar.String(name="lname", max_length=100)
    born_year: int = ormar.Integer(name="year")


class Album(ormar.Model):

    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        tablename="music_albums",
    )

    id: int = ormar.Integer(name="album_id", primary_key=True)
    name: str = ormar.String(name="album_name", max_length=100)
    artist: Optional[Artist] = ormar.ForeignKey(Artist, name="artist_id")

लेकिन वर्तमान में आप MToकॉलम नाम नहीं बदल सकते क्योंकि वे वैसे भी अन्य मॉडलों से गुजरेंगे।

 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
import databases
import ormar
import sqlalchemy

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

database = databases.Database(DATABASE_URl, force_rollback=True)
metadata = sqlalchemy.MetaData()


class Child(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        tablename="children",
    )

    id: int = ormar.Integer(name="child_id", primary_key=True)
    first_name: str = ormar.String(name="fname", max_length=100)
    last_name: str = ormar.String(name="lname", max_length=100)
    born_year: int = ormar.Integer(name="year_born", nullable=True)


class ArtistChildren(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        tablename="children_x_artists",
    )


class Artist(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        tablename="artists",
    )

    id: int = ormar.Integer(name="artist_id", primary_key=True)
    first_name: str = ormar.String(name="fname", max_length=100)
    last_name: str = ormar.String(name="lname", max_length=100)
    born_year: int = ormar.Integer(name="year")
    children = ormar.ManyToMany(Child, through=ArtistChildren)

डिफ़ॉल्ट क्वेरी सेट को ओवरराइड करें

यदि आप उन प्रश्नों को अनुकूलित करना चाहते हैं जो mar चलाता है, तो आप मॉडल वर्ग में अपने स्वयं के क्वेरी सेट वर्ग (extending Ormar QuerySet) को परिभाषित कर सकते हैं, जो डिफ़ॉल्ट क्वेरीसेट है।

आप कक्षा के ormar \ _ config में एक yset \ _ वर्ग तर्क के रूप में एक नया वर्ग प्रदान कर सकते हैं।

 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.y.yset से Queryआयात करें
HTTPसे आयात किया गया अपवाद


क्लास Queryवर्ग (QuerySet):

    Ac def पहले_or_404 (स्व, * args, ** kwargs):
        इकाई = स्वयं का इंतजार करें। get_or_none (* args, ** kwargs)
        यदि इकाई कोई नहीं है:
            # फास्टापी या स्टारलेट में
            HTTPउठाएँ (404)


क्लास बुक (ormar. Model):
    ormar _ config = आधार _ ormar _ config कॉपी (
        class=MyQuerySetClass
        टेबलनाम = "पुस्तक",
    )

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


# जब किताबें नहीं मिलीं, तो उठाया `404` आपके विचार में।
पुस्तक = प्रतीक्षा करें (name = "123")

संकेत टाइप करें

कृपया ध्यान दें कि बेहतर IDE समर्थन और pyजाँच के लिए, आप प्रकार संकेत प्रदान कर सकते हैं।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

कृपया ध्यान दें कि प्रकार संकेत वैकल्पिक है, इसलिए पूरी तरह से मान्य ormar कोड इस तरह दिख सकता है:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
    )

    id = ormar.Integer(primary_key=True)
    name = ormar.String(max_length=100)
    completed = ormar.Boolean(default=False)

!!!चेतावनी: यहां तक कि अगर आप प्रकार के संकेत का उपयोग करते हैं, तो ormar उन्हें dफ़ील्ड बनाने के लिए उपयोग नहीं करेगा!

1
2
टाइप संकेत केवल स्थिर चेकर्स और लिंटिंग का समर्थन करने के लिए हैं,
`ormar` द्वारा उपयोग किए जाने वाले एनोटेशन का निर्माण करें `pydantic` अपने खेतों से।

निर्भरता

चूंकि ormar डेटाबेस और sqlalchemistry-core पर निर्भर करता है डेटाबेस जॉइन और टेबल निर्माण के लिए, आपको प्रत्येक नमूना के लिए दो विशेष पैरामीटर असाइन करने की आवश्यकता है।

डेटाबेस

एक एक डेटाबेस उदाहरण है जो sqlalchकनेक्शन स्ट्रिंग प्रारूप में डेटाबेस का उपयोग करके बनाया गया है।

बनाए गए उदाहरण को प्रत्येक नमूना को दिए गए ormar \ _ config ऑब्जेक्ट डेटाबेस मापदंडों का उपयोग करने की आवश्यकता है।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

!!!युक्ति, आपको केवल एक बार डेटाबेस उदाहरण बनाने और सभी मॉडल के लिए इसका उपयोग करने की आवश्यकता है। यदि आप कई डेटाबेस का उपयोग करना चाहते हैं, तो आप कई डेटाबेस बना सकते हैं।

कीमिया

दूसरी निर्भरता वर्गचिकित्सा मेटाडेटा उदाहरण है।

बनाया गया उदाहरण ormar \ _ config ऑब्जेक्ट मेटाडेटा पैरामीटर का उपयोग करके प्रत्येक नमूना पास करने की आवश्यकता है।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

!!!युक्ति, आपको केवल एक बार मेटाडेटा उदाहरण बनाने और सभी मॉडलों के लिए इसका उपयोग करने की आवश्यकता है। यदि आप कई डेटाबेस का उपयोग करना चाहते हैं, तो आप कई डेटाबेस बना सकते हैं।

सर्वोत्तम प्रथाओं

ध्यान दें कि ormar को ormar \ _ config नाम के क्षेत्र की आवश्यकता होती है, जो marConfig वर्ग का एक उदाहरण है। कॉन्फ़िगरेशन प्रबंधन को सरल बनाने के लिए, marConfig वर्ग प्रतिकृति विधियां प्रदान करता है। इसलिए, आपको एक आधार ऑब्जेक्ट बनाना चाहिए और सभी मॉडलों में इसकी प्रतियों का उपयोग करना चाहिए, बजाय सभी मॉडलों को बार-बार समान पैरामीटर प्रदान करने के।

 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
from typing import Optional

import databases
import ormar
import sqlalchemy

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

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


class Artist(ormar.Model):
    # note that tablename is optional
    # if not provided ormar will user class.__name__.lower()+'s'
    # -> artists in this example
    ormar_config = ormar_base_config.copy()

    id: int = ormar.Integer(primary_key=True)
    first_name: str = ormar.String(max_length=100)
    last_name: str = ormar.String(max_length=100)
    born_year: int = ormar.Integer(name="year")


class Album(ormar.Model):
    ormar_config = ormar_base_config.copy()

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    artist: Optional[Artist] = ormar.ForeignKey(Artist)

तालिका का नाम

डिफ़ॉल्ट रूप से, तालिका नाम नमूना वर्ग नाम से बनाए जाते हैं, अर्थात्, लोअरकेस नाम प्लस "s।"

आप ormar \ _ config ऑब्जेक्ट के लिए तालिका नाम पैरामीटर प्रदान करके इस पैरामीटर को ओवरराइड कर सकते हैं।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):

    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        # if you omit this parameter it will be created automatically
        # as class.__name__.lower()+'s' -> "courses" in this example
        tablename="my_courses",
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

बाधा

नमूना स्तर पर, आप SQL स्तंभों पर नमूना बाधाओं को भी सेट कर सकते हैं।

वर्तमान में केवल IndexColuns, Uniऔर kबाधाओं का समर्थन किया जाता है।

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

!!!टिप प्राथमिक कुंजी, अद्वितीय कुंजी, विदेशी कुंजी, और अधिक के लिए स्तंभ बाधाओं के बारे में अधिक जानने के लिए, फील्ड्स पर जाएं।

अद्वितीय स्तंभ

आप ormar \ _ config ऑब्जेक्ट बाधा पैरामीटर प्रदान करके इस पैरामीटर को सेट कर सकते हैं।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        # define your constraints in OrmarConfig of the model
        # it's a list that can contain multiple constraints
        # hera a combination of name and column will have to be unique in db
        constraints=[ormar.UniqueColumns("name", "completed")],
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

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

सूचकांक स्तंभ

आप ormar \ _ config ऑब्जेक्ट बाधा पैरामीटर प्रदान करके इस पैरामीटर को सेट कर सकते हैं।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        # define your constraints in OrmarConfig of the model
        # it's a list that can contain multiple constraints
        # hera a combination of name and column will have a compound index in the db
        constraints=[ormar.IndexColumns("name", "completed")],
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

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

कॉलम की जाँच करें

आप ormar \ _ config ऑब्जेक्ट बाधा पैरामीटर प्रदान करके इस पैरामीटर को सेट कर सकते हैं।

 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
import datetime

import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        # define your constraints in OrmarConfig of the model
        # it's a list that can contain multiple constraints
        # hera a combination of name and column will have a level check in the db
        constraints=[
            ormar.CheckColumns("start_time < end_time", name="date_check"),
        ],
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    start_date: datetime.date = ormar.Date()
    end_date: datetime.date = ormar.Date()

!!!ध्यान दें कि कुछ डेटाबेस सक्रिय रूप से जाँच बाधाओं का समर्थन नहीं करते हैं (e.g. MySQL).

ब्रैकट संरचना

प्रत्येक ormar के बाद से। मॉडल भी एक pydनमूना है, आपको अपने pydकॉन्फ़िगरेशन की सेटिंग्स को समायोजित करने की आवश्यकता हो सकती है।

pydमें ऐसा करने का तरीका नमूना पर सेटिंग्स को समायोजित करना है \ _ config शब्दकोश जो नमूना को प्रदान किया जाता है, जो ormar मॉडल के लिए बिल्कुल उसी तरह काम करता है।

तो क्रमबद्ध करना अपनी प्राथमिकताएं सेट करने के लिए, आपको नमूना न केवल ormar \ _ config वर्ग के साथ, बल्कि नमूना \ _ config = Cont () वर्ग के साथ भी आपूर्ति करने की आवश्यकता है।

!!!नोट उपलब्ध सेटिंग्स के बारे में अधिक जानने के लिए, dकॉन्फ़िगरेशन पृष्ठ पर जाएँ।

कृपया ध्यान दें कि यदि आप अपना स्वयं का कॉन्फ़िगरेशन प्रदान नहीं करते हैं, तो ormar आपके लिए करेगा। प्रदान किया गया डिफ़ॉल्ट कॉन्फ़िगरेशन इस प्रकार है:

1
model_config = Cont (validate_assion= True, ser_json_bytes = "base64")

इसलिए, सेटिंग्स को ओवरराइड करने या नमूना अपना स्वयं का उदाहरण प्रदान करने के लिए, इस तरह देखें:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
import databases
import ormar
import pydantic
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
    )

    model_config = pydantic.ConfigDict(frozen=True)

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

नमूना में अतिरिक्त क्षेत्र

डिफ़ॉल्ट रूप से, मार आपको अतिरिक्त फ़ील्ड को नमूना पास करने से मना करता है।

यदि आप ऐसा करने का प्रयास करते हैं, तो एक Moउठाया जाएगा।

चूंकि अतिरिक्त फ़ील्ड को डेटाबेस में सहेजा नहीं जा सकता है, ऐसे फ़ील्ड को डिफ़ॉल्ट रूप से अक्षम करना एक व्यवहार्य विकल्प की तरह लगता है।

इसके बजाय, pydantic में, डिफ़ॉल्ट विकल्प इस तरह के अतिरिक्त क्षेत्रों को अनदेखा करना है, इसलिए ormar उसी तरह से काम करने के लिए ormar \ _ config अतिरिक्त सेटिंग प्रदान करता है।

ormar को दिए गए अतिरिक्त फ़ील्ड को अनदेखा करने के लिए, इस सेटिंग को डिफ़ॉल्ट Extra.forके बजाय Extra.पर सेट करें।

कृपया ध्यान दें कि ormar अतिरिक्त फ़ील्ड को स्वीकार करने की अनुमति नहीं देता है। आप केवल उन्हें अनदेखा कर सकते हैं या उन्हें अक्षम कर सकते हैं (यदि मौजूद हो तो एक अपवाद फेंक दें)।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
Ormar, marConfig से अतिरिक्त आयात

कक्षा का बच्चा (ormar. Model):
    ormar_config = marConfig (
        टेबलनाम = "बच्चे",
        अतिरिक्त = अतिरिक्त फ़ील्ड उपस्थिति पर अपवादों को रोकने के लिए अतिरिक्त सेटिंग्स सेट करें
    )

    आईडी: int = ormar। पूर्णांक (name = "child_id", primary_key = True)
    पहला _ नाम: str = ormar। स्ट्रिंग (नाम = "fname", max_length = 100)
    अंतिम _ नाम: str = ormar। स्ट्रिंग (नाम = "lname", max_length = 100)

सभी मॉडलों पर समान सेटिंग्स सेट करने के लिए, सर्वोत्तम प्रथाओं और आधार \ _ ormar \ _ config अवधारणाओं की जांच करें।

मॉडल छँटाई

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

डिफ़ॉल्ट सॉर्ट उदाहरण (अनिर्दिष्ट - इसलिए प्राथमिक कुंजी द्वारा निर्दिष्ट):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
base_ormar_config = ormar। marConfig (
    डेटाबेस = डेटाबेस। डेटाबेस (DATABASE_URL),
    मेटाडेटा = वर्गधर्मी। मेटाडेटा (),
)


कॉलम आईडी आरोही द्वारा # डिफ़ॉल्ट सॉर्ट
कक्षा लेखक (ormar. Model):
    ormar _ config = आधार _ ormar _ config कॉपी (
        टेबलनाम = "लेखक",
    )

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

संशोधित

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
base_ormar_config = ormar। marConfig (
    डेटाबेस = डेटाबेस। डेटाबेस (DATABASE_URL),
    मेटाडेटा = वर्गधर्मी। मेटाडेटा (),
)

# अब डिफ़ॉल्ट सॉर्ट नाम अवरोही द्वारा
कक्षा लेखक (ormar. Model):
    ormar _ config = आधार _ ormar _ config कॉपी (
        आदेश_बाय = ["-नाम"],
        टेबलनाम = "लेखक",
    )

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

नमूना

डेटाबेस में नमूना उदाहरणों को बनाने और सहेजने के दो तरीके हैं।

यदि आप प्रोग्राम निष्पादित होने पर बाद में उदाहरण को संशोधित करने की योजना बनाते हैं, तो आप नमूना को एक सामान्य वर्ग के रूप में शुरू कर सकते हैं और सहेजें () कॉल की प्रतीक्षा कर सकते हैं।

 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
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 Course(ormar.Model):
    ormar_config = ormar_base_config.copy(tablename="courses")

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)


@create_drop_database(base_config=ormar_base_config)
async def run_query():
    course = Course(name="Painting for dummies", completed=False)
    await course.save()

    await Course.objects.create(name="Painting for dummies", completed=False)


asyncio.run(run_query())

यदि आप नमूना शुरू करना चाहते हैं और इसे एक ही समय में डेटाबेस में सहेजना चाहते हैं, तो Queryविधि बनाएँ () का उपयोग करें।

एक बार में कई ऑब्जेक्ट बनाने के लिए, बल्क \ _ बनाएँ () Queryविधि का उपयोग करें।

प्रत्येक नमूना में ऑब्जेक्ट मापदंडों के रूप में प्रारंभ किए गए प्रश्नों का एक सेट होता है

 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
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 Course(ormar.Model):
    ormar_config = ormar_base_config.copy(tablename="courses")

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)


@create_drop_database(base_config=ormar_base_config)
async def run_query():
    course = Course(name="Painting for dummies", completed=False)
    await course.save()

    await Course.objects.create(name="Painting for dummies", completed=False)


asyncio.run(run_query())

!!!जानकारी क्वेरी सेट (थोक संचालन सहित) और उपलब्ध तरीकों के बारे में अधिक जानने के लिए, क्वेरी पर जाएं

नमूना राज्य बचाओ

प्रत्येक नमूना एक अलग पायथन वस्तु है जो एक दूसरे के बारे में कुछ नहीं जानती है।

1
2
3
4
5
6
7
8
Tr1 = Tr.का इंतजार करें (name = 'The Bird')
Tr2 = Tr.का इंतजार करें (name = 'The Bird')
ट्रैक 1 = = ट्रैक 2 # ट्रू डालें

track1.name = 'द बर्ड 2'
प्रतीक्षा track1.save ()
track1.name track2.name
# tr2 अपडेट नहीं करता है और tr1 के बारे में कुछ नहीं जानता है

ऑब्जेक्ट में स्वयं एक सहेजी गई स्थिति है, जो निम्नानुसार सेट है:

  • इंटरनेट पर सम्मिलन विधि को सहेजने / अपडेट करने / लोड करने / अपडेट करने के बाद नमूना नमूना पर सम्मिलन विधि को सहेजने / अपडेट करने / लोड करने / अपडेट करने के बाद छवि सहेजें
  • नमूना के बाद create/get/first/all/get_or_create/update_or_create विधि
  • मॉडल सहेजे जाते हैं जब थोक \ _ अद्यतन और थोक \ _ बनाने के लिए पारित किया जाता है
  • कई Toसंबंधित वस्तुओं को जोड़ने / हटाने के बाद नमूना सहेजें (स्वचालित रूप से सहेजें / नमूना उदाहरण के माध्यम से हटाएं)
  • नमूना अपने स्वयं के किसी भी क्षेत्र को बदलने के बाद सहेजा नहीं जाता है (एक Model.pk उपनाम के रूप में पीके सहित)
  • से संबंधित वस्तुओं को जोड़ने/हटाने के बाद मॉडल सहेजा नहीं गया (fk column not saved)
  • उपयोग __इनिट _\ _ इंस्टेंटेशन के बाद नमूना को न सहेजें (QuerySet.का उपयोग किए बिना या कॉल करने से पहले)

आप यह जांचने के लिए Mo.संपत्ति का उपयोग कर सकते हैं कि क्या नमूना सहेजा गया है