Lewati ke isi

Filter dan urutkan data

Anda dapat menggunakan metode berikut untuk memfilter data (klausa SQL WHERE).

  • filter(*args, **kwargs) -> QuerySet

  • exclude(*args, **kwargs) -> QuerySet

  • Mendapatkan (*Args,*\ * kwargs) - > model

  • get_or_none(*args, **kwargs) -> Optional[Model]

  • get_or_create(_defaults: Optional[Dict[str, Any]] = None, *args, **kwargs) -> Tuple[Model, bool]

  • all(*args, **kwargs) -> List[Optional[Model]]

  • Agen Setelan Kueri

    • QuerysetProxy.filter(*args, **kwargs) metode
    • QuerysetProxy.exclude(*args, **kwargs) metode
    • QuerysetProxy.get(*args, **kwargs) metode
    • QuerysetProxy.get_or_none(*args, **kwargs) metode
    • QuerysetProxy.get_or_create(_defaults: Optional[Dict[str, Any]] = None, *args, **kwargs) metode
    • QuerysetProxy.all(*args, **kwargs) metode

Dan urutkan data menggunakan metode berikut (urutan SQL berdasarkan klausa).

  • order_by(columns:Union[List, str, OrderAction]) -> QuerySet
  • Agen Setelan Kueri
    • QuerysetProxy.order_by(columns:Union[List, str, OrderAction]) metode

penyaring

penyaring

filter(*args, **kwargs) -> QuerySet

Memungkinkan Anda memfilter berdasarkan atribut / bidang model apa pun dan mendapatkan instance menggunakan filter di seluruh hubungan FK.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
Album Kelas (ormar. Model):
    ormar _ config = base _ ormar _ config copy ()

    Id: int = ormar. Integer (primary _ key = Benar)
    Nama: str = ormar. String (max _ length = 100)
    is _ best _ seller: bool = ormar. Boolean (default = Salah)

Jalur Kelas (ormar. Model):
    ormar _ config = base _ ormar _ config copy ()

    Id: int = ormar. Integer (primary _ key = Benar)
    Album: Opsional [Album] = ormar. ForeignKey (Album)
    Nama: str = ormar. String (max _ length = 100)
    Posisi: int = ormar. Integer ()
    play _ count: int = ormar. Integer (nullable = Benar)


Track = Track.objeks.filter (nama = "Burung").get ()
# akan mengembalikan lagu dengan nama yang sama dengan 'The Bird'

Trek = Track.objeks.filter (album _ _ name = "Fantasi").all ()
# akan mengembalikan semua lagu di mana nama album kolom = 'Fantasies'

Filter ala Django

Anda dapat menggunakan akhiran filter khusus untuk mengubah operasi filter:

  • tepat - cocok dengan nilai, kolom sql =\ * dapat ditulis sebagai album\ __nama_\ _ tepat = 'Malibus'
  • iexactly - cocok persis kolom sql =(kasus tidak sensitif)
    • dapat ditulis sebagai album\ __name_\ _ iexactly = 'malibu'
  • berisi - kolom sql SEPERTI '%%'\ * dapat ditulis sebagai album\ __nama_\ _ mengandung = 'Mal'
  • icontains - sql kolom SEPERTI '%%' (case insensitive) \ * dapat ditulis sebagai album\ __name_\ _ icontains = 'mal'
  • dalam -sql column IN (<VALUE1>, <VALUE2>, ...)\ * dapat ditulis sebagai album__name__in=['Malibu', 'Barclay']
  • Isnull - sql kolom IS NULL (dan sql kolom IS NOT NULL)
    • dapat ditulis sebagai album\ __name__isnull = Benar (album isnotnull__name_\ _ isnull = Salah)
  • gt - kolom sql >(lebih besar dari) \ * dapat ditulis sebagai posisi\ _\ _ gt = 3
  • gte - kolom sql > =(lebih besar dari atau sama dengan) \ * dapat ditulis sebagai posisi\ _\ _ gte = 3
  • lt - kolom sql <(di bawah) \ * dapat ditulis sebagai posisi\ _\ _ lt = 3
  • lte - kolom sql < =(kurang dari atau sama dengan) \ * dapat ditulis sebagai posisi\ _\ _ lte = 3
  • startswith - kolom sql SEPERTI '%' (pertandingan awal yang tepat) \ * dapat ditulis sebagai album\ __nama_\ _ startswith = 'Mal'
  • istartswith - kolom sql SEPERTI '%' (case insensitive) \ * dapat ditulis sebagai album__name__istartswith='mal'
  • Endswith - kolom sql SEPERTI '%' (pertandingan akhir yang tepat) \ * dapat ditulis sebagai album\ __Nama_\ _ endswith = 'ibu'
  • iendswith - kolom sql SEPERTI '%' (case insensitive) \ * dapat ditulis sebagai album\ __name_\ _ iendswith = 'IBU'

