Ga naar inhoud

Selecteer een subset van kolommen

Als u alleen de geselecteerde kolommen in het model wilt selecteren, kunt u de volgende functie gebruiken.

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

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

  • Query instellen Agent

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

veld

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

Met velden () kunt u een subset van modelkolommen kiezen om de gegevensbelasting te beperken.

Merk op dat velden () en behalve\ _ velden () van toepassing zijn op zowel het mastermodel (bij normale queries zoals get, all, etc.) als de select\ _ lated en prefetch\ _ lated modellen (met behulp van geneste notatie).

De volgende voorbeeldgegevens worden gegeven:

 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
60
61
62
63
64
65
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())

U kunt het opgegeven veld selecteren door een str, List[str], Set[str] or dict met geneste definities door te geven.

Gebruik het symbool {related_name}__{column}[__{optional_next} etc.] om gerelateerde modellen op te nemen.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
alle _ auto 's = wachten (
    Car.objecten
    . select _ gerelateerd ('fabrikant')
    . Velden (['id', 'naam', 'fabrikant _ _ naam'])
    . Alle ()
)
Voor auto in alle _ auto 's:
    # uitgesloten kolommen leveren geen op
    Stel alles (getattr (auto, x) is geen voor x in ['jaar', 'versnellingsbak _ type', 'versnellingen', 'aircon _ type'])
    # inclusief kolom over gerelateerde modellen zal beschikbaar zijn, pk-kolom is altijd inbegrepen
    # ook als je het niet opneemt in velden lijst
    Beweren car.manufacturer.name = = 'Toyota'
    # ook in de geneste gerelateerde modellen - je kunt pk niet uitsluiten - het is altijd automatisch toegevoegd
    Assert car.fabricture.foundation is geen

Velden () kunnen meerdere keren worden aangeroepen om de te selecteren kolommen te bouwen.

Als u verwante modellen opneemt in de select\ _ lated () -aanroep, maar u geeft geen kolommen op voor die modellen in het veld

  • Betekent een lijst van alle velden van deze geneste modellen.

    alle _ auto 's = wachten ( Car.objecten . select _ gerelateerd ('fabrikant') . Velden ('id') . Velden (['naam']) . Alle () )

    alle velden uit bedrijfsmodel zijn geselecteerd

    Bevestig alle _ auto 's [0]. manufacturer.name = = 'Toyota' Bevestig alle auto 's [0]. Fabrikant opgericht = = 1937

!!! Waarschuwing kan een verplicht veld niet uitsluiten omdat het een validatiefout oplevert en het veld leeg moet zijn om uit te sluiten.

1
2
De `values()`-methode kan worden gebruikt om verplichte velden uit te sluiten, hoewel gegevens dat wel zullen doen
Teruggestuurd worden als `dict`.

U kunt de verplichte kolom met modelnummers niet uitsluiten - de naam fabrikant__in dit voorbeeld.

1
2
3
4
5
6
7
In afwachting (
    Car.objecten
    . select _ gerelateerd ('fabrikant')
    . Velden (['id', 'naam', 'fabrikant _ _ opgericht'])
    . Alle ()
)
# zal pydantic ValidationError verhogen company.name is vereist

!!!De Tip Pk-kolom kan niet worden uitgesloten - deze wordt altijd automatisch toegevoegd, zelfs als deze niet expliciet is opgenomen.

U kunt ook velden doorgeven die als woordenboek of set moeten worden opgenomen.

Om een veld voor opname in het woordenboek te markeren, gebruikt u de naam als sleutel en een ellips als waarde.

Gebruik een genest woordenboek om een genest model te doorlopen.

Als u velden op het laatste niveau wilt opnemen in plaats van geneste woordenboeken, kunt u collecties gebruiken.

Om het volledige geneste model op te nemen, specificeert u de veldnamen en ellipsen die aan het model zijn gekoppeld.

Hieronder ziet u een gelijkwaardig voorbeeld:

 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
60
61
62
63
64
65
66
# 1. zoals in voorbeeld hierboven
In afwachting (
    Car.objecten
    . select _ gerelateerd ('fabrikant')
    . Velden (['id', 'naam', 'fabrikant _ _ naam'])
    . Alle ()
)

