Comment les usines gèrent-elles les relations entre les modèles différemment des semoirs

Les usines se concentrent principalement sur la génération d'instances de modèle unique ou connexes avec des attributs randomisés ou prédéfinis, à l'aide de bibliothèques Faker. Les semoirs, en revanche, visent davantage à exécuter une série d'instructions pour remplir la base de données avec les données nécessaires, qui peuvent inclure plusieurs modèles et leurs relations.

Définition et objectif

Les usines sont conçues pour créer des instances de modèle individuelles ou connexes avec de fausses données facilement et cohérente. Ils permettent aux développeurs de définir des plans de modèles, spécifiant comment les attributs doivent être remplis et permettant la génération de nombreux cas de ce modèle à des fins de test ou de base de données. Les usines fonctionnent souvent isolément ou avec des relations très claires entre les modèles, en se concentrant sur les attributs et l'existence d'instances de modèle.

Les semoirs servent de scripts ou de classes qui peuvent appeler des usines ou des insertions de base de données directes pour remplir la base de données. Les semoirs sont plus holistiques et procéduraux, contrôlant l'ordre et la logique de la création de données. Ils garantissent que la population de données se produit dans la séquence correcte pour maintenir l'intégrité des données, en particulier lorsque plusieurs tables interdépendantes sont impliquées.

Gestion des relations dans les usines

Dans les usines modèles, les relations sont généralement gérées en définissant les relations à l'intérieur des définitions d'usine elles-mêmes. Par exemple, si un modèle d'utilisateur a une relation un à un avec un modèle de profil, l'usine d'utilisateurs peut définir qu'il "a" un profil via des méthodes de relation ou des rappels qui généreront et associeront des profils associés lors de la création d'utilisateurs.

Les usines peuvent intégrer la logique relationnelle de sorte que lorsqu'une usine de modèles est utilisée pour créer une instance, elle crée et associe automatiquement les instances de modèle connexes dans la même opération. Cela se fait souvent à l'aide de méthodes comme `Has () ',` for ()', ou des rappels de relations personnalisés qui génèrent des modèles connexes. Cette approche facilite les tests car les données connexes sont créées de manière transparente aux côtés des principales données du modèle.

Gestion des relations chez les graines

Les semoirs utilisent des usines mais organisent le flux global et l'ordre de création. Parce que l'ensemencement peut impliquer des relations complexes, les sèches gérent généralement les relations en garantissant la création de modèles parents avant les modèles d'enfants pour se conformer aux contraintes de base de données (par exemple, des clés étrangères). Par exemple, dans une relation dans laquelle un utilisateur appartient à une organisation, les Seerser créeraient d'abord l'organisation, puis créeraient l'utilisateur avec une clé étrangère appropriée reliant à l'organisation.

Les semoirs peuvent manipuler ou coordonner la création de données dans n'importe quel ordre et combiner des ensembles de données simples ou complexes, parfois avec une manipulation explicite de clés étrangères ou de tables de pivot dans des relations multiples-à-plusieurs. Ils gèrent souvent l'orchestration dont les usines ne sont pas responsables, comme décider de la séquence de l'ensemencement pour satisfaire les règles d'intégrité des données sur plusieurs tables.

Complexité et modèles de la relation

Les usines définissent généralement les relations de modèle simples ou imbriquées à l'aide de méthodes intégrées qui génèrent les enregistrements connexes à la demande. Ils se concentrent sur les opérations de création atomique - créant un modèle et ses relations immédiates en un seul appel. Par exemple, une usine pour un utilisateur peut définir une relation pour créer plusieurs messages automatiquement ou un profil qui appartient à l'utilisateur, générant une structure JSON imbriquée de modèle de manière transparente.

Les semoirs doivent définir explicitement comment les données liées à des modèles éventuellement créées seront créées dans le bon ordre. Ils pourraient d'abord créer toutes les organisations, puis tous les utilisateurs (associer les utilisateurs à des organisations), puis créer des publications liées aux utilisateurs. Cette ordonnance doit être maintenue pour satisfaire les contraintes de clés étrangères. Les semoirs gèrent également des scénarios complexes comme l'ensemencement conditionnel, l'ensemencement basé sur l'environnement ou la création de données uniquement s'il n'existe pas déjà.

Relations de plusieurs à plusieurs

Gérer les relations multiples-à-plusieurs est plus impliquée. Les usines résument cela en permettant à la création de relations à l'aide d'usines de table de pivot ou à travers des méthodes comme «attach ()» dans Laravel, souvent à l'intérieur de la définition d'usine ou après la création d'usine. Cela facilite la génération de modèles associés et les relie automatiquement avec les données de pivot.