Beberapa sampel:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
# sql: (product.name = 'Uji' DAN produk.rating > = 3.0)
Produk.objeks.filter (nama = 'Tes', peringkat _ _ gte = 3.0).dapatkan ()

# sql: (product.name = 'Uji' DAN produk.rating > = 3.0)
# OR (categories.name IN ('Mainan', 'Buku'))
Produk.objeks.filter (
    Atau. atau _ (
        Ormar.and _ (nama = 'Tes', peringkat _ _ gte = 3.0),
        kategori _ _ name _ _ in = ['Mainan', 'Buku'])
    ). mendapatkan ()
# note: untuk membaca lebih lanjut tentang dan _ dan atau _ baca bagian filter kompleks di bawah ini

Filter gaya ular piton

  • Tepat - cocok persis dengan nilai, kolom sql =
    • Dapat ditulis sebagai Track.album.name = = 'Malibu
  • itepat - cocok persis kolom sql =(kasus tidak sensitif)
    • Dapat ditulis sebagai Track.album.name.iexact('malibu')
  • berisi - sql kolom LIKE '%%'*dapat ditulis sebagai Track.album.name% 'Mal') *dapat ditulis sebagai Track.album.name.contains('Mal') Ikon* - kolom sql SEPERTI '%%' (case insensitive) \ * dapat ditulis sebagai Track.album.name.icontains('mal')
  • in -sql column IN (<VALUE1>, <VALUE2>, ...)*dapat ditulis sebagai Track.album.name << ['Malibu', 'Barclay']*dapat ditulis sebagai Track.album.name.in_(['Malibu', 'Barclay'])
  • isnull - sql kolom IS NULL (dan sql kolom IS NOT NULL) *dapat ditulis sebagai Track.album.name > > None*dapat ditulis sebagai Track.album.name isnull (True) *dapat ditulis sebagai Tidak null sebagai Track.album.name.isnull(False)*tidak null dapat ditulis sebagai ~ (Track.album.name > > Tidak ada) \ * tidak null dapat ditulis sebagai ~(Track.album.name.isnull(True))
  • gt - sql kolom >(lebih besar dari) \ * dapat ditulis sebagai Track.album.name > 3
  • gte - sql kolom > =(lebih besar dari atau sama dengan) \ * dapat ditulis sebagai Track.album.name > = 3
  • lt - kolom sql <(di bawah) \ * dapat ditulis sebagai Track.album.name < 3
  • lte - sql kolom < =(kurang dari atau sama dengan) \ * dapat ditulis sebagai Track.album.name < = 3
  • startswith - kolom sql SEPERTI '%' (pertandingan awal yang tepat) \ * dapat ditulis sebagai Track.album.name.startswith('Mal')
  • istartswith - kolom sql SEPERTI '%' (case insensitive) \ * dapat ditulis sebagai Track.album.name.istartswith('mal')
  • endswith - kolom sql SEPERTI '%' (pertandingan akhir yang tepat) \ * dapat ditulis sebagai Track.album.name.endswith('ibu')
  • iendswith - kolom sql SEPERTI '%' (kasus tidak sensitif) \ * dapat ditulis sebagai Track.album.name.iendswith('IBU')

Beberapa sampel:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
# sql: (product.name = 'Uji' DAN produk.rating > = 3.0)
Produk.objeks.filter (
    (Product.name = = 'Uji') & (Product.rating > = 3.0)
). mendapatkan ()

# sql: (product.name = 'Uji' DAN produk.rating > = 3.0)
# OR (categories.name IN ('Mainan', 'Buku'))
Produk.objeks.filter (
        ((Product.name = = 'Test') & (Product.rating > = 3.0)) |
        (Product.categories.name < < ['Mainan', 'Buku'])
    ). mendapatkan ()

Perhatikan

Jadi operasi seperti filter(),select_related(),limit() dan offset() dll dapat dirantai.

Sesuatu seperti Track.object.select_related("album").filter(album__name="Malibu").offset(1).limit(1).all()

Peringatan!!!, perhatikan bahwa Anda tidak perlu menentukan% wild-card yang berisi dan filter lainnya, itu ditambahkan untuk Anda. Jika Anda memasukkan% dalam nilai pencarian, itu akan lolos dan diperlakukan sebagai tanda persen literal dalam teks.

mengecualikan

exclude(*args, **kwargs) -> QuerySet

