Создайте базу данных для хранения имени модуля вместе с ним parent_module_id - PullRequest
Новая
       29

Создайте базу данных для хранения имени модуля вместе с ним parent_module_id

0 голосов
/ 08 января 2019

Хорошо, у меня есть таблица, в которой я храню имена всех модулей или программ, примерно так: 

+----+----------------+
|id  |module          |
+----+----------------+
|1   |node js         |
+----+----------------+
|2   |python          |
+----+----------------+
|3   |angular         |
+----+----------------+
|4   |ionic           |
+----+----------------+
|5   |tensorflow      |
+----+----------------+
|6   |jupyter notebook|
+----+----------------+

Теперь я хочу сохранить родительский модуль для всех модулей, таких как нам нужно установить nodejs, чтобы начать использовать ionic или для tensorflow нам нужно иметь python. Теперь у меня было два, я включил столбец с именем parent_id, который foreign_key ссылается на id той же таблицы. 

+----+----------------+----------+
|id  |module          |parent_id |
+----+----------------+----------+
|1   |node js         |null      |
+----+----------------+----------+
|2   |python          |null      |
+----+----------------+----------+
|3   |angular         |1         |
+----+----------------+----------+
|4   |ionic           |1         |
+----+----------------+----------+
|5   |tensorflow      |2         |
+----+----------------+----------+
|6   |jupyter notebook|2         |
+----+----------------+----------+

Это помогло мне дать родителям возможность иметь нескольких детей, как у nodejs было два ребенка, угловой и ионный.

Я использую sequelize и настроил ассоциацию как обычную ассоциацию. 

//--------- module.model.js------------//
'use strict';
module.exports = (sequelize, DataTypes) => {
  const Module = sequelize.define('Module', {
  }, {
    timestamps: false
  });
  module.associate = function(models) {
    Module.hasMany(Module, {
      foreignKey: 'parent_id',
    });
    Module.belongsTo(Module, {
      foreignKey: 'parent_id',
    });
  };
  return Module;
};

//--------------- index.js-------------//
const models = require('./models');  //module.models.js

async function start() {
  let modules = await models.Module.findAll({
    include: [{
      model: models.Module
    }]
  });
  console.log(modules);
}
start();

Вывод выглядит примерно так: 

[{id: 1, module: 'node js', Module: [
    {id: 3, module: 'angular'},
    {id: 4, module: 'ionic'}
  ]},
 {id: 2, module: 'python', Module: [
    {id: 5, module: 'tensorflow'},
    {id: 6, module: 'jupyter notebook'}
  ]},
 {id: 3, module: 'angular', Module: []},
 {id: 4, module: 'ionic', Module: []},
 {id: 5, module: 'tensorflow', Module: []},
 {id: 6, module: 'jupyter notebook', Module: []}]

что было вполне ожидаемо, но я хочу получить массив родительских модулей внутри дочерних записей, примерно так: 

[{id: 1, module: 'node js', Module: []},
 {id: 2, module: 'python', Module: []},
 {id: 3, module: 'angular', Module: [
    {id: 1, module: 'node js'}
  ]},
 {id: 4, module: 'ionic', Module: [
    {id: 1, module: 'node js'},
  ]},
 {id: 5, module: 'tensorflow', Module: [
    {id: 2, module: 'python'},
  ]},
 {id: 6, module: 'jupyter notebook', Module: [
    {id: 2, module: 'python'},
  ]}]

Я знаю, что могу изменить столбец parent_id на child id модулей сопоставления противоположным образом, но это исключает возможность того, что родитель имеет нескольких детей, и будет показывать только одного ребенка на одного родителя. 

+----+----------------+----------+
|id  |module          |child_id  |
+----+----------------+----------+
|1   |node js         |3         |
+----+----------------+----------+
|2   |python          |5         |
+----+----------------+----------+
|3   |angular         |null      |
+----+----------------+----------+
|4   |ionic           |null      |
+----+----------------+----------+
|5   |tensorflow      |null      |
+----+----------------+----------+
|6   |jupyter notebook|null      |
+----+----------------+----------+

