Entités

4D v19

ORDA

Entités

Une entité (entity) est un objet qui peut être vu comme une instance d'une dataclass, ou comme un enregistrement de la table correspondant à la dataclass dans son datastore associé. Toutefois, une entité contient également des données corrélées à la base de données associée au datastore. Le but de l'entité est de gérer les données (créer, mettre à jour, supprimer). Lorsqu'une référence d'entité est obtenue au moyen d'une sélection d'entités, elle conserve des informations sur la sélection d'entités, ce qui permet l'itération à travers la sélection.

Créer une entité

Il existe deux façons de créer une nouvelle entité dans une dataclass :

Comme les entités sont des références aux enregistrements de la base de données, vous pouvez créer des entités en créant des enregistrements via le langage 4D classique puis en les référençant avec des méthodes ORDA telles que entity.next( ) ou entitySelection.first( ).
Vous pouvez également créer une entité à l'aide de la méthode dataClass.new( ).

Gardez à l'esprit que l'entité est créée uniquement en mémoire. Si vous voulez l'ajouter au datastore, vous devez appeler la méthode entity.save( ).

Les attributs d'entité sont directement disponibles en tant que propriétés de l'objet entité. Pour plus d'informations, veuillez vous reporter à Utilisation des attributs d'entités.

Par exemple, nous voulons créer une nouvelle entité dans la dataclass "Employee" dans le datastore en cours avec "John" et "Dupont" assignés aux attributs prénom et nom :

 C_OBJET($myEntity)

 $myEntity:=ds.Employee.new() //Crée un nouvel objet de type entity

 $myEntity.name:="Dupont" // assigne 'Dupont' à l'attribut 'name'

 $myEntity.firstname:="John" //assigne 'John' à l'attribut 'firstname'

 $myEntity.save() //sauvegarde l'entité

Note : Une entité est définie uniquement dans le process où elle a été créée. Vous ne pouvez pas, par exemple, stocker la référence d'une entité dans une variable interprocess et l'utiliser dans un autre process.

Entités et références

Une entité contient une référence à un enregistrement 4D. Différentes entités peuvent référencer le même enregistrement 4D. De même, étant donné qu'une entité peut être stockée dans une variable objet 4D, différentes variables peuvent contenir une référence à la même entité.

Si vous exécutez le code suivant :

 C_OBJET($e1;$e2)

 $e1:=ds.Employee.get(1) //accède à l'employé avec l'ID 1

 $e2:=$e1

 $e1.name:="Hammer"

  //les deux variables $e1 et $e2 partagent la référence à la même entité

  //$e2.name contient "Hammer"

Ceci est illustré par le graphique suivant :

Maintenant si vous exécutez :

 C_OBJET($e1;$e2)

 $e1:=ds.Employee.get(1)

 $e2:=ds.Employee.get(1)

 $e1.name:="Hammer"

  //la variable $e1 contient une référence à une entité

  //la variable $e2 contient une autre référence à une autre entité

  //$e2.name contient "smith"

Ceci est illustré par le graphique suivant :

Notez cependant que les entités se réfèrent au même enregistrement. Dans tous les cas, si vous appelez la méthode entity.save( ), l'enregistrement sera mis à jour (sauf en cas de conflit, voir Verrouillage d'entités).

En fait, $e1 et $e2 ne sont pas l'entité elle-même, mais une référence à l'entité. Cela signifie que vous pouvez la passer directement à l'importe quelle fonction ou méthode, et elle agira comme un pointeur, et plus rapidement qu'un pointeur 4D. Par exemple :

 Pour chaque($entity;$selection)

    do_Capitalize($entity)

 Fin de chaque

Et la fonction est :

 $entity:=$1

 $name:=$entity.lastname

 Si(Non($name=Null))

    $name:=Majusc(Sous chaine($name;1;1))+Minusc(Sous chaine($name;2))

 Fin de si

 $entity.lastname:=$name

Vous pouvez gérer des entités comme n'importe quel autre objet dans 4D et transmettre leurs références directement en tant que paramètres.

