Skip to content

models.model

Model Objects

1
class Model(ModelRow)

upsert

1
 | async upsert(**kwargs: Any) -> T

Performs either a save or an update depending on the presence of the pk. If the pk field is filled it's an update, otherwise the save is performed. For save kwargs are ignored, used only in update if provided.

Arguments:

  • kwargs: list of fields to update :type kwargs: Any

Returns:

saved Model :rtype: Model

save

1
 | async save() -> T

Performs a save of given Model instance. If primary key is already saved, db backend will throw integrity error.

Related models are saved by pk number, reverse relation and many to many fields are not saved - use corresponding relations methods.

If there are fields with server_default set and those fields are not already filled save will trigger also a second query to refreshed the fields populated server side.

Does not recognize if model was previously saved. If you want to perform update or insert depending on the pk fields presence use upsert.

Sends pre_save and post_save signals.

Sets model save status to True.

Returns:

saved Model :rtype: Model

1
 | async save_related(follow: bool = False, save_all: bool = False, relation_map: Dict = None, exclude: Union[Set, Dict] = None, update_count: int = 0, previous_model: "Model" = None, relation_field: Optional["ForeignKeyField"] = None) -> int

Triggers a upsert method on all related models if the instances are not already saved. By default saves only the directly related ones.

If follow=True is set it saves also related models of related models.

To not get stuck in an infinite loop as related models also keep a relation to parent model visited models set is kept.

That way already visited models that are nested are saved, but the save do not follow them inside. So Model A -> Model B -> Model A -> Model C will save second Model A but will never follow into Model C. Nested relations of those kind need to be persisted manually.

Arguments:

  • relation_field: field with relation leading to this model :type relation_field: Optional[ForeignKeyField]
  • previous_model: previous model from which method came :type previous_model: Model
  • exclude: items to exclude during saving of relations :type exclude: Union[Set, Dict]
  • relation_map: map of relations to follow :type relation_map: Dict
  • save_all: flag if all models should be saved or only not saved ones :type save_all: bool
  • follow: flag to trigger deep save - by default only directly related models are saved with follow=True also related models of related models are saved :type follow: bool
  • update_count: internal parameter for recursive calls - number of updated instances :type update_count: int

Returns:

number of updated/saved models :rtype: int

update

1
 | async update(_columns: List[str] = None, **kwargs: Any) -> T

Performs update of Model instance in the database. Fields can be updated before or you can pass them as kwargs.

Sends pre_update and post_update signals.

Sets model save status to True.

Arguments:

  • _columns: list of columns to update, if None all are updated :type _columns: List
  • kwargs: list of fields to update as field=value pairs :type kwargs: Any

Raises:

  • ModelPersistenceError: If the pk column is not set

Returns:

updated Model :rtype: Model

delete

1
 | async delete() -> int

Removes the Model instance from the database.

Sends pre_delete and post_delete signals.

Sets model save status to False.

Note it does not delete the Model itself (python object). So you can delete and later save (since pk is deleted no conflict will arise) or update and the Model will be saved in database again.

Returns:

number of deleted rows (for some backends) :rtype: int

load

1
 | async load() -> T

Allow to refresh existing Models fields from database. Be careful as the related models can be overwritten by pk_only models in load. Does NOT refresh the related models fields if they were loaded before.

Raises:

  • NoMatch: If given pk is not found in database.

Returns:

reloaded Model :rtype: Model

load_all

1
 | async load_all(follow: bool = False, exclude: Union[List, str, Set, Dict] = None, order_by: Union[List, str] = None) -> T

Allow to refresh existing Models fields from database. Performs refresh of the related models fields.

By default loads only self and the directly related ones.

If follow=True is set it loads also related models of related models.

To not get stuck in an infinite loop as related models also keep a relation to parent model visited models set is kept.

That way already visited models that are nested are loaded, but the load do not follow them inside. So Model A -> Model B -> Model C -> Model A -> Model X will load second Model A but will never follow into Model X. Nested relations of those kind need to be loaded manually.

Arguments:

  • order_by: columns by which models should be sorted :type order_by: Union[List, str]
  • exclude: related models to exclude :type exclude: Union[List, str, Set, Dict]
  • follow: flag to trigger deep save - by default only directly related models are saved with follow=True also related models of related models are saved :type follow: bool

Raises:

  • NoMatch: If given pk is not found in database.

Returns:

reloaded Model :rtype: Model