Итак, как можно добиться желаемого результата и какие изменения необходимо внести в ассоциации или структуру всей таблицы, включив в нее третью таблицу, в которой будет два ключа доступа, ссылающихся на одну и ту же таблицу, что-то вроде этого, но это не выглядит настолько условно, или, честно говоря, я никогда не видел подобных вещей раньше, поэтому я не совсем уверен, правильно ли это или нет. 

  +-------------------------------------------------
  |                                     |          |
+----+----------------+        +----+---------+----------+
|id  |module          |        |id  |child_id |parent_id |
+----+----------------+        +----+---------+----------+
|1   |node js         |        |1   | 3       | 1        |
+----+----------------+        +----+---------+----------+
|2   |python          |        |2   | 4       | 1        |
+----+----------------+        +----+---------+----------+
|3   |angular         |        |3   | 5       | 2        |
+----+----------------+        +----+---------+----------+
|4   |ionic           |        |4   | 6       | 2        |
+----+----------------+        +----+---------+----------+
|5   |tensorflow      |
+----+----------------+
|6   |jupyter notebook|
+----+----------------+

И поэтому я запутался, как решить эту проблему, и я также оказался новичком и новичком. Заранее спасибо.

Ответы [ 3 ]

0 голосов
/ 08 января 2019

Вы можете создать связанную таблицу «многие ко многим», как это: -

CREATE TABLE Язык ( lng_id INT NOT NULL, lng_name VARCHAR (40) NOT NULL, Описание VARCHAR (100) NOT NULL, Изображение BLOB NOT NULL, ПЕРВИЧНЫЙ КЛЮЧ (lng_id)

CREATE TABLE dependency_lng ( lng_id1 INT NOT NULL, // FK относится к language.lng_id lng_id2 INT NOT NULL), // FK относится к language.lng_id CONSTRAINT pk_dependency_lng ПЕРВИЧНЫЙ КЛЮЧ (lng_id1, lng_id2)

Вы можете добавить столько записей, сколько хотите, вместе с внешними ключами, если того требует ваше требование.

P.S: --- Также, если вы хотите, автоинкрементный столбец не нужен. ПЕРВИЧНЫЙ КЛЮЧ может быть (lng_id1, lng_id2)

0 голосов
/ 12 января 2019

Будет работать само ссылающаяся ассоциация 

module.associate = function(models) {
  Module.belongsTo(Module, {
    foreignKey: 'parent_id',
    as:'parent'
  })
};

Обратите внимание, что нам нужно a belongsTo с as ассоциацией, а не hasMany.

так что с нормальным запросом 

let modules = await models.Module.findAll({
  include: [{
    model: models.Module,
    as:'parent'
  }]
});

и это приведет к желаемому результату 

[{id: 1, module: 'node js', Module: []},
 {id: 2, module: 'python', Module: []},
 {id: 3, module: 'angular', Module: [
    {id: 1, module: 'node js'}
  ]},
 {id: 4, module: 'ionic', Module: [
    {id: 1, module: 'node js'},
  ]},
 {id: 5, module: 'tensorflow', Module: [
    {id: 2, module: 'python'},
  ]},
 {id: 6, module: 'jupyter notebook', Module: [
    {id: 2, module: 'python'},
  ]}]
0 голосов
/ 08 января 2019

Надеюсь, вам нужна самостоятельная ассоциация. 

module.associate = function(models) {
    Module.hasMany(Module, {
      foreignKey: 'parent_id',
      as:'sub_entry'
    })
  };

Обратите внимание, что вам не нужно принадлежит ассоциации и вам нужно добавить ключевое слово as для этой ассоциации.

и ваш запрос 

let modules = await models.Module.findAll({
    include: [{
      model: models.Module,
      as:'sub_entry'
    }]

Надеюсь, это даст то, что вы ожидаете. Вам не нужна вспомогательная таблица для этого.

...