Ini bekerja persis sama dengan filter, dan semua pengubah (akhiran) sama, tetapi kondisi tidak dikembalikan.

Jadi jika Anda menggunakan filter (nama = 'John'), yang sama dengan di mana nama = 'John' dalam SQL, maka kecuali (nama = 'John') sama dengan di mana nama < > 'John'.

Harap dicatat bahwa semua kondisi digabungkan, jadi jika Anda melewati banyak nilai, itu menjadi penyatuan kondisi.

Pengecualian (nama = 'John', usia > = 35) menjadi where not (name='John' and age>=35)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
Album Kelas (ormar. Model):
    ormar _ config = base _ ormar _ config copy ()

    Id: int = ormar. Integer (primary _ key = Benar)
    Nama: str = ormar. String (max _ length = 100)
    is _ best _ seller: bool = ormar. Boolean (default = Salah)

Jalur Kelas (ormar. Model):
    ormar _ config = base _ ormar _ config copy ()

    Id: int = ormar. Integer (primary _ key = Benar)
    Album: Opsional [Album] = ormar. ForeignKey (Album)
    Nama: str = ormar. String (max _ length = 100)
    Posisi: int = ormar. Integer ()
    play _ count: int = ormar. Integer (nullable = Benar)


Catatan = menunggu Track.objeks.exde (posisi _ gt = 3).all ()
# mengembalikan semua lagu dengan posisi < 3

Filter kompleks (termasuk OR)

Secara default, metode filter () dan kecuali () menggabungkan opsi filter yang disediakan dengan kondisi AND sehingga filter(name="John", age__gt=30) diterjemahkan menjadi WHERE name = 'John' AND age > 30.

Kadang-kadang berguna untuk menanyakan database menggunakan kondisi yang tidak boleh diterapkan bersama-sama, seperti WHERE name = 'John' OR age > 30, atau untuk membangun kompleks di mana pertanyaan di mana Anda ingin lebih banyak kontrol. Bagaimanapun,WHERE (name = 'John' OR age > 30) and city='New York' benar-benar berbeda dari WHERE name = 'John' OR (age > 30 and city='New York').

Untuk membangun OR dan kondisi bersarang, Ormar menyediakan dua fungsi yang dapat digunakan dalam filter () dan kecuali () dalam QuerySet dan QuerysetProxy.

!!!Perhatikan bahwa Anda dapat menyediakan metode ini dengan metode lain yang menerima\ * args, seperti get () atau all ().

Panggilan ke atau_dan_dapat bersarang satu sama lain atau dikombinasikan dengan argumen kata kunci. Karena kedengarannya lebih rumit dari yang sebenarnya, mari kita lihat beberapa contoh.

Diberi contoh model seperti ini:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
base _ ormar _ config = ormar. OrmarConfig (
    Database = database. Database (DATABASE _ URL),
    Metadata = sqlalchemy. MetaData (),
)


Kelas Penulis (ormar. Model):
    ormar _ config = base _ ormar _ config copy ()

    Id: int = ormar. Integer (primary _ key = Benar)
    Nama: str = ormar. String (max _ length = 100)


Buku Kelas (ormar. Model):
    ormar _ config = base _ ormar _ config copy ()

    Id: int = ormar. Integer (primary _ key = Benar)
    Author: Opsional [Author] = ormar. ForeignKey (Author)
    Judul: str = ormar. String (max _ length = 100)
    Tahun: int = ormar. Integer (nullable = Benar)

Mari kita buat beberapa contoh data:

1
2
3
4
5
6
7
Tolkien = await Author (nama = "J.R.R. Tolkien").save ()
Menunggu Buku (penulis = tolkien, judul = "The Hobbit," tahun = 1933). simpan ()
Menunggu Buku (penulis = tolkien, judul = "The Lord of the Rings," tahun = 1955). simpan ()
Menunggu Buku (penulis = tolkien, judul = "The Silmarillion," tahun = 1977). simpan ()
Sapkowski = menunggu Penulis (nama = "Andrzej Sapkowski").simpan ()
Menunggu Buku (penulis = sapkowski, judul = "The Witcher," tahun = 1990). simpan ()
Buku Menunggu (penulis = sapkowski, judul = "Menara Orang Bodoh," tahun = 2002). simpan ()

Kita dapat membuat beberapa contoh pertanyaan kompleks:

Mari kita pilih buku atau buku Tolkien yang ditulis setelah tahun 1970

SQL: WHERE ( authors.name = 'J.R.R. Tolkien' OR books.year > 1970 )

Gaya Django

