स्तंभों का सबसेट चुनें

नमूना में केवल चयनित स्तंभों का चयन करने के लिए, आप निम्न फ़ंक्शन का उपयोग कर सकते हैं।

• fields(columns: Union[List, str, set, dict]) -> QuerySet

• exclude_fields(columns: Union[List, str, set, dict]) -> QuerySet

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

  • QuerysetProxy.fields(columns: Union[List, str, set, dict]) विधि
  • QuerysetProxy.exclude_fields(columns: Union[List, str, set, dict]) विधि

क्षेत्र

fields(columns: Union[List, str, set, dict]) -> QuerySet

फ़ील्ड () के साथ, आप डेटा लोड को सीमित करने के लिए नमूना स्तंभों का सबसेट चुन सकते हैं।

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

निम्नलिखित उदाहरण डेटा दिया गया है:

import asyncio

import databases
import ormar
import sqlalchemy
from examples import create_drop_database
from tests.settings import DATABASE_URL

base_ormar_config = ormar.OrmarConfig(
    database=databases.Database(DATABASE_URL, force_rollback=True),
    metadata=sqlalchemy.MetaData(),
)


class Company(ormar.Model):
    ormar_config = base_ormar_config.copy(tablename="companies")

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


class Car(ormar.Model):
    ormar_config = base_ormar_config.copy()

    id: int = ormar.Integer(primary_key=True)
    manufacturer = ormar.ForeignKey(Company)
    name: str = ormar.String(max_length=100)
    year: int = ormar.Integer(nullable=True)
    gearbox_type: str = ormar.String(max_length=20, nullable=True)
    gears: int = ormar.Integer(nullable=True)
    aircon_type: str = ormar.String(max_length=20, nullable=True)


@create_drop_database(base_config=base_ormar_config)
async def sample_data():
    # build some sample data
    toyota = await Company.objects.create(name="Toyota", founded=1937)
    await Car.objects.create(
        manufacturer=toyota,
        name="Corolla",
        year=2020,
        gearbox_type="Manual",
        gears=5,
        aircon_type="Manual",
    )
    await Car.objects.create(
        manufacturer=toyota,
        name="Yaris",
        year=2019,
        gearbox_type="Manual",
        gears=5,
        aircon_type="Manual",
    )
    await Car.objects.create(
        manufacturer=toyota,
        name="Supreme",
        year=2020,
        gearbox_type="Auto",
        gears=6,
        aircon_type="Auto",
    )


asyncio.run(sample_data())

आप एक पास करके एक निर्दिष्ट फ़ील्ड का चयन कर सकते हैं str, List[str], Set[str] or dict नेस्टेड परिभाषाएँ हैं।

संबंधित मॉडल शामिल करने के लिए, प्रतीकों का उपयोग करें {related_name}__{column}[__{optional_next} etc.] ...

all_cars = प्रतीक्षा करें (
    .
    । चयन _ संबंधित ('निर्माता')
    । फील्ड्स (['आईडी', 'नाम', 'निर्माता __ नाम'])
    । सभी ()
)
सभी कारों में कार के लिए:
    # बहिष्कृत कॉलम कोई नहीं मिलेगा
    सभी पर जोर दें (getattr (car, x) ['वर्ष', 'गियरबॉक्स _ प्रकार', 'गियर', 'एयरकॉन _ प्रकार'] में x के लिए कोई नहीं है)
    संबंधित मॉडल पर # शामिल कॉलम उपलब्ध होगा, पीके कॉलम हमेशा शामिल होता है
    # भले ही आप इसे फ़ील्ड सूची में शामिल न करें
    car.manufacturer.name
    # नेस्टेड संबंधित मॉडल में भी - आप pk को बाहर नहीं कर सकते - यह हमेशा ऑटो जोड़ा जाता है
    Assert car.ture.कोई नहीं है

फील्ड्स () को चयनित किए जाने वाले स्तंभों के निर्माण के लिए कई बार बुलाया जा सकता है।

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

• इन नेस्टेड मॉडल के सभी क्षेत्रों की एक सूची का मतलब है।

  all_cars = प्रतीक्षा करें ( . । चयन _ संबंधित ('निर्माता') । फील्ड्स ('id') । फील्ड्स (['name']) । सभी () )

  कंपनी नमूना से सभी फ़ील्ड चयनित हैं

  All_cars [0] manufacturer.name all_cars [0] .er.= = पर जोर दें