Note : Avec les entités, il n'y a pas de concept d'"enregistrement courant" comme dans le langage 4D classique. Vous pouvez utiliser autant d'entités que vous le souhaitez, en même temps. Il n'y a pas non plus de verrou automatique sur une entité (voir Verrouillage d'entités). Lorsqu'une entité est chargée, elle utilise le mécanisme de 'Lazy loading', ce qui signifie que seules les informations nécessaires sont chargées. Néanmoins, en client / serveur, l'entité peut être chargée directement si nécessaire.

Utilisation des attributs d'entités

Les attributs d'entités stockent les données et mappent les champs correspondants dans la table correspondante. Les attributs d'entité de type storage peuvent être fixés ou récupérés en tant que simples propriétés de d'objet entité, tandis qu'une entité de type relatedEntity ou relatedEntities renvoie une entité ou une sélection d'entités.

Note : Pour plus d'informations sur le type d'attribut, reportez-vous au paragraphe Attributs de stockage et relationnel.

Par exemple pour définir un attribut storage :

 $entity:=ds.Employee.get(1) // récupère l'attribut Employé avec ID 1

 $name:=entity.lastname // récupère le nom de l'employé, par exemple "Smith"

 entity.lastname:="Jones" // définit le nom de l'employé

Note : Les attributs Image ne peuvent pas être assignés directement dans une entité avec un chemin donné.

L'accès à un attribut relié dépend du type d'attribut. Par exemple, avec la structure suivante :

Vous pouvez accéder aux données via le (ou les) objet(s) associé(s) :

 $entity:=ds.Project.all().first().theClient // récupère l'entité Compagnie (Company) associée au projet (Projet)

 $EntitySel:=ds.Company.all().first().companyProjects // permet d'obtenir la sélection des projets pour une Compagnie

Notez que theClient et companyProjects dans l'exemple ci-dessus sont des attributs relationnels primaires et représentent une relation directe entre les deux dataclasses. Cependant, les attributs relationnels peuvent également être construits avec des chemins via des relations à plusieurs niveaux, y compris des références circulaires. Par exemple, considérez la structure suivante :

Chaque employé peut être manager et peut avoir un manager. Pour obtenir le manager du manager d'un employé, vous pouvez simplement écrire :

 $myEmp:=ds.Employee.get(50)

 $manLev2:=$myEmp.manager.manager.lastname

Affectation de valeurs aux attributs relationnels

Dans l'architecture ORDA, les attributs relationnels contiennent directement des données relatives aux entités :

Un attribut relationnel de type N->1 (type relatedEntity) contient une entité
Un attribut relationnel de type 1->N (type relatedEntities) contient une sélection d'entités

Examinons la structure (simplifiée) suivante :

Dans cet exemple, une entité de la dataclass "Employee" contient un objet de type Entity dans l'attribut "employer" (ou une valeur null). Une entité de la dataclass "Company" contient un objet de type EntitySelection dans l'attribut "staff" (ou une valeur null).

Note : Dans ORDA, la propriété Automatique ou Manuel des relations n'a aucun effet.

Pour attribuer une valeur directement à l'attribut "employer", vous devez passer une entité existante de la dataclass "Company". Par exemple :

 $emp:=ds.Employee.new() // crée un employé

 $emp.lastname:="Smith" // assigne une valeur à un attribut

 $emp.employer:=ds.Company.query("name =:1";"4D")[0]  //assigne une entité Company

 $emp.save()

4D fournit une facilité supplémentaire pour entrer un attribut relationnel pour une entité "N" reliée à une entité "1" : vous passez directement la clé primaire de l'entité "1" lors de l'affectation d'une valeur à l'attribut relationnel. Pour que cela fonctionne, vous transmettez des données de type Nombre ou Texte (la valeur de la clé primaire) à l'attribut relationnel. 4D prend alors automatiquement en charge la recherche de l'entité correspondante dans la dataclass. Par exemple :

 $emp:=ds.Employee.new()

 $emp.lastname:="Wesson"

 $emp.employer:=2 // affecter une clé primaire à l'attribut relationnel

  //4D recherche la Société dont la clé primaire (dans ce cas, son ID) est 2

  //et l'assigne à l'Employé

 $emp.save()

Ceci est particulièrement utile lorsque vous importez de grandes quantités de données à partir d'une base de données relationnelle. Ce type d'importation contient généralement une colonne "ID", qui fait référence à une clé primaire que vous pouvez ensuite affecter directement à un attribut relationnel.
Cela signifie également que vous pouvez affecter des clés primaires dans les entités "N" sans que les entités correspondantes aient auparavant été créées dans la class "1" du datastore. Si vous affectez une clé primaire qui n'existe pas dans la class reliée du datastore, elle est néanmoins stockée et affectée par 4D dès que cette entité "1" est créée.

Vous pouvez affecter ou modifier la valeur d'un attribut d'une entité liée "1" à partir de la dataclass "N" directement via l'attribut relationnel. Par exemple, si vous souhaitez modifier l'attribut name d'une entité Company associée à une entité Employee, vous pouvez écrire :

 $emp:=ds.Employee.get(2) // charge l'entité "Employee" ayant la clé primaire 2

 $emp.employer.name:="4D, Inc." //modifie l'attribut "name"  de la "Company" liée

 $emp.employer.save() //enregistre l'attribut lié

  //l'entité reliée est mise à jour

A propos de l'objet entité

L'objet entity lui-même ne peut pas être copié en tant qu'objet :

$myentity:=OB Copier(ds.Employee.get(1)) //retourne null

Les propriétés de l'entité sont cependant énumérables :

 TABLEAU TEXTE($prop;0)

 OB LIRE NOMS PROPRIETES(ds.Employee.get(1);$prop)

  //$prop contient les noms de tous les attributs d'entités

Pour des besoins d'exportation, vous pouvez convertir une entité en un objet standard en utilisant la méthode entity.toObject( ). Vous pouvez ensuite exporter l'entité sous forme JSON, par exemple :

 C_OBJET($entity_json)

 $entity_json:=JSON Stringify($myentity.toObject()) //retourne l'entité sous forme JSON

Voir aussi

Verrouillage d'entités