1
2
3
4
5
6
Buku = (
    await Book.objeks.pilih _ terkait ("penulis")
    . Filter (ormar. or _ (author _ _ name = "J.R.R. Tolkien," year _ _ gt = 1970))
    . Semua ()
)
Assert len (buku) = = 5

Gaya ular piton

1
2
3
4
5
6
Buku = (
    await Book.objeks.pilih _ terkait ("penulis")
    . Filter ((Book.author.name = = "J.R.R. Tolkien") | (Book.year > 1970))
    . Semua ()
)
Assert len (buku) = = 5

Sekarang mari kita pilih buku yang ditulis oleh Tolkien setelah tahun 1960 atau sebelum tahun 1940.

SQL: WHERE ( books.year > 1960 OR books.year < 1940 ) AND authors.name = 'J.R.R. Tolkien'

Gaya Django

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# OPTION 1 - split dan menjadi panggilan terpisah
Buku = (
    await Book.objeks.pilih _ terkait ("penulis")
    . Filter (ormar. atau _ (tahun _ _ gt = 1960, tahun _ _ lt = 1940))
    . Filter (penulis _ _ name = "J.R.R. Tolkien")
    . Semua ()
)
Assert len (buku) = = 2

# OPTION 2 - semuanya menjadi satu
Buku = (
    await Book.objeks.pilih _ terkait ("penulis")
    . Filter (
        Atau. dan _ (
            Ormar. atau _ (tahun _ _ gt = 1960, tahun _ _ lt = 1940),
            penulis _ _ name = "J.R.R. Tolkien,"
        )
    )
    . Semua ()
)

Assert len (buku) = = 2
Buku-buku yang ditegaskan [0]. judul = = "The Hobbit"
Buku yang ditegaskan [1]. judul = = "Silmarillion"

Gaya ular piton

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
Buku = (
    await Book.objeks.pilih _ terkait ("penulis")
    . Filter ((Tahun buku > 1960) | (Tahun buku < 1940))
    . Filter (Book.author.name = = "J.R.R. Tolkien")
    . Semua ()
)
Assert len (buku) = = 2

# OPTION 2 - semuanya menjadi satu
Buku = (
    await Book.objeks.pilih _ terkait ("penulis")
    . Filter (
        (
            (Tahun buku > 1960) | (Tahun buku < 1940)
        ) & (Book.author.name = = "J.R.R. Tolkien")
    )
    . Semua ()
)

Assert len (buku) = = 2
Buku-buku yang ditegaskan [0]. judul = = "The Hobbit"
Buku yang ditegaskan [1]. judul = = "Silmarillion"

Buku Sapkowski sebelum tahun 2000 atau buku Tolkien setelah tahun 1960

SQL: WHERE ( ( books.year > 1960 AND authors.name = 'J.R.R. Tolkien' ) OR ( books.year < 2000 AND authors.name = 'Andrzej Sapkowski' ) )

Gaya Django

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
Buku = (
    await Book.objeks.pilih _ terkait ("penulis")
    . Filter (
        Atau. atau _ (
            Ormar. dan _ (tahun _ _ gt = 1960, penulis _ _ name = "J.R.R. Tolkien"),
            Ormar. dan _ (tahun _ _ lt = 2000, penulis _ _ name = "Andrzej Sapkowski"),
        )
    )
    . Semua ()
)
Assert len (buku) = = 2

Gaya ular piton