# 2. om een veld te markeren zoals vereist met ellips
In afwachting (
    Car.objecten
    . select _ gerelateerd ('fabrikant')
    . Velden ({'id':...,
             'Naam':...,
             'Fabrikant': {
                 'Naam':...
                }
             })
    . Alle ()
)

# 3. hele geneste modellen met ellips op te nemen
In afwachting (
    Car.objecten
    . select _ gerelateerd ('fabrikant')
    . Velden ({'id':...,
             'Naam':...,
             "" "Fabrikant" ":"...
             })
    . Alle ()
)

# 4. om velden op het laatste nestniveau te specificeren
# je kunt ook set gebruiken - equivalent aan 2 hierboven
In afwachting (
    Car.objecten
    . select _ gerelateerd ('fabrikant')
    . Velden ({'id':...,
             'Naam':...,
             'De fabrikant': {'name'}
             })
    . Alle ()
)

# 5. natuurlijk kan set meerdere velden hebben
In afwachting (
    Car.objecten
    . select _ gerelateerd ('fabrikant')
    . Velden ({'id':...,
             'Naam':...,
             'De fabrikant': {'name', 'founded'}
             })
    . Alle ()
)

# 6. u kunt alle geneste velden opnemen,
# maar het komt overeen met 3. daarboven wat korter is
In afwachting (
    Car.objecten
    . select _ gerelateerd ('fabrikant')
    . Velden ({'id':...,
             'Naam':...,
             "De fabrikant": {'id', 'name', 'founded'}
             })
    . Alle ()
)

!!!Merk op dat alle methoden die geen rijen retourneren expliciet een QuerySet-instantie retourneren, zodat u ze aan elkaar kunt koppelen

1
2
3
Dus operaties zoals `filter()`,`select_related()`,`limit()` en `offset()` etc. kunnen worden geketend.

Iets als `Track.objects.select_related("album").filter(album__name="Malibu").offset(1).limit(1).all()`

uitsluitingsveld

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

Met behalve\ _ fields () kunt u een subset van modelkolommen selecteren die u wilt uitsluiten om het laden van gegevens te beperken.

Het is het tegenovergestelde van de velden () methode, dus controleer de documentatie hierboven om de beschikbare opties te zien.

Controleer met name hoe geneste woordenboeken en collecties als maskers worden doorgegeven om velden uit de hele hiërarchie uit te sluiten.

Merk op dat velden () en behalve\ _ velden () van toepassing zijn op zowel het mastermodel (bij normale queries zoals get, all, etc.) als de select\ _ lated en prefetch\ _ lated modellen (met behulp van geneste notatie).

Hieronder vindt u enkele eenvoudige voorbeelden:

  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
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
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

!!!Waarschuwing, het verplichte veld kan niet worden uitgesloten omdat het een ValidationError oproept. Om een veld uit te sluiten, moet het nullable zijn.

1
2
De `values()`-methode kan worden gebruikt om verplichte velden uit te sluiten, hoewel gegevens dat wel zullen doen
Teruggestuurd worden als een `dict`.

!!! Tip dat de Pk-kolom niet kan worden uitgesloten - zelfs als deze expliciet wordt uitgesloten, wordt deze altijd automatisch toegevoegd.

!!!Merk op dat alle methoden die geen rijen retourneren expliciet een QuerySet-instantie retourneren, zodat u ze aan elkaar kunt koppelen

1
2
3
Dus operaties zoals `filter()`,`select_related()`,`limit()` en `offset()` etc. kunnen worden geketend.

Iets als `Track.object.select_related("album").filter(album__name="Malibu").offset(1).limit(1).all()`

QuerysetProxy methode

Wanneer u rechtstreeks toegang krijgt tot de relevante ManyToMany-velden en ReverseForeignKey, wordt een lijst met gerelateerde modellen geretourneerd.

Maar het toont ook een subset van de QuerySet API, zodat u rechtstreeks vanuit het bovenliggende model kunt filteren, maken, gerelateerde modellen kunt selecteren, enz.

veld

Het werkt precies zoals de bovenstaande velden, maar stelt u in staat kolommen te selecteren uit gerelateerde objecten aan de andere kant van de relatie.

Ga

uitsluitingsveld

Hetzelfde als de functie behalve\ _ velden hierboven, maar u kunt kolommen selecteren uit gerelateerde objecten aan het andere uiteinde van de relatie.

Ga