Gegevens invoegen in de database

Met de volgende methoden kunt u gegevens in een database invoegen.

Maken (**Kwargs) - > Model
get_or_create(_defaults: Optional[Dict[str, Any]] = None, **kwargs) -> Tuple[Model, bool]
update_or_create(**kwargs) -> Model
bulk_create(objects: List[Model]) -> None
Model*Model.save () methode*Model.upsert () methode\ * Model.save\ _ lated () methode
Query Set Agent*QuerysetProxy.create(**kwargs) methode*QuerysetProxy.get_or_create(_defaults: Optional[Dict[str, Any]] = None, **kwargs) methode\ *QuerysetProxy.update_or_create(**kwargs) methode

creëren

Aanmaken (**kwargs): - > Model

Maak de modelinstantie, sla deze op in de database en keer terug om het model bij te werken (pk wordt ingevuld als het niet wordt doorgegeven en automatische verhoging is ingesteld).

De toegestane kwargs zijn modelveldnamen en correcte waardetypen.

Klasse Album (ormar. Model):
    ormar _ config = ormar. OrmarConfig (
        Database = databank,
        metagegevens = metagegevens;
        Tafelnaam = "album"
    )


    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Naam: str = ormar. String (max _ length = 100)


Malibu = wacht op Album.objects.create (naam = "Malibu")
Await Track.objects.create (album = malibu, titel = "De vogel", positie = 1)

Een andere benadering is het creëren van modelsplitsing en persistentie.

Malibu = Album (naam = "Malibu")
malibu.save ()

Tip

Verwerven of creëren

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

Maak en verkrijg een combinatie van methoden.

Pogingen om rijen te krijgen die aan de criteria voldoen, en als er een NoMatch-uitzondering wordt gegenereerd, wordt er een nieuwe rij gemaakt met de gegeven kwargs en\ _ defaults.

Bij het aanleveren van een\ _ defaults woordenboek zullen de waarden die in\ _ defaults zijn ingesteld altijd worden ingesteld, inclusief het overschrijven van die welke expliciet zijn opgegeven. IE get_or_create(_defaults: {"title": "I win"}, title="never used") zal altijd "Ik heb gewonnen" als titel gebruiken, ongeacht of u uw eigen waarde in kwargs opgeeft.

Klasse Album (ormar. Model):
    ormar _ config = ormar. OrmarConfig (
        Database = databank,
        metagegevens = metagegevens;
        Tafelnaam = "album"
    )

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Naam: str = ormar. String (max _ length = 100)
    Jaar: int = ormar. Geheel ()


Album, aangemaakt = afwachten Album.objects.get _ or _ create (naam = 'De kat', _ defaults ={"year": 1999})
Assert gemaakt is Waar
Beweren album.name = = "De Kat"
Beweerd albumjaar = = 1999
# object wordt gemaakt omdat het niet bestaat
Album2, aangemaakt = afwachten Album.objects.get _ or _ create (naam = 'De Kat')
Aangemaakt beweren is vals
Album bevestigen = = album2
# return Waar als dezelfde db-rij wordt geretourneerd

!!!Waarschuwing: Album en album2 in het bovenstaande voorbeeld zijn 2 verschillende Python-objecten, ondanks dat het equivalente rijen in de database zijn! Het bijwerken van een van hen zal de tweede niet vernieuwen totdat u expliciet () nieuwe gegevens uit de database laadt.

Merk op dat als u een nieuw object wilt maken, u de pk-kolomwaarde moet doorgeven of dat de pk-kolom moet worden ingesteld op automatisch verhogen

Bijwerken of aanmaken

update_or_create(**kwargs) -> Model

Werk het model bij of maak een nieuw model als er geen overeenkomst is in de database.

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 Book(ormar.Model):
    ormar_config = ormar_base_config.copy()

    id: int = ormar.Integer(primary_key=True)
    title: str = ormar.String(max_length=200)
    author: str = ormar.String(max_length=100)
    genre: str = ormar.String(
        max_length=100,
        default="Fiction",
    )


@create_drop_database(base_config=ormar_base_config)
async def run_query():
    await Book.objects.create(
        title="Tom Sawyer", author="Twain, Mark", genre="Adventure"
    )
    await Book.objects.create(
        title="War and Peace", author="Tolstoy, Leo", genre="Fiction"
    )
    await Book.objects.create(
        title="Anna Karenina", author="Tolstoy, Leo", genre="Fiction"
    )

    # if not exist the instance will be persisted in db
    vol2 = await Book.objects.update_or_create(
        title="Volume II", author="Anonymous", genre="Fiction"
    )
    assert await Book.objects.count() == 4

    # if pk or pkname passed in kwargs (like id here) the object will be updated
    assert await Book.objects.update_or_create(id=vol2.id, genre="Historic")
    assert await Book.objects.count() == 4


asyncio.run(run_query())

Merk op dat als u een nieuw object wilt maken, u de pk-kolomwaarde moet doorgeven of dat de pk-kolom moet worden ingesteld op automatisch verhogen

batch aanmaken

bulk_create(objects: List["Model"]) -> None

Hiermee kunt u meerdere objecten tegelijk maken.

U moet een geldige lijst met modelobjecten doorgeven.

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

    id: int = ormar.Integer(primary_key=True)
    text: str = ormar.String(max_length=500)
    completed = ormar.Boolean(default=False)


@create_drop_database(base_config=ormar_base_config)
async def run_query():
    # create multiple instances at once with bulk_create
    await ToDo.objects.bulk_create(
        [
            ToDo(text="Buy the groceries."),
            ToDo(text="Call Mum.", completed=True),
            ToDo(text="Send invoices.", completed=True),
        ]
    )

    todoes = await ToDo.objects.all()
    assert len(todoes) == 3


asyncio.run(run_query())

model werkwijze

Elk modelexemplaar heeft een set methoden om zichzelf op te slaan, bij te werken of te laden.

# # opslaan

U kunt de methode QuerySet.create () gebruiken of het model initialiseren als een normaal Pydantisch model en vervolgens de methode save () aanroepen om een nieuw model te maken.

!!!Tip Lees meer over de methode opslaan () in modellen-opslaan

# # update invoegen

Het is een proxy voor de save () of update (**kwargs) -methoden van het model. Als pk niet is ingesteld, wordt de save () -methode aangeroepen.

!!!Tip Lees meer over de upsert () methode in modellen-upsert

# # opslaan gerelateerd

De methode herhaalt alle relaties van het model dat de methode heeft aangeroepen en roept de upsert () -methode aan op elk niet-opgeslagen model.

!!!Tip Lees meer over de methode opslaan\ _ lated () in modellen-opslaan-lated

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.

creëren

De creatiefunctie is identiek aan die hierboven, maar stelt u in staat om gerelateerde objecten te maken vanaf het andere uiteinde van de relatie.

Ga

Verwerven of creëren

Precies hetzelfde als de functie get\ _ or\ _ create hierboven, maar u kunt gerelateerde objecten opvragen of maken vanaf het andere uiteinde van de relatie.

Ga

Bijwerken of aanmaken

De update\ _ or\ _ create-functie is precies hetzelfde als hierboven, maar stelt u in staat om gerelateerde objecten vanaf het andere uiteinde van de relatie bij te werken of te maken.

Ga