# models.helpers.relations #### register\_relation\_on\_build ```python register_relation_on_build(field: Type["ForeignKeyField"]) -> None ``` Registers ForeignKey relation in alias_manager to set a table_prefix. Registration include also reverse relation side to be able to join both sides. Relation is registered by model name and relation field name to allow for multiple relations between two Models that needs to have different aliases for proper sql joins. **Arguments**: - `field (ForeignKey class)`: relation field #### register\_many\_to\_many\_relation\_on\_build ```python register_many_to_many_relation_on_build(field: Type[ManyToManyField]) -> None ``` Registers connection between through model and both sides of the m2m relation. Registration include also reverse relation side to be able to join both sides. Relation is registered by model name and relation field name to allow for multiple relations between two Models that needs to have different aliases for proper sql joins. By default relation name is a model.name.lower(). **Arguments**: - `field (ManyToManyField class)`: relation field #### expand\_reverse\_relationship ```python expand_reverse_relationship(model_field: Type["ForeignKeyField"]) -> None ``` If the reverse relation has not been set before it's set here. **Arguments**: - `model_field ()`: **Returns**: `(None)`: None #### expand\_reverse\_relationships ```python expand_reverse_relationships(model: Type["Model"]) -> None ``` Iterates through model_fields of given model and verifies if all reverse relation have been populated on related models. If the reverse relation has not been set before it's set here. **Arguments**: - `model (Model class)`: model on which relation should be checked and registered #### register\_reverse\_model\_fields ```python register_reverse_model_fields(model_field: Type["ForeignKeyField"]) -> None ``` Registers reverse ForeignKey field on related model. By default it's name.lower()+'s' of the model on which relation is defined. But if the related_model name is provided it's registered with that name. Autogenerated reverse fields also set related_name to the original field name. **Arguments**: - `model_field (relation Field)`: original relation ForeignKey field #### register\_relation\_in\_alias\_manager ```python register_relation_in_alias_manager(field: Type[ForeignKeyField]) -> None ``` Registers the relation (and reverse relation) in alias manager. The m2m relations require registration of through model between actual end models of the relation. Delegates the actual registration to: m2m - register_many_to_many_relation_on_build fk - register_relation_on_build **Arguments**: - `field (ForeignKey or ManyToManyField class)`: relation field #### verify\_related\_name\_dont\_duplicate ```python verify_related_name_dont_duplicate(related_name: str, model_field: Type["ForeignKeyField"]) -> None ``` Verifies whether the used related_name (regardless of the fact if user defined or auto generated) is already used on related model, but is connected with other model than the one that we connect right now. **Raises**: - `ModelDefinitionError`: if name is already used but lead to different related model **Arguments**: - `related_name ()`: - `model_field (relation Field)`: original relation ForeignKey field **Returns**: `(None)`: None #### reverse\_field\_not\_already\_registered ```python reverse_field_not_already_registered(model_field: Type["ForeignKeyField"]) -> bool ``` Checks if child is already registered in parents pydantic fields. **Raises**: - `ModelDefinitionError`: if related name is already used but lead to different related model **Arguments**: - `model_field (relation Field)`: original relation ForeignKey field **Returns**: `(bool)`: result of the check