1
2
3
4
5
6
7
8
9
Buku = (
    await Book.objeks.pilih _ terkait ("penulis")
    . Filter (
        ((Book.year > 1960) & (Book.author.name = = "J.R.R. Tolkien")
        ((Tahun buku < 2000) & (Book.author.name = = "Andrzej Sapkowski"))
    )
    . Semua ()
)
Assert len (buku) = = 2

Tentu saja, fungsi ini dapat memiliki lebih dari dua syarat, jadi jika kita menginginkan buku yang mencakup "hobbit":

SQL: WHERE ( ( books.year > 1960 AND authors.name = 'J.R.R. Tolkien' ) OR ( books.year < 2000 AND os0cec_authors.name = 'Andrzej Sapkowski' ) OR books.title LIKE '%hobbit%' )

Gaya Django

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
Buku = (
    await Book.objeks.pilih _ terkait ("penulis")
    . Filter (
        Atau. atau _ (
            Ormar. dan _ (tahun _ _ gt = 1960, penulis _ _ name = "J.R.R. Tolkien"),
            Ormar. dan _ (tahun _ _ lt = 2000, penulis _ _ name = "Andrzej Sapkowski"),
            judul _ _ icontains = "hobbit,"
        )
    )
    . Semua ()
)

Gaya ular piton

1
2
3
4
5
6
7
8
9
Buku = (
    await Book.objeks.pilih _ terkait ("penulis")
    . Filter (
        ((Book.year > 1960) & (Book.author.name = = "J.R.R. Tolkien")
        ((Book.year < 2000) & (Book.author.name = = "Andrzej Sapkowski")) |
        (Book.title.icontains ("hobbit"))
    )
    . Semua ()
)

Jika mau atau perlu, Anda dapat bersarang kondisi yang lebih dalam sesuai kebutuhan, seperti menerapkan pertanyaan berikut:

SQL:

1
2
3
DI MANA (((tahun buku > 1960 ATAU tahun buku < 1940)
DAN authors.name = 'J.R.R. Tolkien') ATAU
(Tahun buku < 2000 dan authors.name = 'Andrzej Sapkowski'))

Anda dapat menyusun pertanyaan sebagai berikut:

Gaya Django

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
Buku = (
    await Book.objeks.pilih _ terkait ("penulis")
    . Filter (
        Atau. atau _ (
            Atau. dan _ (
                Ormar. atau _ (tahun _ _ gt = 1960, tahun _ _ lt = 1940),
                penulis _ _ name = "J.R.R. Tolkien,"
            ),
            Ormar. dan _ (tahun _ _ lt = 2000, penulis _ _ name = "Andrzej Sapkowski"),
        )
    )
    . Semua ()
)
Assert len (buku) = = 3
Buku-buku yang ditegaskan [0]. judul = = "The Hobbit"
Buku yang ditegaskan [1]. judul = = "Silmarillion"
Buku yang ditegaskan [2]. judul = = "Sang Penyihir"

Gaya ular piton

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
Buku = (
    await Book.objeks.pilih _ terkait ("penulis")
    . Filter (
        (
            (
            (Tahun buku > 1960) |
            (Buku. Tahun < 1940)
            ) &
            (Book.author.name = = "J.R.R. Tolkien")
        ) |
        (
            (Tahun buku < 2000) &
            (Book.author.name = = "Andrzej Sapkowski")
        )
    )
    . Semua ()
)
Assert len (buku) = = 3
Buku-buku yang ditegaskan [0]. judul = = "The Hobbit"
Buku yang ditegaskan [1]. judul = = "Silmarillion"
Buku yang ditegaskan [2]. judul = = "Sang Penyihir"

Anda sekarang harus memahami cara kerja ormar.or_dan ormar.and_. Tentu saja, Anda dapat menghubungkannya ke salah satu metode lain dalam kumpulan kueri, jadi dalam contoh, kueri yang sepenuhnya valid mungkin terlihat seperti ini:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
Buku = (
    await Book.objeks.pilih _ terkait ("penulis")
    . Filter (ormar. or _ (tahun _ _ gt = 1980, penulis _ _ name = "Andrzej Sapkowski"))
    . Filter (judul _ _ startswith = "The")
    . batas (1)
    . Offset (1)
    . pesan _ oleh ("-id")
    . Semua ()
)
Assert len (buku) = = 1
Buku yang ditegaskan [0]. judul = = "Sang Penyihir"

Ini juga berlaku untuk menghubungkan dan bersarang ala Python.

Gaya Django

Harap dicatat bahwa dengan gaya Django, Anda tidak dapat memberikan argumen kata kunci yang sama beberapa kali, jadi mempertanyakan filter(ormar.or_(name='Jack', name='John')) sebagai berikut tidak diperbolehkan. Jika Anda ingin memeriksa beberapa nilai untuk kolom yang sama, cukup gunakan operator in:filter(name__in=['Jack','John']).

Jika hanya satu argumen yang diteruskan ke fungsi atau_atau_, itu hanya dilampirkan dalam tanda kurung dan tidak berpengaruh pada kueri yang sebenarnya, jadi ketiga kueri akhirnya menjadi sama:

1
2
3
Menunggu Book.objeks.filter (judul = 'The Hobbit').get ()
Tunggu Book.objeks.filter (ormar.or _ (judul = 'The Hobbit')).get ()
Tunggu Book.objeks.filter (ormar.and _ (judul = 'The Hobbit')).get ()

!!!Catatan atau_ Dan dan_ Pertanyaan akan memiliki MANA (judul = 'The Hobbit'), tetapi tanda kurung berlebihan dan tidak memiliki efek praktis.

Jika Anda benar-benar perlu menggunakan nama bidang yang sama dua kali, Anda dapat menggunakan fitur ini. Ingat bahwa Anda tidak dapat meneruskan argumen kata kunci yang sama ke fungsi dua kali, jadi bagaimana Anda menghitung WHERE (authors.name LIKE '%tolkien%') OR (authors.name LIKE '%sapkowski%')) dalam contoh?

Anda tidak bisa melakukan ini.

1
2
3
4
5
6
7
8
Buku = (
    await Book.objeks.pilih _ terkait ("penulis")
        . Filter (atau _ (
        penulis _ _ name _ _ icontains = "tolkien,"
        penulis _ _ name _ _ icontains = "sapkowski" # Anda tidak dapat menggunakan kata kunci yang sama dua kali di atau _!
    )) # kesalahan sintaks python
        . Semua ()
)

Tapi Anda bisa melakukan ini:

1
2
3
4
5
6
7
8
9
Buku = (
    await Book.objeks.pilih _ terkait ("penulis")
        . Filter (atau _ (
        Ormar.and _ (penulis _ _ name _ _ icontains = "tolkien"), # satu argumen = = hanya dibungkus ()
        Ormar dan _ (penulis _ _ name _ _ icontains = "sapkowski")
    ))
        . Semua ()
)
Assert len (buku) = = 5

Gaya ular piton

Harap dicatat bahwa dengan gaya Python, Anda dapat menggunakan bidang yang sama sebanyak yang diperlukan.

1
2
3
4
5
6
7
8
Buku = (
    await Book.objeks.pilih _ terkait ("penulis")
        . Filter (
        (Book.author.name ikontains ("tolkien")) |
        (Book.author.name ikontains ("sapkowski"))
    ))                                      
        . Semua ()
)

