Grails GORM: Wie erstelle ich einen zusammengesetzten Primärschlüssel, und verwenden Sie es für eine Tabelle Beziehung?

Ich habe zwei Tabellen, von denen eine (legacy-Tabelle: A) hat zwei Felder, die dazu dienen sollte, einen zusammengesetzten Fremdschlüssel und die andere (neue Tabelle: B) verwenden Sie einen zusammengesetzten Primärschlüssel für eine each row:A has one row:B Beziehung. Wie kann ich diese beschreiben Tabellen in Bezug auf GORM?

So weit ich habe in der Lage, erstellen Sie eine domain-Klasse, spiegelt das Erbe Tisch:Ein

class A {

    ...
    //composite foreign key to link B class
    String className;
    String eventName;

    B b; //instance of B to be related

    static mapping = {
        table 'a_table';            
        id column: 'id';
        className column: 'class_name';
        eventName column: 'event_name';
        //b: ???
    }
}

die funktioniert, aber ich kann nicht erstellen Sie eine new class:B und die Beziehung.

Habe ich versucht zu erklären, B:

class B implements Serializable{

    static auditable = true;

    String name;
    String className;
    String eventName;

    static mapping = {
        //supposed to make a composite PK
        id composite:[className, eventName] 
    }
}

aber dieser Code wird nicht kompiliert, mit ein
ERROR context.GrailsContextLoader - Error executing bootstraps: Error evaluating ORM mappings block for domain [com.package.B]: No such property: eventName for class: org.codehaus.groovy.grails.orm.hibernate.cfg.HibernateMappingBuilder

Was ich will, ist so etwas wie:

static mapping = {
    ...
    b composite: [b.className:className, b.eventName:eventName]
    //or whatever is the right way for this to be done.
}

für die A-Klasse zu machen GORM Griff dieser Beziehung.

InformationsquelleAutor svz | 2013-02-06

gorm grails

7

Haben Sie versuchen, zu verwenden, Attribut-Namen, anstatt Sie zu verwenden Attribut-Wert ?
```
class B implements Serializable{
    String name;
    String className;
    String eventName;

    static mapping = {
        //supposed to make a composite PK
        id composite:['className', 'eventName'] 
    }
}
```
- Und mapping-in :
```
class A {
    static hasMany = [ b : B ]
}
```
Kein Bedürfnis zu haben className oder eventName im A

Danke, das Teil funktioniert. Aber wie kann ich erklären, die Beziehung, die ich brauche?
Upps, zwei Fragen, aber nur eine Antwort... Bearbeiten

InformationsquelleAutor Isammoc

Die B-Klasse muss Serialisierbar deklariert und implementiert die equals-und hashCode-Methoden

import org.apache.commons.lang.builder.HashCodeBuilder
class B implements Serializable{

    static auditable = true;

    String name;
    String className;
    String eventName;
    boolean equals(other) {
    if (!(other instanceof B)) {
        return false
    }

    other.className == className && other.eventName == eventName
    }

    int hashCode() {
    def builder = new HashCodeBuilder()
    builder.append className
    builder.append eventName
    builder.toHashCode()
    }

    static mapping = {
        //supposed to make a composite PK
        id composite:["className", "eventName"] 
    }
}

und die A-Klasse muss ein Attribut der Klasse B und die GORM machen die zusammengesetzten Fremdschlüssel

class A {

    //composite foreign key to link B class
    B b; //instance of B to be related

    static mapping = {
        table 'a_table';            
        id column: 'id';
    }
}

erstellen Sie zwei Tabellen in der Datenbank

+--------------------------------------------------+
|                       A_TABLE                    |  
+--------+-----------+--------------+--------------+
|   id   |  version  |  b_className | b_eventName  |
+--------+-----------+--------------+--------------+
--where the Primary key is "id" and the foreign key are "b_className and b_eventName" 
+--------------------------------------------------+
|                       B                          |  
+--------+-----------+--------------+--------------+
|  name  |  version  |  className   | eventName    |
+--------+-----------+--------------+--------------+
--where the Primary key are "className and eventName"

wenn Sie, was Sie ändern den Namen der Spalten, andere fügen Sie einfach die clausule in der mapping-Anweisung

class A {

    //composite foreign key to link B class
    B b; //instance of B to be related

    static mapping = {
        table 'a_table';            
        id column: 'id';
        columns {
              b {
                 column name: "className"
                 column name: "eventName"
              }
        }
    }
}

InformationsquelleAutor ladriangb

import org.apache.commons.lang.builder.HashCodeBuilder
class Person implements Serializable {

String firstName
String lastName

boolean equals(other) {
    if (!(other instanceof Person)) {
        return false
    }

    other.firstName == firstName && other.lastName == lastName
}

int hashCode() {
    def builder = new HashCodeBuilder()
    builder.append firstName
    builder.append lastName
    builder.toHashCode()
}

static mapping = {
    id composite: ['firstName', 'lastName']
}
}

dies ist, was finden Sie von der offiziellen docs von grails,

http://grails.org/doc/latest/guide/GORM.html#compositePrimaryKeys

nur blind Folgen diese und Ihr problem wird gelöst werden. für Erklärung siehe oben link

InformationsquelleAutor Rajesh Solo

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.