Les semoirs, quant à eux, coordonnent explicitement les liens de plusieurs à plusieurs en créant d'abord des instances des deux modèles, puis invoquant les inserts de table pivot, soit par des méthodes de relation éloquentes, soit des requêtes de base de données directes. Les semoirs gèrent la population de tables de pivot en liant des ID et peut-être en ajoutant des champs de données de pivot supplémentaires, en veillant à ce que la base de données reflète des connexions interdémilles correctes.

Dépendances des clés étrangères

Les usines gèrent souvent les dépendances des clés étrangères dans leurs définitions. Lorsqu'une usine crée un modèle qui dépend d'une autre, il peut nicher les usines liées pour générer automatiquement le parent ou les modèles connexes. Cette approche réduit le risque de référence à des enregistrements inexistants et rationalise la création d'ensembles de données valides pour les tests.

Les semoirs doivent gérer explicitement les dépendances des clés étrangères, nécessitant souvent une commande minutieuse de la population de table pour respecter ces contraintes. Il est habituel dans les semoirs de créer d'abord le parent ou des modèles référencés, puis d'utiliser leurs clés principales pour lier les modèles dépendants. Les semoirs agissent ainsi en tant qu'orchestrateurs gérant le flux de la population de bases de données en ce qui concerne l'intégrité relationnelle.

Réutilisabilité et composition

Les usines sont très réutilisables et composables. Ils peuvent être définis une fois et utilisés pour créer des instances autonomes ou des instances connexes avec des relations spécifiées à plusieurs reprises, en soutenant des flux de travail de test ou une génération répétée de données de graines avec des variantes.

Les semoirs ont tendance à être davantage de scripts procéduraux, moins réutilisables isolément, souvent axés sur un scénario de population de données ou une configuration environnementale particulière. Cependant, ils invoquent les usines comme des blocs de construction et composent ces appels dans un ordre significatif pour configurer un environnement de données complexe.

Transactions et isolement

Les usines créent des instances généralement isolément ou dans le cadre d'un seul appel d'usine, qui pourrait être enveloppé dans une transaction pour les tests, mais généralement pas. Ils se concentrent sur la génération du modèle et de ses relations en une seule fois.

Les semoirs enveloppent souvent de grandes séquences de population de données dans les transactions de base de données pour garantir que l'ensemble de l'opération de semis réussit ou échoue, empêchant des données partielles ou corrompues dans des tableaux connexes. Cette approche transactionnelle est essentielle lorsque les semoirs gèrent plusieurs modèles et relations interdépendants.

Avantages et cas d'utilisation

L'utilisation d'usines pour les relations est avantageuse dans les scénarios nécessitant une génération rapide et isolée de données de test ou dans les tests eux-mêmes. Ils simplifient la création de modèles connexes sans intervention manuelle, permettant aux développeurs de se concentrer sur les tests au lieu de la configuration des données manuelles.

Les semoirs sont préférés pour la configuration de l'environnement, la population initiale de données ou les scénarios d'ensemencement complexes où l'ordre et la logique de la population de bases de données sont importants, y compris les dépendances multimodèles et la conformité logique métier. Les Seeds invoquent les usines et les opérations de base de données directes pour fournir un état de base de données entièrement prêt pour le développement ou la mise en scène.

Exemple pratique

Envisagez de créer des utilisateurs et leurs publications:

- Avec les usines, on peut définir dans l'usine d'utilisateurs une relation pour créer des messages automatiquement, donc lorsqu'un utilisateur est créé via l'usine, les messages connexes sont créés automatiquement.

- Avec les Seedrs, le Seeder crée d'abord les utilisateurs utilisant l'usine d'utilisateurs. Ensuite, séparément, il utilise la post-usine pour créer des publications, en les associant explicitement aux utilisateurs dans une boucle ou un lot, en garantissant une intégrité référentielle.

Les usines se concentrent sur l'encapsulation de la logique relationnelle à l'intérieur du processus de création de modèle lui-même. Les semoirs se concentrent sur l'orchestration et l'ordre qui assure un état global de base de données cohérent.

Résumé

Les usines gèrent les relations en intégrant la logique de création relationnelle dans les définitions d'usine, permettant la création automatique et imbriquée de modèles connexes. Ils favorisent la simplicité et la réutilisabilité lors de la génération d'ensembles uniques ou petits de modèles connexes, parfaits pour les tests et la génération rapide de fausses données.

Les semoirs gérent les relations en orchestrant l'ordre et le flux de processus complets de population de bases de données, garantissant que les modèles connexes sont créés dans un ordre cohérent et avec des clés étrangères valides. Ils utilisent des usines comme éléments constitutifs mais émettent la responsabilité de la gestion des dépendances complexes inter-modèles, des données spécifiques à l'environnement et de la cohérence transactionnelle dans l'ensemble de l'opération d'ensemencement.