!!! चेतावनी एक अनिवार्य फ़ील्ड को बाहर नहीं कर सकती क्योंकि यह एक Validationउठाता है और फ़ील्ड को बाहर करने के लिए खाली होना चाहिए।

`values()` विधि का उपयोग अनिवार्य क्षेत्रों को बाहर करने के लिए किया जा सकता है, हालांकि डेटा होगा
एक के रूप में लौटाया जाए `dict` हाँ।

आप इस उदाहरण में अनिवार्य नमूना संख्या कॉलम - निर्माता को बाहर नहीं कर सकते।__नाम।

प्रतीक्षा)
    .
    । चयन _ संबंधित ('निर्माता')
    । फील्ड्स (['आईडी', 'नाम', 'निर्माता __ स्थापित'])
    । सभी ()
)
#will पाइडेंटिक वैलिडेशनएरर बढ़ाएं क्योंकि company.name आवश्यक है

!!!टिप पीके कॉलम को बाहर नहीं किया जा सकता है - यह हमेशा स्वचालित रूप से जोड़ा जाता है, भले ही यह स्पष्ट रूप से शामिल न हो।

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

शब्दकोश में शामिल करने के लिए किसी फ़ील्ड को चिह्नित करने के लिए, कुंजी के रूप में इसके नाम और मान के रूप में एक दीर्घवृत्त का उपयोग करें।

नेस्टेड नमूना को पार करने के लिए, नेस्टेड शब्दकोश का उपयोग करें।

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

संपूर्ण नेस्टेड नमूना शामिल करने के लिए, नमूना से जुड़े फ़ील्ड नाम और दीर्घवृत्त निर्दिष्ट करें।

आप नीचे एक समान उदाहरण देख सकते हैं:

#1। ऊपर दिए गए उदाहरण की तरह
प्रतीक्षा)
    .
    । चयन _ संबंधित ('निर्माता')
    । फील्ड्स (['आईडी', 'नाम', 'निर्माता __ नाम'])
    । सभी ()
)

# 2। दीर्घवृत्त का उपयोग करके आवश्यक रूप से एक क्षेत्र को चिह्नित करने के लिए
प्रतीक्षा)
    .
    । चयन _ संबंधित ('निर्माता')
    । फील्ड्स ({'आईडी': ...,
             'नाम': ...,
             'निर्माता': {
                 'नाम': ...
                }
             })
    । सभी ()
)

# 3. दीर्घवृत्त का उपयोग करके पूरे नेस्टेड मॉडल को शामिल करना
प्रतीक्षा)
    .
    । चयन _ संबंधित ('निर्माता')
    । फील्ड्स ({'आईडी': ...,
             'नाम': ...,
             'निर्माता': ...
             })
    । सभी ()
)

# 4. अंतिम घोंसले के स्तर पर फ़ील्ड निर्दिष्ट करने के लिए
# आप सेट का भी उपयोग कर सकते हैं - ऊपर 2 के बराबर
प्रतीक्षा)
    .
    । चयन _ संबंधित ('निर्माता')
    । फील्ड्स ({'आईडी': ...,
             'नाम': ...,
             'निर्माता': {'name'}
             })
    । सभी ()
)

# 5। बेशक सेट में कई फ़ील्ड हो सकते हैं
प्रतीक्षा)
    .
    । चयन _ संबंधित ('निर्माता')
    । फील्ड्स ({'आईडी': ...,
             'नाम': ...,
             'निर्माता': {'name', 'founded'}
             })
    । सभी ()
)

# 6. आप सभी नेस्टेड फ़ील्ड शामिल कर सकते हैं,
# लेकिन यह 3 के बराबर होगा। ऊपर जो छोटा है
प्रतीक्षा)
    .
    । चयन _ संबंधित ('निर्माता')
    । फील्ड्स ({'आईडी': ...,
             'नाम': ...,
             'निर्माता': {'id', 'name', 'founded'}
             })
    । सभी ()
)

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

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

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

बहिष्करण क्षेत्र

exclude_fields(columns: Union[List, str, set, dict]) -> QuerySet

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

यह फ़ील्ड () विधि के विपरीत है, इसलिए उपलब्ध विकल्पों को देखने के लिए ऊपर दिए गए प्रलेखन की जांच करें।