mendapatkan

Mendapatkan (*Args,*\ * kwargs) - > model

Mendapatkan baris pertama dari database yang memenuhi kondisi set kwargs.

Saat melewati args dan / atau kwarg apa pun, itu setara dengan memanggil filter (*Args,*\ * kwargs).dapatkan () jalan pintas

!!!Tip Untuk mempelajari lebih lanjut tentang filter, buka Filter.

1
Untuk membaca lebih lanjut tentang `get`, buka [baca / dapatkan](../read/#get)

Dapatkan atau tidak sama sekali

Ini persis sama dengan yang dijelaskan di atas, tetapi jika tidak ada catatan database yang cocok dengan kriteria yang ditemukan, Tidak ada yang dikembalikan alih-alih pengecualian yang dilemparkan.

Memperoleh atau membuat

get_or_create(_defaults: Optional[Dict[str, Any]] = None, *args, **kwargs) -> Tuple[Model, bool]

Buat dan dapatkan kombinasi metode.

Saat melewati args dan / atau kwarg apa pun, itu setara dengan memanggil jalan pintas filter(*args, **kwargs).get_or_create()

!!!Tip Untuk mempelajari lebih lanjut tentang filter, buka Filter.

1
Untuk membaca lebih lanjut tentang `get_or_create`, buka [baca / dapatkan _ atau _ buat](../read/#get_or_create)

Peringatan!!!Ketika item tertentu tidak ada, Anda harus melewati kwarg untuk semua bidang model yang diperlukan, termasuk namun tidak terbatas pada kolom kunci\ _ Primer (kecuali jika ditambahkan secara otomatis).

semuanya

all(*args, **kwargs) -> List[Optional["Model"]]

Untuk opsi filter set, kembalikan semua baris dalam database untuk model yang diberikan.

Saat melewati kwarg apa pun, itu setara dengan memanggil jalan pintas ke filter (*args,*\ * kwargs).all ()

!!!Tip Untuk mempelajari lebih lanjut tentang filter, buka Filter.

1
Untuk membaca lebih lanjut tentang `all` Pergi ke [Baca / semuanya](../read/#all)

Metode QuerysetProxy

Saat mengakses bidang ManyToMany dan ReverseForeignKey yang relevan secara langsung, daftar model terkait dikembalikan.

Tetapi juga memaparkan subset dari QuerySet API, sehingga Anda dapat memfilter, membuat, memilih model terkait, dll. langsung dari model induk.

penyaring

Fungsi pemfilteran yang sama seperti di atas, tetapi memungkinkan Anda untuk menyaring objek terkait dari ujung hubungan yang lain.

!!!Untuk mempelajari lebih lanjut tentang QuerysetProxy, kunjungi bagian QuerysetProxy

mengecualikan

Fungsi pengecualian persis sama seperti di atas, tetapi memungkinkan Anda untuk menyaring objek terkait dari sisi lain hubungan.

!!!Untuk mempelajari lebih lanjut tentang QuerysetProxy, kunjungi bagian QuerysetProxy

mendapatkan

Sama seperti mendapatkan fungsi di atas, tetapi memungkinkan Anda untuk menyaring objek terkait dari ujung hubungan yang lain.

!!!Untuk mempelajari lebih lanjut tentang QuerysetProxy, kunjungi bagian QuerysetProxy

Dapatkan atau tidak sama sekali

Ini persis sama dengan yang dijelaskan di atas, tetapi jika tidak ada catatan database yang cocok dengan kriteria yang ditemukan, Tidak ada yang dikembalikan alih-alih pengecualian yang dilemparkan.

Memperoleh atau membuat

Sama persis dengan fungsi get\ _ atau\ _ di atas, tetapi memungkinkan Anda untuk memfilter objek terkait dari ujung hubungan yang lain.

!!!Untuk mempelajari lebih lanjut tentang QuerysetProxy, kunjungi bagian QuerysetProxy

semuanya

Sama seperti semua hal di atas, tetapi memungkinkan Anda untuk menyaring objek terkait dari sisi lain hubungan.

!!!Untuk mempelajari lebih lanjut tentang QuerysetProxy, kunjungi bagian QuerysetProxy

memilah

Dasar pemesanan

order_by(columns: Union[List, str, OrderAction]) -> QuerySet

Menggunakan order\ _ by (), Anda dapat mengurutkan hasil di database dengan bidang yang Anda pilih.

Anda dapat memberikan string dengan nama bidang atau daftar string dengan bidang yang berbeda.

Penyortiran dalam SQL diterapkan dalam urutan nama yang Anda berikan secara berurutan\ _ by.

!!!Tip Secara default, jika Anda tidak memberikan penyortiran atau secara eksplisit mengurutkan berdasarkan semua tombol utama

!!!Peringatan: Jika Anda mengurutkan berdasarkan model bersarang, baris yang dihasilkan tidak diurutkan berdasarkan model utama, jika tidak, mar akan menggabungkan baris anak-anak ini menjadi satu model utama.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
Contoh hasil baris database mentah (diurutkan berdasarkan model anak desc):
```
MODEL: 1 - Child Model - 3
MODEL: 2 - Child Model - 2
MODEL: 1 - Child Model - 1
```

Akan menghasilkan 2 baris hasil:
```
MODEL: 1 - Child Models: [3, 1] # encountered first in result, all children rows combined
MODEL: 2 - Child Models: [2]
```

Model utama tidak akan pernah menduplikasi hasil

Contoh model yang diberikan adalah sebagai berikut:

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

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


class Toy(ormar.Model):
    ormar_config = ormar_base_config.copy(tablename="toys")

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    owner: Owner = ormar.ForeignKey(Owner)


@create_drop_database(base_config=ormar_base_config)
async def run_query():
    # build some sample data
    aphrodite = await Owner.objects.create(name="Aphrodite")
    hermes = await Owner.objects.create(name="Hermes")
    zeus = await Owner.objects.create(name="Zeus")

    await Toy.objects.create(name="Toy 4", owner=zeus)
    await Toy.objects.create(name="Toy 5", owner=hermes)
    await Toy.objects.create(name="Toy 2", owner=aphrodite)
    await Toy.objects.create(name="Toy 1", owner=zeus)
    await Toy.objects.create(name="Toy 3", owner=aphrodite)
    await Toy.objects.create(name="Toy 6", owner=hermes)


asyncio.run(run_query())

Untuk mengurutkan berdasarkan bidang model master, cukup berikan nama bidang

Gaya Django

1
2
3
4
5
6
Mainan = menunggu Toy.objeks.pilih _ terkait ("pemilik").order _ by ("nama").all ()
Tegaskan [x.name ("Mainan," "") untuk x dalam mainan] = = [
    STR (x + 1) untuk x dalam jangkauan (6)
]
Mainan yang ditetapkan [0]. pemilik = = zeus
Menegaskan mainan [1]. pemilik = = aphrodite

Gaya ular piton

1
2
3
4
5
6
Mainan = menunggu Toy.objeks.Select _ terkait ("pemilik") order _ by (Toy.name ()).all ()
Tegaskan [x.name ("Mainan," "") untuk x dalam mainan] = = [
    STR (x + 1) untuk x dalam jangkauan (6)
]
Mainan yang ditetapkan [0]. pemilik = = zeus
Menegaskan mainan [1]. pemilik = = aphrodite

Untuk mengurutkan model bersarang, nama bidang terpisah dengan dunder '__'.

Anda dapat mengurutkan semua jenis hubungan - > ForeignKey, Reverse Virtual FK, dan ManyToMany bidang dengan cara ini.

Gaya Django

1
2
3
4
Mainan = menunggu Toy.objeks.select _ terkait ("pemilik").order _ by ("pemilik _ _ name").all ()
Assert toys [0]. owner.name = = mainan [1]. owner.name = = "Aphrodite"
Assert toys [2]. owner.name = = mainan [3]. owner.name = = "Hermes"
Assert toys [4]. owner.name = = mainan [5]. owner.name = = "Zeus"

Gaya ular piton

1
2
3
4
Mainan = menunggu Toy.objeks.Select _ terkait ("pemilik") order _ by (Toy.owner.name ()).all ()
Assert toys [0]. owner.name = = mainan [1]. owner.name = = "Aphrodite"
Assert toys [2]. owner.name = = mainan [3]. owner.name = = "Hermes"
Assert toys [4]. owner.name = = mainan [5]. owner.name = = "Zeus"

Untuk mengurutkan dalam urutan menurun, berikan tanda hubung sebelum nama bidang

Gaya Django

1
2
3
4
5
6
7
8
Pemilik = (
    Tunggu Pemilik. Objek. Pilih _ terkait ("mainan")
        . order _ by ("- mainan _ _ name")
        . filter (nama = "Zeus")
        . mendapatkan ()
)
Tegaskan owner.toys [0]. nama = = "Mainan 4"
Tegaskan owner.toys [1]. nama = = "Mainan 1"

Gaya ular piton

1
2
3
4
5
6
7
8
Pemilik = (
    Tunggu Pemilik. Objek. Pilih _ terkait ("mainan")
        . order _ by (Owner.toys.name ())
        . Filter (Owner.name = = "Zeus")
        . mendapatkan ()
)
Tegaskan owner.toys [0]. nama = = "Mainan 4"
Tegaskan owner.toys [1]. nama = = "Mainan 1"

Perhatikan

Jadi operasi seperti filter(),select_related(),limit() dan offset() dll dapat dirantai.

Sesuatu seperti Track.object.select_related("album").filter(album__name="Malibu").offset(1).limit(1).all()

Penyortiran default di Ormar

Karena urutan baris dalam database tidak dapat dijamin, Ormar selalu mengeluarkan urutan berdasarkan klausa sql untuk setiap pertanyaan (sebagian), bahkan jika Anda tidak memberikan pesanan sendiri.

Secara default, saat menanyai database dengan model tertentu, model diurutkan dalam urutan menaik oleh kolom\ _ kunci Primer. Jika Anda ingin mengubah perilaku default, Anda dapat melakukannya dengan memasok Pesanan\ _ dengan parameter ke konfigurasi ormar\ _.

!!! Tip Untuk mempelajari lebih lanjut tentang urutan pemilahan model, kunjungi bagian Model dokumentasi

Secara default, hubungan mengikuti urutan yang sama, tetapi Anda dapat mengubah urutan di mana model terkait dimuat selama kueri dengan menyediakan hubungan dengan pesanan\ _ berdasarkan dan\ _ pesanan\ _ terkait berdasarkan parameter.

!!! Tip Untuk membaca lebih lanjut tentang urutan pemilahan model, kunjungi bagian hubungan dokumen

Urutan\ _ berdasarkan klausa diterapkan dalam urutan berikut:

  • Secara eksplisit lulus pesanan\ _ oleh () panggilan dalam kueri
  • Hubungan dengan perintah\ _ oleh dan terkait\ _ perintah\ _ oleh (jika ada)
  • Model ormar\ _ konfigurasi urutan objek\ _ oleh
  • Kolom kunci\ _ utama model dalam urutan menaik (fallback, digunakan jika tidak ada di atas yang disediakan)

Terapkan pesanan hanya dari satu sumber ke setiap model (sehingga Anda selalu dapat menimpanya dalam satu pertanyaan).

Ini berarti bahwa jika Anda memberikan urutan eksplisit\ _ oleh untuk model dalam kueri, hubungan dan urutan pemesanan model akan dilewati.

Jika Anda memberikan hubungan satu, pemesanan model dilewati.

Terakhir, jika Anda memberikan Model, nilai default untuk\ _ key primer dilewati.

Metode QuerysetProxy

Saat mengakses bidang ManyToMany dan ReverseForeignKey yang relevan secara langsung, daftar model terkait dikembalikan.

Tetapi juga memaparkan subset dari QuerySet API, sehingga Anda dapat memfilter, membuat, memilih model terkait, dll. langsung dari model induk.

Dasar pemesanan

Persis sama dengan urutan\ _ berdasarkan fungsi di atas, tetapi memungkinkan Anda untuk mengurutkan objek terkait dari sisi lain hubungan.

!!!Untuk mempelajari lebih lanjut tentang QuerysetProxy, kunjungi bagian QuerysetProxy