Tables de liens many-to-many dans grails (GORM)/hibernate

Question

Je joue avec les Grails et je trouve les choses ORM fastidieuses parce que je ne comprends pas vraiment ce que je fais quand il s'agit de classes de domaine. J'espère que quelqu'un peut me mettre sur la bonne voie

Considérez ce qui suit

test Job One: Beaucoup matériel utilisé sur Job Many: Un matériel physique

... Ceci est analogue à l'ordre classique, OrderLine, scénario de produit vu dans les exemples universitaires de DB

J'ai créé les classes de domaine suivants

class Job 
{ 
    String jobName 
    String jobDescription 
} 

class HardwareOnJob 
{ 
    static hasMany = [ jobs:Job, physicalHardware:PhysicalHardware ] 
    static belongsTo = Job 

    String role 
} 

class PhysicalHardware 
{ 
    String assetName 
    String model 
    String os 
} 

La question que je dois me poser est pourquoi Grails crée-t-il deux tables supplémentaires dans ma base de données plutôt que d'utiliser la classe d'entité de liaison/domaine que j'ai définie. Par exemple, Grails crée hardware_on_job_job et hardware_on_job_physical_hardware dans la base de données. En utilisant les contrôleurs d'échafaudage, je peux entrer du matériel, entrer un travail, puis entrer les deux en même temps. La question que j'ai est pourquoi est-ce créer ces deux tables supplémentaires plutôt que d'utiliser l'objet de domaine (HardwareOnJob) que j'ai spécifié.

Toute aide/orientation serait très appréciée en allant de l'arrière en regardant ça et en essayant de nouvelles choses. Btw Je suis sur grails version 1.2.1

Answer 1

Lors de l'utilisation de relations un à plusieurs ou plusieurs à plusieurs, grails crée une table de jointure contenant les ID des objets dans la relation. Vous pouvez éviter d'utiliser la table de jointure en demandant à grails d'utiliser une clé étrangère dans une relation un à plusieurs. À ma connaissance, il n'y a aucun moyen d'éviter d'utiliser la table de jointure créée automatiquement dans une relation plusieurs à plusieurs. Pour plus d'informations voir les sections 5.2.1.2 et 5.2.1.3 de this ainsi que this

Answer 2

Ok, donc après avoir joué, je suis venu avec autour de la structure suivante

class Job 
{ 
    String jobName 
    String jobDescription 

    static mapping = { 
    id column:"jobId" 
    } 

    static hasMany = [hardware:HardwareOnJob] 
} 

class HardwareOnJob 
{ 
    String role 
    Job job 
    PhysicalHardware hardware 


    static mapping = { 
    id column:"hardware_on_job_id" 
    } 

} 

class PhysicalHardware 
{ 
    String assetName 
    String model 
    String os 

    static mapping = { 
    id column:"physical_hardware_id" 
    } 

    static hasMany = [hardwareOnjob:HardwareOnJob] 
} 

Est-ce que ce regard raisonnable à tout le monde ? La structure de la base de données qui a été créée semble beaucoup plus conviviale et n'a que les trois tables que j'attends. Intéressé à entendre les pensées des gens car je viens d'un arrière-plan relationnel. Je regarde la création de l'objet comme un moyen de donner un design de base de données clair du point de vue de la garder simple de signaler contre.

commentaires sont les bienvenus

Answer 3

Jetez un oeil sur le mot-clé joinTable qui:

Personnalise la jointure table utilisée pour unidirectionnelle un à plusieurs, plusieurs à plusieurs et types de collections primitifs

Voici l'exemple de la mode d'emploi:

class Book { 
    String title 
    static belongsTo = Author 
    static hasMany = [authors:Author] 

    static mapping = { 
     authors joinTable:[name:"mm_author_books", key:'mm_book_id' ] 
    } 
} 
class Author { 
    String name 
    static hasMany = [books:Book] 

    static mapping = { 
     books joinTable:[name:"mm_author_books", key:'mm_author_id'] 
    } 

} 

Answer 4

pensez à utiliser une classe/table d'association explicite.voir la classe d'appartenance dans http://www.grails.org/Many-to-Many+Mapping+without+Hibernate+XML

un avantage secondaire est un échafaudage pour la classe d'association (vous ne l'obtiendrez pas sans une classe d'association explicite).

Answer 5

En bref, si l'enfant a exactement un parent, puis à Parent, vous mettre

static hasMany = [children: Child] 

et enfant, vous mettez

static belongsTo = [parent: Parent] 

(ou si vous ne voulez pas en cascade, je pense que juste ajouté "Parent parent" serait suffisant, mais c'est un cas plus rare que je devrais)

Cela crée une relation bidirectionnelle, en ce que dans un objet de domaine enfant, vous pouvez accéder à l'objet parent t par la propriété, et dans un objet parent, vous avez la collection enfants.

Normalement, cela créera une colonne dans Child, en conservant l'identifiant de son parent. Cela ne peut pas être le cas pour de nombreuses personnes, lorsqu'une sorte de table de liens sera nécessaire (et GORM peut gérer cela). Les soi-disant « à sens unique » relations (que vous avez dans votre premier exemple) peuvent également créer des tables de liaison, ce qui est expliqué un peu par ceci:

http://grails.1312388.n4.nabble.com/Many-to-many-vs-Many-to-one-td1369336.html