विशेष रूप से, जांचें कि पूरे पदानुक्रम से फ़ील्ड को बाहर करने के लिए नेस्टेड शब्दकोश और संग्रह मास्क के रूप में कैसे पारित किए जाते हैं।

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

आप नीचे कुछ सरल उदाहरण पा सकते हैं:

import asyncio

import databases
import ormar
import sqlalchemy
from examples import create_drop_database
from tests.settings import DATABASE_URL

base_ormar_config = ormar.OrmarConfig(
    database=databases.Database(DATABASE_URL, force_rollback=True),
    metadata=sqlalchemy.MetaData(),
)


class Company(ormar.Model):
    ormar_config = base_ormar_config.copy(tablename="companies")

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


class Car(ormar.Model):
    ormar_config = base_ormar_config.copy()

    id: int = ormar.Integer(primary_key=True)
    manufacturer = ormar.ForeignKey(Company)
    name: str = ormar.String(max_length=100)
    year: int = ormar.Integer(nullable=True)
    gearbox_type: str = ormar.String(max_length=20, nullable=True)
    gears: int = ormar.Integer(nullable=True)
    aircon_type: str = ormar.String(max_length=20, nullable=True)


@create_drop_database(base_config=base_ormar_config)
async def sample_data():
    # build some sample data
    toyota = await Company.objects.create(name="Toyota", founded=1937)
    await Car.objects.create(
        manufacturer=toyota,
        name="Corolla",
        year=2020,
        gearbox_type="Manual",
        gears=5,
        aircon_type="Manual",
    )
    await Car.objects.create(
        manufacturer=toyota,
        name="Yaris",
        year=2019,
        gearbox_type="Manual",
        gears=5,
        aircon_type="Manual",
    )
    await Car.objects.create(
        manufacturer=toyota,
        name="Supreme",
        year=2020,
        gearbox_type="Auto",
        gears=6,
        aircon_type="Auto",
    )


asyncio.run(sample_data())


# select manufacturer but only name,
# to include related models use notation {model_name}__{column}
all_cars = await (
    Car.objects
    .select_related('manufacturer')
    .exclude_fields([
        'year',
        'gearbox_type',
        'gears',
        'aircon_type',
        'company__founded'
    ])
    .all()
)
for car in all_cars:
    # excluded columns will yield None
    assert all(getattr(car, x) is None
               for x in [
                   'year',
                   'gearbox_type',
                   'gears',
                   'aircon_type'
               ])
    # included column on related models will be available,
    # pk column is always included
    # even if you do not include it in fields list
    assert car.manufacturer.name == 'Toyota'
    # also in the nested related models,
    # you cannot exclude pk - it's always auto added
    assert car.manufacturer.founded is None

# fields() can be called several times,
# building up the columns to select
# models included in select_related 
# but with no columns in fields list implies all fields
all_cars = await (
    Car.objects
    .select_related('manufacturer')
    .exclude_fields('year')
    .exclude_fields(['gear', 'gearbox_type'])
    .all()
)
# all fields from company model are selected
assert all_cars[0].manufacturer.name == 'Toyota'
assert all_cars[0].manufacturer.founded == 1937

# cannot exclude mandatory model columns,
# company__name in this example - note usage of dict/set this time
await (
    Car.objects
    .select_related('manufacturer')
    .exclude_fields([{'company': {'name'}}])
    .all()
)
# will raise pydantic ValidationError as company.name is required

!!!चेतावनी, अनिवार्य फ़ील्ड को बाहर नहीं किया जा सकता क्योंकि यह एक Validationउठाता है। किसी फ़ील्ड को बाहर करने के लिए, यह अशक्त होना चाहिए।

`values()` विधि का उपयोग अनिवार्य क्षेत्रों को बाहर करने के लिए किया जा सकता है, हालांकि डेटा होगा
एक के रूप में लौटाया जाए `dict` हाँ।

!!! टिप दें कि Pk कॉलम को बाहर नहीं किया जा सकता है - भले ही इसे स्पष्ट रूप से बाहर रखा गया हो, इसे हमेशा स्वचालित रूप से जोड़ा जाएगा।

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

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

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

QueryProविधि

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

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

क्षेत्र

यह ठीक ऊपर के क्षेत्रों की तरह कार्य करता है, लेकिन आपको रिश्ते के दूसरे छोर पर संबंधित वस्तुओं से स्तंभों का चयन करने की अनुमति देता है।

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

बहिष्करण क्षेत्र

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

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