Hubungan banyak ke banyak phpmyadmin

Sebelum kita mulai membangun hubungan banyak-ke-banyak, mari mundur selangkah dan diskusikan apa sebenarnya hubungan itu. Untuk melakukan itu kita akan menggunakan contoh film dan aktor. Sebuah film dapat memiliki banyak aktor dan satu aktor dapat bekerja di beberapa film. Artinya setiap aktor terhubung dengan banyak film dan setiap film terhubung dengan banyak aktor

Di sini kita akan mulai dengan desain database. Jika Anda ingin belajar mengatur proyek sekuel Anda, Anda dapat melihat artikel saya sebelumnya, Hubungan Satu ke Satu di Database MYSQL Menggunakan Sequelize ORM

Pertanyaan. Mengapa Anda tidak bisa meletakkan kunci asing di meja film atau meja aktor?

Yah, itu cukup sederhana jika Anda memikirkannya. Katakanlah Anda meletakkan kunci asing di meja film dan seperti ini

Sekarang, seperti yang Anda lihat, kami mengulang data di baris yang berbeda dan itu akan membuat kekacauan besar. Untuk mengatasi ini kita akan menggunakan sesuatu yang disebut tabel persimpangan. Ini akan menjadi meja ketiga selain meja aktor dan film. Dan tabel terakhir kita akan terlihat seperti ini

Meja Film

Meja Aktor

Junction Table untuk menunjukkan hubungan antara aktor dan film

Seperti yang dapat Anda lihat dengan jelas, kami telah membuat hubungan banyak-ke-banyak dalam skema kami menggunakan tabel persimpangan ketiga. Sekarang yang harus dilakukan hanyalah membuatnya menggunakan sekuel

Jalankan kode vs Anda, atau editor kode apa pun yang Anda sukai, siapkan proyek lanjutan, dan sambungkan ke database. Saya telah memberikan tautan ke artikel saya sebelumnya di mana Anda dapat melihat bagaimana melakukannya. Juga, jalankan perintah nodemon app. js, ini akan membuat server Anda tetap berjalan
Mari kita mulai dengan membuat model film kita terlebih dahulu
Buka folder model di direktori root dan buat file bernama movie. js. File ini akan menjadi definisi model kita, ini akan memiliki ID penambahan otomatis yang akan digunakan sebagai kunci utama dan nama film. Untuk melakukan ini, rekatkan kode berikut di file yang baru saja Anda buat

1
2
3
4
5
6
7
8
9
10
11
12
13
module.exports = (sequelize, DataTypes) => {
  const Movie = sequelize.define("Movie", {
    id: {
      type: DataTypes.INTEGER,
      autoIncrement: true,
      primaryKey: true
    },
    name: {
      type: DataTypes.STRING,
    },
  });
  return Movie;
};

Sekarang mari kita buat tabel aktor. Di folder yang sama, buat file bernama aktor. js, dan rekatkan kode berikut

1
2
3
4
5
6
7
8
9
10
11
12
13
module.exports = (sequelize, DataTypes) => {
  const Actor = sequelize.define("Actor", {
    id: {
      type: DataTypes.INTEGER,
      autoIncrement: true,
      primaryKey: true
    },
    name: {
      type: DataTypes.STRING,
    },
  });
  return Actor;
};

Jika sekarang Anda pergi ke meja kerja MySQL dan menyegarkan tabel, maka Anda akan dapat melihat kedua tabel tersebut

Mari buat beberapa API untuk mengisi tabel ini dengan data dan setelah ini, kita akan membuat tabel persimpangan

Ini adalah API untuk membuat data di tabel film

1
2
3
4
5
6
7
8
9
app.post("/movie", async (req, res) => {
  const data = req.body;
  try {
    const Movie = await db.Movie.create(data);
    res.send(Movie);
  } catch (err) {
    res.send(err);
  }
});

Sekarang tekan permintaan posting di url dan kirim data berikut di badan

1
2
3
{
  "name": "Harry Potter"
}

Anda akan melihat nilai berikut di output

1
2
3
4
5
6
{
  "id": 1,
  "name": "Harry Potter",
  "updatedAt": "2021-09-29T16:32:11.061Z",
  "createdAt": "2021-09-29T16:32:11.061Z"
}

Ulangi proses ini untuk film sebanyak yang Anda inginkan. Pada akhirnya, tabel film kita terlihat seperti ini

