Viele zu viele "Selbst" -Relationen SQLite: Ist das möglich?

Question

Ich benutze SQLite.net und SQLite-Net Extensions. Ich möchte eine Viele-zu-viele-Beziehung schaffen.
In meinem Fall habe ich eine Kindklasse mit einigen Geschwistern, natürlich sind die Geschwister noch vom Kindtyp. Deshalb habe ich versucht, eine ManyToMany Beziehung zu implementieren:

Kinder Klasse

[ManyToMany(typeof(Brotherhood), CascadeOperations = CascadeOperation.All)] 
public List<Child> Siblings_DB { get; set; } 

Bruderschaft Klasse

class Brotherhood 
{ 
    [ForeignKey(typeof(Child))] 
    public int ID_child1 { get; set; } 

    [ForeignKey(typeof(Child))] 
    public int ID_child2 { get; set; } 

} 

, dass alle Arbeit sein sollte.
Dann erstelle ich ein Child und Geschwister in der Siblings Liste hinzufügen, aber wenn ich versuche, die Klasse in der DB speichern mit InsertOrReplaceWithChildren(Child,true) nur ID_child1 aktualisiert und ID_child2 Aufenthalt auf 0
Jede Idee? Was mache ich falsch?
Alex

Answer 1

Nach einigen Versuchen gelang es mir, die viele zu viele Selbstbeziehung zu realisieren, ich war nur ein wenig verwirrt, zwei manytomany Beziehung in der gleichen Klasse zu haben: Ich fragte mich welcher der "offizielle" war. Irgendwann habe ich verstanden, dass beides war! Und die Summe der Geschwister war die Summe der beiden Listen.

[ManyToMany(typeof(Brotherhood), "ChildID1", "Siblings_DB_support", CascadeOperations = CascadeOperation.All)] 
public List<Child> Siblings_DB { get; set; } 
[ManyToMany(typeof(Brotherhood), "ChildID2", "Siblings_DB", CascadeOperations = CascadeOperation.All)] 
public List<Child> Siblings_DB_support { get; set; } 

Und die Beziehung Tabelle:

public class Brotherhood 
{ 
    [ForeignKey(typeof(Child))] 
    public int ChildID1 { get; set; } 

    [ForeignKey(typeof(Child))] 
    public int ChildID2 { get; set; } 
} 

Answer 2

Das Datenbankschema muss zuerst mit dem, was Sie versuchen, kompatibel sein. Eine Seite von jede Beziehung muss ein Schlüsselattribut oder eine Menge von Attributen sein, also können Sie keine Viele-zu-Viele-Selbstbeziehung haben. Wenn Sie jedoch eine andere Tabelle für die verknüpften Zeilen erstellen und einen kombinierten Schlüssel mit zwei Kopien des Schlüsselattributs [s] aus der einen Tabelle erstellen, für die Sie die Beziehung erstellen möchten, können Sie dies tun.

sagen, dass die Tabellenschlüssel myPK ist, dann eine zweite Tabelle erstellen gestattet, sagen myM2M mit einem zweispaltigen Primärschlüsselattribute enthält und myPK2, die zusammen das Stück dieser neuen Tabellenform bilden dann eine Beziehung zwischen den beiden Diese Spalten mit der Spalte myPK in der ersten Tabelle.

Haben Sie sich this angesehen?

Answer 3

In diesem Szenario explizit Fremdschlüssel und inverse Beziehungen in der Eigenschaft Attribute angeben.

public class TwitterUser { 
    [PrimaryKey, AutoIncrement] 
    public int Id { get; set; } 

    public string Name { get; set; } 

    [ManyToMany(typeof(FollowerLeaderRelationshipTable), "LeaderId", "Followers", 
     CascadeOperations = CascadeOperation.All)] 
    public List<TwitterUser> FollowingUsers { get; set; } 

    // ReadOnly is required because we're not specifying the followers manually, but want to obtain them from database 
    [ManyToMany(typeof(FollowerLeaderRelationshipTable), "FollowerId", "FollowingUsers", 
     CascadeOperations = CascadeOperation.CascadeRead, ReadOnly = true)] 
    public List<TwitterUser> Followers { get; set; } 
} 

// Intermediate class, not used directly anywhere in the code, only in ManyToMany attributes and table creation 
public class FollowerLeaderRelationshipTable { 
    public int LeaderId { get; set; } 
    public int FollowerId { get; set; } 
} 

---

Wenn Ihre Beziehung ein „Bruder-Bruder“ anstelle von „Eltern-Kindern“ sind Sie beiden Beziehungen summieren müssen, zum Beispiel:

public class Person { 
    [PrimaryKey, AutoIncrement] 
    public int Id { get; set; } 

    public string Name { get; set; } 

    [ManyToMany(typeof(BrothersRelationshipTable), "OldBrotherId", "YoungerBrothers", 
     CascadeOperations = CascadeOperation.All)] 
    public List<Person> OlderBrothers { get; set; } 

    [ManyToMany(typeof(BrothersRelationshipTable), "YoungBrotherId", "OlderBrothers", 
     CascadeOperations = CascadeOperation.CascadeRead, ReadOnly = true)] 
    public List<Brothers> YoungerBrothers { get; set; } 

    [Ignore] 
    publc List<TwitterUser> Brothers { 
     get { return YoungerBrothers.Concat(OlderBrothers).ToList() } 
    } 
} 

// Intermediate class, not used directly anywhere in the code, only in ManyToMany attributes and table creation 
public class BrothersRelationshipTable { 
    public int OldBrotherId { get; set; } 
    public int YoungBrotherId { get; set; } 
}