FindAll umfassen mehrere Tabellen auf sequelize Abfrage

Question

Ich habe die folgende Abfrage auf meinem Server-Controller, wo ich alle Daten von al Associate Tabellen bringen für meinen Kurs:

db.Course.findAll({ 
    include: [ 
     // {model:db.Room, attributes:['id','DisplayLabel']}, 
     // {model:db.Period, attributes:['id','DisplayName']}, 
     {model:db.Subject, attributes:['id','Name']}, 
     // {model:db.Schedule, attributes:['id','Day','StartHour','EndHour']}, 
     {model:db.Person, where : { id : db.Course.PersonId}}, 
    ]} 

Der Kursmodell Verein ist wie folgt:

Course.hasMany(models.Schedule); 

Course.belongsTo(models.Period); 
Course.belongsTo(models.Room); 
Course.belongsTo(models.Subject); 
Course.belongsTo(models.School); 
Course.belongsTo(models.Person); 

das Problem ist, dass ich nicht die „Person“ Daten sQL-Protokoll zeigt dazu führen, dass das geht den Weg durch andere Tabelle Associate verbindet alle mit der Person Modell erhalten kann:

verbose: Executing (default): SELECT `Course`.`id`, `Course`.`Scholarship`, `Course`.`Level`, `Course`.`CourseType`, `Course`.`RecordStatus`, `Course`.`DeletedAt`, `Course`.`createdAt`, `Course`.`updatedAt`, `Course`.`PeriodId`, `Course`.`RoomId`, `Course`.`SubjectId`, `Course`.`SchoolId`, `Course`.`PersonId`, `Course`.`CreatedById`, `Course`.`UpdateById`, `Course`.`DeleteById`, `Subject`.`id` AS `Subject.id`, `Subject`.`Name` AS `Subject.Name`, `People`.`id` AS `People.id`, `People`.`RFC` AS `People.RFC`, `People`.`FirstName` AS `People.FirstName`, `People`.`LastName` AS `People.LastName`, `People`.`LastName2` AS `People.LastName2`, `People`.`Phone` AS `People.Phone`, `People`.`Cellphone` AS `People.Cellphone`, `People`.`Email` AS `People.Email`, `People`.`Birthday` AS `People.Birthday`, `People`.`RecordStatus` AS `People.RecordStatus`, `People`.`DeletedAt` AS `People.DeletedAt`, `People`.`createdAt` AS `People.createdAt`, `People`.`updatedAt` AS `People.updatedAt`, `People`.`RoleId` AS `People.RoleId`, `People`.`SchoolId` AS `People.SchoolId`, `People`.`TutorId` AS `People.TutorId`, `People`.`CreatedById` AS `People.CreatedById`, `People`.`UpdateById` AS `People.UpdateById`, `People`.`DeleteById` AS `People.DeleteById`, `People.Task`.`Title` AS `People.Task.Title`, `People.Task`.`Content` AS `People.Task.Content`, `People.Task`.`Grade` AS `People.Task.Grade`, `People.Task`.`OtherDetails` AS `People.Task.OtherDetails`, `People.Task`.`TaskType` AS `People.Task.TaskType`, `People.Task`.`RecordStatus` AS `People.Task.RecordStatus`, `People.Task`.`DeletedAt` AS `People.Task.DeletedAt`, `People.Task`.`createdAt` AS `People.Task.createdAt`, `People.Task`.`updatedAt` AS `People.Task.updatedAt`, `People.Task`.`KardexId` AS `People.Task.KardexId`, `People.Task`.`PersonId` AS `People.Task.PersonId`, `People.Task`.`CourseId` AS `People.Task.CourseId`, `People.Task`.`CreatedById` AS `People.Task.CreatedById`, `People.Task`.`UpdateById` AS `People.Task.UpdateById`, `People.Task`.`DeleteById` AS `People.Task.DeleteById` FROM `Courses` AS `Course` LEFT OUTER JOIN `Subjects` AS `Subject` ON `Course`.`SubjectId` = `Subject`.`id` INNER JOIN (`Tasks` AS `People.Task` INNER JOIN `People` AS `People` ON `People`.`id` = `People.Task`.`PersonId`) ON `Course`.`id` = `People.Task`.`CourseId` AND `People`.`id` = NULL; 

Wie Sie sehen können sie die Spalten aus dem Task-Modell bringen, das ist eine Tabelle, die Ursprünge von Uhr: n Beziehung zwischen Kurs und Menschen

associate: function(models){ 
    models.Person.belongsToMany(models.Course, {through : Task}); 
    models.Course.belongsToMany(models.Person, {through : Task}); 
    } 

Auch wenn ich die Tabelle aus der Datenbank nur für Debug löschen Zweck macht es dasselbe mit einer anderen m: n Beziehung. Wie schließe ich das aus dem Join aus, um nur Daten zu erhalten?

Das Modell Person, Sie wundern sich, dass es alle verschiedenen Benutzer speichert: Student, Lehrer, Vater und es hat einen Fremdschlüssel des Rollenmodells, die diese RoleTypes haben. Aus diesem Grund habe ich im Kursmodell den Schlüssel PersonId, in diesem Fall den Teacher, und im Beispiel für die Aufgabe PersonId den Benutzer Student.

Answer 1

Ihre Abfrage verwendet die join Tabelle Task, weil Sie zwei Assoziationen zwischen Person und Course definieren. Der erste ist Course.belongsTo(Person) und der zweite ist m: n-Beziehung. Was passiert, ist, dass Sequelize einen von ihnen berücksichtigt - wie würde es wissen, dass Sie die belongsTo Assoziation statt m: n wollen? Um diese Situation zu verzichten Sie alias in den Verbänden

Course.belongsTo(models.Person, { as: 'Teacher' }); // example alias 

Und dann, um Course abrufen, könnte damit Teacher ist würden Sie die alias

db.Course.findAll({ 
    include: [ 
     { model: db.Person, as: 'Teacher' } 
    ] 
}).then((course) => { 
    // course with Teacher 
}); 

Sie enthalten haben, um das gleiche tun mit m: n Beziehung

models.Course.belongsToMany(models.Person, { as: 'Students', through: Task }); 

Und dann würden Sie die Students verwenden Alias, um alle Studenten des gegebenen Kurses zurückzugeben.

EDIT

Um andere Spaltennamen dann ModelId zu erhalten, müssen Sie foreignKey oder otherKey im Verein definieren. In Ihrem Fall in dem m: n Beziehung zwischen Course und Person wollen Sie StudentId statt PersonId haben, würden Sie otherKey

models.Course.belongsToMany(models.Person, { as: 'Students', through: Task, otherKey: 'StudentId' }); 

die jetzt verwenden Tabelle sowohl CourseId (Referenzierung Course Tabelle) und StudentId hätte kommen (Referenzieren Person Tabelle).

Hinweis: Wenn Sie auch die m definieren: n Beziehung auf Person Modell, denken Sie daran entsprechende Option hinzufügen - foreignKey, wie folgt aus:

models.Person.belongsToMany(models.Course, { as: 'Courses', through: Task, foreignKey: 'StudentId' });