Mari buat API untuk menambahkan data ke tabel aktor

1
2
3
4
5
6
7
8
9
10
app.post('/actor', async (req, res) => {

  const data = req.body;
  try {
    const Actor = await db.Actor.create(data);
    res.send(Actor);
  } catch (err) {
    res.send(err);
  }
})

Sekarang tekan permintaan posting di URL http. // localhost. 3000/aktor dan kirim data berikut di badan

1
2
3
{
  "name": "Emma Watson"
}

Outputnya akan terlihat seperti ini

1
2
3
4
5
6
{
  "id": 1,
  "name": "Emma Watson",
  "updatedAt": "2021-09-29T16:38:12.655Z",
  "createdAt": "2021-09-29T16:38:12.655Z"
}

Ulangi proses ini untuk aktor sebanyak yang Anda inginkan. Pada akhirnya, tabel aktor kita terlihat seperti ini

Saya sedang menulis aplikasi lengkap saya. js di sini untuk referensi Anda

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
const express = require("express");
const app = express();
const PORT = 3000;
const db = require("./models");
app.use(express.json());
app.use(express.urlencoded({
  extended: false
}));

app.post("/movie", async (req, res) => {
  const data = req.body;
  try {
    const Movie = await db.Movie.create(data);
    res.send(Movie);
  } catch (err) {
    res.send(err);
  }
});

app.post('/actor', async (req, res) => {

  const data = req.body;
  try {
    const Actor = await db.Actor.create(data);
    res.send(Actor);
  } catch (err) {
    res.send(err);
  }
})

db.sequelize
  .sync()
  .then((result) => {
    app.listen(3000, () => {
      console.log("Server started");
    });
  })
  .catch((err) => {
    console.log(err);
  });

Sekarang mari kita buat tabel persimpangan. Buat persimpangan. js di file model Anda. Ini akan memiliki id penambahan otomatis, movieId, actorId, dan akan memiliki dua asosiasi, satu ke tabel film melalui movieId dan lainnya ke tabel aktor melalui actorId. Rekatkan kode berikut di persimpangan. js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
module.exports = (sequelize, DataTypes) => {
  const Junction = sequelize.define("Junction", {
    id: {
      type: DataTypes.INTEGER,
      autoIncrement: true,
      primaryKey: true
    },
    movieId: {
      type: DataTypes.INTEGER,
    },
    actorId: {
      type: DataTypes.INTEGER,
    },
  });
  Junction.associate = models => {
    Junction.belongsTo(models.Actor, {
      foreignKey: 'actorId'
    });
    Junction.belongsTo(models.Movie, {
      foreignKey: 'movieId'
    });
  }
  return Junction;
};

Sekarang, akhirnya tabel persimpangan kita sudah siap, dan saatnya mengisi data menggunakan API. Buat API berikut di app. js

1
2
3
4
5
6
7
8
9
10
11
12
13
module.exports = (sequelize, DataTypes) => {
  const Actor = sequelize.define("Actor", {
    id: {
      type: DataTypes.INTEGER,
      autoIncrement: true,
      primaryKey: true
    },
    name: {
      type: DataTypes.STRING,
    },
  });
  return Actor;
};

Sekarang tekan permintaan posting di URL http. // localhost. 3000/junction dan kirim data berikut di body

1
2
3
4
5
6
7
8
9
10
11
12
13
module.exports = (sequelize, DataTypes) => {
  const Actor = sequelize.define("Actor", {
    id: {
      type: DataTypes.INTEGER,
      autoIncrement: true,
      primaryKey: true
    },
    name: {
      type: DataTypes.STRING,
    },
  });
  return Actor;
};

Anda akan melihat output berikut,

1
2
3
4
5
6
7
8
9
10
11
12
13
module.exports = (sequelize, DataTypes) => {
  const Actor = sequelize.define("Actor", {
    id: {
      type: DataTypes.INTEGER,
      autoIncrement: true,
      primaryKey: true
    },
    name: {
      type: DataTypes.STRING,
    },
  });
  return Actor;
};

Sekarang ulangi proses ini untuk menautkan film dan aktor yang sesuai. Seperti inilah tampilan tabel persimpangan saya pada akhirnya

Cara membuat banyak

Bagaimana Anda menyelesaikan banyak

Bagaimana cara menampilkan hubungan di phpMyAdmin?

Bagaimana Anda membuat banyak