Mysql
 sql >> Base de données >  >> RDS >> Mysql

Guide pour concevoir une base de données pour le système de commande de restaurant dans MySQL

Ce didacticiel fournit des étapes complètes pour concevoir un schéma de base de données du système de commande du restaurant afin de gérer les utilisateurs, les réservations de table, les menus, l'inventaire, les commandes et les paiements. Il fournit la conception de la base de données des commandes de nourriture pour gérer les commandes de nourriture des restaurants. Il peut également être utilisé pour développer des applications de système de commande de restaurant sur site.

Ces systèmes de commande sont mis en œuvre pour automatiser le traitement des commandes et gérer efficacement les pics de commande, améliorant ainsi la satisfaction des clients avec moins d'efforts - une situation gagnant-gagnant pour les entreprises de restauration.

Le diagramme de relation d'entité ou la conception visuelle de la base de données est illustré ci-dessous.

Système de commande de restaurant

Remarques :Il peut être utilisé pour la réservation en ligne des tables et pré-commande avant d'arriver au restaurant. La sécurité peut également être gérée en suivant la base de données RBAC dans MySQL.

Vous pouvez également consulter les didacticiels populaires, notamment Comment installer MySQL 8 sur Ubuntu, Comment installer MySQL 8 sur Windows, Comment installer MySQL 8 avec Workbench sur Windows 10, Base de données RBAC dans MySql, Base de données de blogs dans MySql, Base de données de quiz dans MySQL, Base de données de sondage et d'enquête dans MySQL, base de données de panier d'achat en ligne et apprentissage des requêtes SQL de base dans MySQL.

Base de données des restaurants

La toute première étape consiste à créer la base de données des restaurants. Il peut être créé à l'aide de la requête comme indiqué ci-dessous.

CREATE SCHEMA `restaurant` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

J'ai utilisé le jeu de caractères utf8mb4 pour prendre en charge un large éventail de caractères.

Tableau des utilisateurs

Dans cette section, nous allons concevoir la table des utilisateurs pour stocker les informations de l'utilisateur. La même table peut être utilisée pour gérer différents types d'utilisateurs, notamment les administrateurs, les chefs, les agents et les clients. Il peut être utilisé pour relier les utilisateurs aux menus, aux articles, aux réservations de table et aux commandes. Les utilisateurs peuvent suivre leurs propres tables et commandes. Vous trouverez ci-dessous la description de toutes les colonnes de la table des utilisateurs.

Identifiant L'identifiant unique pour identifier l'utilisateur.
Prénom Le prénom de l'utilisateur.
Deuxième prénom Le deuxième prénom de l'utilisateur.
Nom de famille Le nom de famille de l'utilisateur.
Mobile Le numéro de portable de l'utilisateur. Il peut être utilisé à des fins de connexion et d'enregistrement.
E-mail L'adresse e-mail de l'utilisateur. Il peut être utilisé à des fins de connexion et d'enregistrement.
Hachage du mot de passe Le hachage du mot de passe généré par l'algorithme approprié. Nous devons éviter de stocker des mots de passe simples ou cryptés.
Administrateur L'indicateur pour identifier si l'utilisateur est un administrateur. Ce n'est pas obligatoire si les tables RBAC sont créées en suivant la conception de la base de données RBAC.
Fournisseur L'indicateur permettant d'identifier si l'utilisateur peut recevoir des commandes d'inventaire. Ce n'est pas obligatoire si les tables RBAC sont créées en suivant la conception de la base de données RBAC.
Chef L'indicateur pour identifier si l'utilisateur peut cuisiner les éléments. Ce n'est pas obligatoire si les tables RBAC sont créées en suivant la conception de la base de données RBAC.
Agent L'indicateur pour identifier si l'utilisateur peut héberger une table. Ce n'est pas obligatoire si les tables RBAC sont créées en suivant la conception de la base de données RBAC.
Enregistré à Cette colonne peut être utilisée pour calculer la durée de vie de l'utilisateur avec l'application.
Dernière connexion Il peut être utilisé pour identifier la dernière connexion de l'utilisateur.
Introduction La brève présentation de l'utilisateur vendeur à afficher sur la page produit.
Profil Les détails du fournisseur à afficher sur la page produit.

La table utilisateur avec les contraintes appropriées est illustrée ci-dessous.

CREATE TABLE `restaurant`.`user` (
  `id` BIGINT NOT NULL AUTO_INCREMENT,
  `firstName` VARCHAR(50) NULL DEFAULT NULL,
  `middleName` VARCHAR(50) NULL DEFAULT NULL,
  `lastName` VARCHAR(50) NULL DEFAULT NULL,
  `mobile` VARCHAR(15) NULL,
  `email` VARCHAR(50) NULL,
  `passwordHash` VARCHAR(32) NOT NULL,
  `admin` TINYINT(1) NOT NULL DEFAULT 0,
  `vendor` TINYINT(1) NOT NULL DEFAULT 0,
  `chef` TINYINT(1) NOT NULL DEFAULT 0,
  `agent` TINYINT(1) NOT NULL DEFAULT 0,
  `registeredAt` DATETIME NOT NULL,
  `lastLogin` DATETIME NULL DEFAULT NULL,
  `intro` TINYTEXT NULL DEFAULT NULL,
  `profile` TEXT NULL DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE INDEX `uq_mobile` (`mobile` ASC),
  UNIQUE INDEX `uq_email` (`email` ASC) );

Tableaux des ingrédients, des articles, des recettes et des menus

Dans cette section, nous allons concevoir les tableaux d'ingrédients, d'articles, de recettes et de menus pour stocker les données des menus et des éléments.

Vous trouverez ci-dessous la description de toutes les colonnes du tableau des ingrédients . Le tableau des ingrédients est également mappé pour identifier le fournisseur qui peut fournir l'ingrédient pour réapprovisionner l'inventaire. Dans un scénario plus avancé, il peut y avoir une table distincte pour stocker l'ingrédient et la relation fournisseur afin de prendre en charge plusieurs fournisseurs pour le même ingrédient.

Identifiant L'identifiant unique pour identifier l'ingrédient.
Identifiant utilisateur L'identifiant d'utilisateur pour identifier l'administrateur.
Identifiant du fournisseur L'identifiant du vendeur pour identifier le fournisseur.
Titre Le titre de l'ingrédient à afficher sur la recette de l'article.
limace Le slug unique à utiliser comme GID de l'ingrédient.
Résumé Le résumé pour mentionner les principaux faits saillants.
Type Le type permettant de distinguer les différents types d'ingrédients.
SKU L'unité de gestion des stocks pour suivre l'inventaire des ingrédients.
Quantité La quantité disponible de l'ingrédient.
Unité Les unités de mesure attribuées à l'ingrédient.
Créé à Il stocke la date et l'heure auxquelles l'ingrédient est créé.
Mis à jour à Il stocke la date et l'heure auxquelles l'ingrédient est mis à jour.
Contenu La colonne utilisée pour stocker les détails supplémentaires de l'ingrédient.

Il utilise les colonnes quantité et unité pour suivre le stock disponible dans l'inventaire des ingrédients. Le tableau des ingrédients avec les contraintes appropriées est illustré ci-dessous.

CREATE TABLE `restaurant`.`ingredient` (
  `id` BIGINT NOT NULL AUTO_INCREMENT,
  `userId` BIGINT NOT NULL,
  `vendorId` BIGINT DEFAULT NULL,
  `title` VARCHAR(75) NOT NULL,
  `slug` VARCHAR(100) NOT NULL,
  `summary` TINYTEXT NULL,
  `type` SMALLINT(6) NOT NULL DEFAULT 0,
  `sku` VARCHAR(100) NOT NULL,
  `quantity` FLOAT NOT NULL DEFAULT 0,
  `unit` SMALLINT(6) NOT NULL DEFAULT 0,
  `createdAt` DATETIME NOT NULL,
  `updatedAt` DATETIME NULL DEFAULT NULL,
  `content` TEXT NULL DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE INDEX `uq_slug` (`slug` ASC),
  INDEX `idx_ingredient_user` (`userId` ASC),
  CONSTRAINT `fk_ingredient_user`
    FOREIGN KEY (`userId`)
    REFERENCES `restaurant`.`user` (`id`)
    ON DELETE RESTRICT
    ON UPDATE NO ACTION);

ALTER TABLE `restaurant`.`ingredient`
ADD INDEX `idx_ingredient_vendor` (`vendorId` ASC);
ALTER TABLE `restaurant`.`ingredient` 
ADD CONSTRAINT `fk_ingredient_vendor`
  FOREIGN KEY (`vendorId`)
  REFERENCES `restaurant`.`user` (`id`)
  ON DELETE NO ACTION
  ON UPDATE NO ACTION;

Vous trouverez ci-dessous la description de toutes les colonnes du tableau des éléments . Le tableau des articles est également mappé pour identifier le fournisseur qui peut fournir l'article non culinaire pour réapprovisionner l'inventaire. Dans un scénario plus avancé, il peut y avoir une table distincte pour stocker l'article et la relation fournisseur afin de prendre en charge plusieurs fournisseurs pour le même article.

Remarques :On peut aussi utiliser la même table pour ranger les ingrédients et articles pour simplifier les commandes restaurant et fournisseur. Dans ce cas, une auto-jointure est nécessaire pour identifier les ingrédients de l'article. De plus, les colonnes cuisson et prix ne sont pas utiles pour les lignes d'ingrédients.

Identifiant L'identifiant unique pour identifier l'article.
Identifiant utilisateur L'identifiant d'utilisateur pour identifier l'administrateur.
Identifiant du fournisseur L'identifiant du vendeur pour identifier le fournisseur.
Titre Le titre de l'élément à afficher dans le menu.
limace Le slug unique à utiliser comme GID de l'élément.
Résumé Le résumé pour mentionner les principaux faits saillants.
Type Le type permettant de distinguer les différents types d'éléments.
Cuisine L'indicateur pour identifier si la cuisson est requise pour l'article.
SKU L'unité de gestion des stocks pour suivre l'inventaire des articles. Il n'est obligatoire que si l'article n'est pas associé à des ingrédients.
Prix Le prix de vente d'une unité ou d'une seule portion.
Quantité La quantité disponible de l'article. Il n'est obligatoire que si l'article n'est pas associé à des ingrédients.
Unité Les unités de mesure attribuées à l'article. Il n'est obligatoire que si l'article n'est pas associé à des ingrédients.
Recette Les instructions nécessaires à la cuisson de l'article.
Instructions Les instructions nécessaires pour servir l'article.
Créé à Il stocke la date et l'heure auxquelles l'élément est créé.
Mis à jour à Il stocke la date et l'heure auxquelles l'élément est mis à jour.
Contenu La colonne utilisée pour stocker les détails supplémentaires de l'article.

Semblable au tableau des ingrédients, il utilise les colonnes quantité et unité pour suivre le stock disponible dans l'inventaire des articles. La table d'éléments avec les contraintes appropriées est illustrée ci-dessous.

CREATE TABLE `restaurant`.`item` (
  `id` BIGINT NOT NULL AUTO_INCREMENT,
  `userId` BIGINT NOT NULL,
  `vendorId` BIGINT DEFAULT NULL,
  `title` VARCHAR(75) NOT NULL,
  `slug` VARCHAR(100) NOT NULL,
  `summary` TINYTEXT NULL,
  `type` SMALLINT(6) NOT NULL DEFAULT 0,
  `cooking` TINYINT(1) NOT NULL DEFAULT 0,
  `sku` VARCHAR(100) NOT NULL,
  `price` FLOAT NOT NULL DEFAULT 0,
  `quantity` FLOAT NOT NULL DEFAULT 0,
  `unit` SMALLINT(6) NOT NULL DEFAULT 0,
  `recipe` TEXT NULL DEFAULT NULL,
  `instructions` TEXT NULL DEFAULT NULL,
  `createdAt` DATETIME NOT NULL,
  `updatedAt` DATETIME NULL DEFAULT NULL,
  `content` TEXT NULL DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE INDEX `uq_slug` (`slug` ASC),
  INDEX `idx_item_user` (`userId` ASC),
  CONSTRAINT `fk_item_user`
    FOREIGN KEY (`userId`)
    REFERENCES `restaurant`.`user` (`id`)
    ON DELETE RESTRICT
    ON UPDATE NO ACTION);

ALTER TABLE `restaurant`.`item`
ADD INDEX `idx_item_vendor` (`vendorId` ASC);
ALTER TABLE `restaurant`.`item` 
ADD CONSTRAINT `fk_item_vendor`
  FOREIGN KEY (`vendorId`)
  REFERENCES `restaurant`.`user` (`id`)
  ON DELETE NO ACTION
  ON UPDATE NO ACTION;

Le tableau de recettes peut être utilisé pour suivre la quantité d'ingrédients requis pour un article pour une seule portion. Vous trouverez ci-dessous la description de toutes les colonnes du tableau des recettes.

Identifiant L'identifiant unique pour identifier la recette.
Identifiant de l'article L'identifiant de l'article pour identifier l'article.
Identifiant de l'ingrédient L'identifiant de l'ingrédient pour identifier l'ingrédient.
Quantité La quantité d'ingrédient nécessaire pour cuisiner l'article pour une seule portion.
Unité Les unités de mesure pour identifier la quantité d'ingrédients requise pour l'article.
Instructions Les instructions d'ingrédients nécessaires à la cuisson de l'article.

Le tableau de recettes avec les contraintes appropriées est illustré ci-dessous.

CREATE TABLE `restaurant`.`recipe` (
  `id` BIGINT NOT NULL AUTO_INCREMENT,
  `itemId` BIGINT NOT NULL,
  `ingredientId` BIGINT NOT NULL,
  `quantity` FLOAT NOT NULL DEFAULT 0,
  `unit` SMALLINT(6) NOT NULL DEFAULT 0,
  `instructions` TEXT NULL DEFAULT NULL,
  PRIMARY KEY (`id`),
  INDEX `idx_recipe_item` (`itemId` ASC),
  UNIQUE INDEX `uq_recipe_item_ingredient` (`itemId` ASC, `ingredientId` ASC),
  CONSTRAINT `fk_recipe_item`
    FOREIGN KEY (`itemId`)
    REFERENCES `restaurant`.`item` (`id`)
    ON DELETE RESTRICT
    ON UPDATE NO ACTION)
ENGINE = InnoDB;

ALTER TABLE `restaurant`.`recipe`
ADD INDEX `idx_recipe_ingredient` (`ingredientId` ASC);
ALTER TABLE `restaurant`.`recipe` 
ADD CONSTRAINT `fk_recipe_ingredient`
  FOREIGN KEY (`ingredientId`)
  REFERENCES `restaurant`.`ingredient` (`id`)
  ON DELETE RESTRICT
  ON UPDATE NO ACTION;

Vous trouverez ci-dessous la description de toutes les colonnes du tableau des menus . Le tableau des menus peut être utilisé pour stocker les multiples menus d'un même restaurant.

Identifiant L'identifiant unique pour identifier le menu.
Identifiant utilisateur L'identifiant d'utilisateur pour identifier l'administrateur.
Titre Le titre du menu à afficher sur la carte de menu.
limace Le slug unique à utiliser comme GID du menu.
Résumé Le résumé pour mentionner les points forts de la carte de menu.
Type Le type permettant de distinguer les différents types de menu.
Créé à Il stocke la date et l'heure auxquelles l'élément est créé.
Mis à jour à Il stocke la date et l'heure auxquelles l'élément est mis à jour.
Contenu La colonne utilisée pour stocker les détails supplémentaires du menu.

Le tableau de menu avec les contraintes appropriées est illustré ci-dessous.

CREATE TABLE `restaurant`.`menu` (
  `id` BIGINT NOT NULL AUTO_INCREMENT,
  `userId` BIGINT NOT NULL,
  `title` VARCHAR(75) NOT NULL,
  `slug` VARCHAR(100) NOT NULL,
  `summary` TINYTEXT NULL,
  `type` SMALLINT(6) NOT NULL DEFAULT 0,
  `createdAt` DATETIME NOT NULL,
  `updatedAt` DATETIME NULL DEFAULT NULL,
  `content` TEXT NULL DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE INDEX `uq_slug` (`slug` ASC),
  INDEX `idx_menu_user` (`userId` ASC),
  CONSTRAINT `fk_menu_user`
    FOREIGN KEY (`userId`)
    REFERENCES `restaurant`.`user` (`id`)
    ON DELETE RESTRICT
    ON UPDATE NO ACTION);

Le tableau des éléments de menu peut être utilisé pour suivre les éléments disponibles dans la carte de menu. Vous trouverez ci-dessous la description de toutes les colonnes du tableau des éléments de menu.

Identifiant L'identifiant unique pour identifier l'élément de menu.
Identifiant de menu L'identifiant du menu pour identifier le menu.
Identifiant de l'article L'identifiant de l'article pour identifier l'article.
Actif L'indicateur pour vérifier si l'article est disponible.

Le tableau des éléments de menu avec les contraintes appropriées est illustré ci-dessous.

CREATE TABLE `restaurant`.`menu_item` (
  `id` BIGINT NOT NULL AUTO_INCREMENT,
  `menuId` BIGINT NOT NULL,
  `itemId` BIGINT NOT NULL,
  `active` TINYINT(1) NOT NULL DEFAULT 1,
  PRIMARY KEY (`id`),
  INDEX `idx_menu_item_menu` (`menuId` ASC),
  UNIQUE INDEX `uq_menu_item` (`menuId` ASC, `itemId` ASC),
  CONSTRAINT `fk_menu_item_menu`
    FOREIGN KEY (`menuId`)
    REFERENCES `restaurant`.`menu` (`id`)
    ON DELETE RESTRICT
    ON UPDATE NO ACTION)
ENGINE = InnoDB;

ALTER TABLE `restaurant`.`menu_item`
ADD INDEX `idx_menu_item_item` (`itemId` ASC);
ALTER TABLE `restaurant`.`menu_item` 
ADD CONSTRAINT `fk_menu_item_item`
  FOREIGN KEY (`itemId`)
  REFERENCES `restaurant`.`item` (`id`)
  ON DELETE RESTRICT
  ON UPDATE NO ACTION;

La table des chefs d'articles peut être utilisé pour identifier le chef chargé de cuisiner l'article. Vous trouverez ci-dessous la description de toutes les colonnes de la table Item Chef.

Identifiant L'identifiant unique pour identifier l'élément de menu.
Identifiant de l'article L'identifiant de l'article pour identifier l'article.
Identifiant du chef L'identifiant du chef pour identifier l'utilisateur.
Actif Le drapeau pour vérifier si le chef est disponible pour cuisiner l'article.

La table Item Chef avec les contraintes appropriées est illustrée ci-dessous.

CREATE TABLE `restaurant`.`item_chef` (
  `id` BIGINT NOT NULL AUTO_INCREMENT,
  `itemId` BIGINT NOT NULL,
  `chefId` BIGINT NOT NULL,
  `active` TINYINT(1) NOT NULL DEFAULT 1,
  PRIMARY KEY (`id`),
  INDEX `idx_item_chef_item` (`itemId` ASC),
  UNIQUE INDEX `uq_item_chef` (`itemId` ASC, `chefId` ASC),
  CONSTRAINT `fk_item_chef_item`
    FOREIGN KEY (`itemId`)
    REFERENCES `restaurant`.`item` (`id`)
    ON DELETE CASCADE
    ON UPDATE NO ACTION)
ENGINE = InnoDB;

ALTER TABLE `restaurant`.`item_chef`
ADD INDEX `idx_item_chef_chef` (`chefId` ASC);
ALTER TABLE `restaurant`.`item_chef` 
ADD CONSTRAINT `fk_item_chef_chef`
  FOREIGN KEY (`chefId`)
  REFERENCES `restaurant`.`user` (`id`)
  ON DELETE CASCADE
  ON UPDATE NO ACTION;

TableTop et tables de réservation

Dans cette section, nous allons concevoir les tables de table et de réservation pour stocker les tables du restaurant et leurs détails de réservation.

La table de table peut être utilisé pour stocker les détails des tables au restaurant. Le statut de la table peut être Libre, Réservé et Actif. J'ai utilisé TableTop au lieu de Table pour le distinguer du mot-clé table de MySQL. Vous trouverez ci-dessous la description de toutes les colonnes de la table TableTop.

Identifiant L'identifiant unique pour identifier la table.
Code Le code du tableau.
Statut La note de l'avis.
Capacité Le nombre total de places assises de la table.
Créé à Il stocke la date et l'heure auxquelles la table est créée.
Mis à jour à Il stocke la date et l'heure auxquelles la table est mise à jour.
Contenu La colonne utilisée pour stocker les détails supplémentaires de la table.

La table TableTop avec les contraintes appropriées est illustrée ci-dessous.

CREATE TABLE `restaurant`.`table_top` (
  `id` BIGINT NOT NULL AUTO_INCREMENT,
  `code` VARCHAR(100) NOT NULL,
  `status` SMALLINT(6) NOT NULL DEFAULT 0,
  `capacity` SMALLINT(6) NOT NULL DEFAULT 0,
  `createdAt` DATETIME NOT NULL,
  `updatedAt` DATETIME NULL DEFAULT NULL,
  `content` TEXT NULL DEFAULT NULL,
  PRIMARY KEY (`id`));

Tableau de réservation peut être utilisé pour réserver les tables du restaurant en ligne ou sur place. Un utilisateur connecté ou existant peut également être associé à la réservation. Il suppose également que seules les tables ayant le statut Libre peuvent être réservées. Le statut de la table peut être modifié en Réservé une fois la réservation confirmée. De plus, le statut de la table peut être défini sur Actif dès que les invités l'occupent. Vous trouverez ci-dessous la description de toutes les colonnes du tableau de réservation.

Remarques :La table de réservation ne couvre pas les paiements impliqués dans la réservation de la table. Il peut être mis à jour davantage en ajoutant des colonnes supplémentaires pour gérer les paiements impliqués dans la réservation de la table.

Identifiant L'identifiant unique pour identifier la réservation.
Identifiant de table L'identifiant de la table pour identifier la table associée à la réservation.
Identifiant utilisateur L'identifiant de l'utilisateur pour identifier l'utilisateur enregistré associé à la réservation.
Jeton Le jeton unique associé à la réservation.
Statut Le statut de la réservation peut être Nouveau, Salon, Actif et Terminé.
Prénom Le prénom de l'invité.
Deuxième prénom Le deuxième prénom de l'invité.
Nom de famille Le nom de famille de l'utilisateur.
Mobile Le numéro de portable de l'utilisateur.
E-mail L'adresse e-mail de l'utilisateur.
Ligne 1 La première ligne pour stocker l'adresse.
Ligne 2 La deuxième ligne pour stocker l'adresse.
Ville La ville de l'adresse.
Province La province de l'adresse.
Pays Le pays de l'adresse.
Créé à Il stocke la date et l'heure auxquelles la réservation est créée.
Mis à jour à Il stocke la date et l'heure auxquelles la réservation est mise à jour.
Contenu La colonne utilisée pour stocker les détails supplémentaires de la réservation.

Le tableau de réservation avec les contraintes appropriées est illustré ci-dessous.

CREATE TABLE `restaurant`.`booking` (
  `id` BIGINT NOT NULL AUTO_INCREMENT,
  `tableId` BIGINT NOT NULL,
  `userId` BIGINT NULL DEFAULT NULL,
  `token` VARCHAR(100) NOT NULL,
  `status` SMALLINT(6) NOT NULL DEFAULT 0,
  `firstName` VARCHAR(50) NULL DEFAULT NULL,
  `middleName` VARCHAR(50) NULL DEFAULT NULL,
  `lastName` VARCHAR(50) NULL DEFAULT NULL,
  `mobile` VARCHAR(15) NULL,
  `email` VARCHAR(50) NULL,
  `line1` VARCHAR(50) NULL DEFAULT NULL,
  `line2` VARCHAR(50) NULL DEFAULT NULL,
  `city` VARCHAR(50) NULL DEFAULT NULL,
  `province` VARCHAR(50) NULL DEFAULT NULL,
  `country` VARCHAR(50) NULL DEFAULT NULL,
  `createdAt` DATETIME NOT NULL,
  `updatedAt` DATETIME NULL DEFAULT NULL,
  `content` TEXT NULL DEFAULT NULL,
  PRIMARY KEY (`id`),
  INDEX `idx_booking_table` (`tableId` ASC),
  CONSTRAINT `fk_booking_table`
    FOREIGN KEY (`tableId`)
    REFERENCES `restaurant`.`table_top` (`id`)
    ON DELETE NO ACTION
    ON UPDATE NO ACTION);

ALTER TABLE `restaurant`.`booking`
ADD INDEX `idx_booking_user` (`userId` ASC);
ALTER TABLE `restaurant`.`booking` 
ADD CONSTRAINT `fk_booking_user`
  FOREIGN KEY (`userId`)
  REFERENCES `restaurant`.`user` (`id`)
  ON DELETE CASCADE
  ON UPDATE NO ACTION;

Le tableau des éléments de réservation est nécessaire pour suivre les articles commandés par le client. Vous trouverez ci-dessous la description de toutes les colonnes du tableau des éléments de réservation.

Identifiant L'identifiant unique pour identifier l'élément de réservation.
Identifiant de réservation L'identifiant de réservation pour identifier la réservation associée à l'élément de réservation.
Identifiant de l'article L'identifiant de l'article pour identifier l'article associé à l'article de réservation.
SKU Le SKU de l'article lors de sa commande.
Prix Le prix de vente de l'article lors de sa commande.
Remise La remise de l'article lors de sa commande.
Quantité La quantité de l'article commandé par l'utilisateur. Il peut s'agir soit du multiplicateur de l'unité de l'article, soit de la portion individuelle.
Unité Les unités de mesure lors de la commande de l'article.
Statut Le statut pour suivre la progression de l'élément. Il peut s'agir de Nouveau, Cuisine, Cuisine, Cuit, Servi.
Créé à Il stocke la date et l'heure auxquelles l'élément de réservation est créé.
Mis à jour à Il stocke la date et l'heure auxquelles l'élément de réservation est mis à jour.
Contenu La colonne utilisée pour stocker les détails supplémentaires de l'élément de réservation.

Le tableau des éléments de réservation avec les contraintes appropriées est illustré ci-dessous.

CREATE TABLE `restaurant`.`booking_item` (
  `id` BIGINT NOT NULL AUTO_INCREMENT,
  `bookingId` BIGINT NOT NULL,
  `itemId` BIGINT NOT NULL,
  `sku` VARCHAR(100) NOT NULL,
  `price` FLOAT NOT NULL DEFAULT 0,
  `discount` FLOAT NOT NULL DEFAULT 0,
  `quantity` FLOAT NOT NULL DEFAULT 0,
  `unit` SMALLINT(6) NOT NULL DEFAULT 0,
  `status` SMALLINT(6) NOT NULL DEFAULT 0,
  `createdAt` DATETIME NOT NULL,
  `updatedAt` DATETIME NULL DEFAULT NULL,
  `content` TEXT NULL DEFAULT NULL,
  PRIMARY KEY (`id`),
  INDEX `idx_booking_item_booking` (`bookingId` ASC),
  CONSTRAINT `fk_booking_item_booking`
    FOREIGN KEY (`bookingId`)
    REFERENCES `restaurant`.`booking` (`id`)
    ON DELETE RESTRICT
    ON UPDATE NO ACTION);

ALTER TABLE `restaurant`.`booking_item` 
ADD INDEX `idx_booking_item_item` (`itemId` ASC);
ALTER TABLE `restaurant`.`booking_item` 
ADD CONSTRAINT `fk_booking_item_item`
  FOREIGN KEY (`itemId`)
  REFERENCES `restaurant`.`item` (`id`)
  ON DELETE RESTRICT
  ON UPDATE NO ACTION;

Tableau des commandes et tableau des articles commandés

Cette section fournit les tables pour gérer les commandes. Un utilisateur connecté peut également être associé à la commande. Le tableau des commandes peut être utilisé pour stocker les réservations terminées et les commandes des fournisseurs. Le statut des commandes fournisseur peut être défini sur nouveau lors de la passation de la commande et il peut être défini sur terminé après réception des articles du fournisseur. De plus, le prix de l'article doit être renseigné manuellement après avoir reçu les articles du fournisseur. Vous trouverez ci-dessous la description de toutes les colonnes du tableau de commande.

Identifiant L'identifiant unique pour identifier la commande.
Identifiant utilisateur L'identifiant de l'utilisateur pour identifier l'invité associé à la commande.
Identifiant du fournisseur L'identifiant du fournisseur pour identifier le fournisseur associé à la commande.
Jeton Le jeton unique associé à la commande pour l'associer à la réservation. Le même jeton peut également être transmis à la passerelle de paiement si nécessaire.
Statut Le statut de la commande peut être Nouveau, Paiement, Payé, Échec, Expédié, Livré, Renvoyé et Terminé. Le statut Expédié, Livré et Renvoyé peut être utilisé pour les commandes fournisseur.
Sous-total Le prix total des articles de la commande.
Remise sur les articles La remise totale des articles de la commande.
Taxe La taxe sur les articles de la commande.
Livraison Les frais d'expédition des articles commandés.
Total Le prix total de la Commande incluant les taxes et les frais d'expédition. Cela exclut la remise sur les articles.
Promotion Le code promo de la Commande.
Remise La remise totale de la commande en fonction du code promotionnel ou de la remise en magasin.
Total général Le grand total de la commande à payer par le client au restaurant ou le restaurant au vendeur.
Prénom Le prénom de l'utilisateur.
Deuxième prénom Le deuxième prénom de l'utilisateur.
Nom de famille Le nom de famille de l'utilisateur.
Mobile Le numéro de portable de l'utilisateur.
E-mail L'adresse e-mail de l'utilisateur.
Ligne 1 La première ligne pour stocker l'adresse.
Ligne 2 La deuxième ligne pour stocker l'adresse.
Ville La ville de l'adresse.
Province La province de l'adresse.
Pays Le pays de l'adresse.
Créé à Il stocke la date et l'heure auxquelles la commande est créée.
Mis à jour à Il stocke la date et l'heure auxquelles la commande est mise à jour.
Contenu La colonne utilisée pour stocker les détails supplémentaires de la commande.

La table de commande avec les contraintes appropriées est illustrée ci-dessous.

CREATE TABLE `restaurant`.`order` (
  `id` BIGINT NOT NULL AUTO_INCREMENT,
  `userId` BIGINT NULL DEFAULT NULL,
  `vendorId` BIGINT NULL DEFAULT NULL,
  `token` VARCHAR(100) NOT NULL,
  `status` SMALLINT(6) NOT NULL DEFAULT 0,
  `subTotal` FLOAT NOT NULL DEFAULT 0,
  `itemDiscount` FLOAT NOT NULL DEFAULT 0,
  `tax` FLOAT NOT NULL DEFAULT 0,
  `shipping` FLOAT NOT NULL DEFAULT 0,
  `total` FLOAT NOT NULL DEFAULT 0,
  `promo` VARCHAR(50) NULL DEFAULT NULL,
  `discount` FLOAT NOT NULL DEFAULT 0,
  `grandTotal` FLOAT NOT NULL DEFAULT 0,
  `firstName` VARCHAR(50) NULL DEFAULT NULL,
  `middleName` VARCHAR(50) NULL DEFAULT NULL,
  `lastName` VARCHAR(50) NULL DEFAULT NULL,
  `mobile` VARCHAR(15) NULL,
  `email` VARCHAR(50) NULL,
  `line1` VARCHAR(50) NULL DEFAULT NULL,
  `line2` VARCHAR(50) NULL DEFAULT NULL,
  `city` VARCHAR(50) NULL DEFAULT NULL,
  `province` VARCHAR(50) NULL DEFAULT NULL,
  `country` VARCHAR(50) NULL DEFAULT NULL,
  `createdAt` DATETIME NOT NULL,
  `updatedAt` DATETIME NULL DEFAULT NULL,
  `content` TEXT NULL DEFAULT NULL,
  PRIMARY KEY (`id`),
  INDEX `idx_order_user` (`userId` ASC),
  CONSTRAINT `fk_order_user`
    FOREIGN KEY (`userId`)
    REFERENCES `restaurant`.`user` (`id`)
    ON DELETE NO ACTION
    ON UPDATE NO ACTION);

ALTER TABLE `restaurant`.`order` 
ADD INDEX `idx_order_vendor` (`vendorId` ASC);
ALTER TABLE `restaurant`.`order` 
ADD CONSTRAINT `fk_order_vendor`
  FOREIGN KEY (`vendorId`)
  REFERENCES `restaurant`.`user` (`id`)
  ON DELETE RESTRICT
  ON UPDATE NO ACTION;

Vous trouverez ci-dessous la description de toutes les colonnes du tableau des éléments de commande.

Identifiant L'identifiant unique pour identifier l'article commandé.
Identifiant de l'article L'identifiant du produit pour identifier l'article associé à l'article commandé.
Identifiant de commande L'identifiant de la commande pour identifier la commande associée à l'article commandé.
SKU Le SKU de l'article lors de sa commande.
Prix Le prix de l'article lors de sa commande.
Remise La remise de l'article lors de sa commande.
Quantité La quantité de l'article sélectionné par l'utilisateur.
Unité Les unités de mesure lors de la commande de l'article.
Créé à Il stocke la date et l'heure auxquelles l'article commandé est créé.
Mis à jour à Il stocke la date et l'heure auxquelles l'article commandé est mis à jour.
Contenu La colonne utilisée pour stocker les détails supplémentaires de l'article commandé.

Le tableau des articles de commande avec les contraintes appropriées est illustré ci-dessous.

CREATE TABLE `restaurant`.`order_item` (
  `id` BIGINT NOT NULL AUTO_INCREMENT,
  `orderId` BIGINT NOT NULL,
  `itemId` BIGINT NOT NULL,
  `sku` VARCHAR(100) NOT NULL,
  `price` FLOAT NOT NULL DEFAULT 0,
  `discount` FLOAT NOT NULL DEFAULT 0,
  `quantity` FLOAT NOT NULL DEFAULT 0,
  `unit` SMALLINT(6) NOT NULL DEFAULT 0,
  `createdAt` DATETIME NOT NULL,
  `updatedAt` DATETIME NULL DEFAULT NULL,
  `content` TEXT NULL DEFAULT NULL,
  PRIMARY KEY (`id`),
  INDEX `idx_order_item_order` (`orderId` ASC),
  CONSTRAINT `fk_order_item_order`
    FOREIGN KEY (`orderId`)
    REFERENCES `restaurant`.`order` (`id`)
    ON DELETE NO ACTION
    ON UPDATE NO ACTION);

ALTER TABLE `restaurant`.`order_item` 
ADD INDEX `idx_order_item_item` (`itemId` ASC);
ALTER TABLE `restaurant`.`order_item` 
ADD CONSTRAINT `fk_order_item_item`
  FOREIGN KEY (`itemId`)
  REFERENCES `restaurant`.`item` (`id`)
  ON DELETE NO ACTION
  ON UPDATE NO ACTION;

Tableau des transactions

Nous avons également besoin d'un tableau des transactions pour suivre les paiements des commandes effectués par les clients au restaurant et le restaurant aux vendeurs pour la comptabilité. Nous pouvons également utiliser la même table pour enregistrer les transactions de crédit (invités) et de débit (fournisseurs). Vous trouverez ci-dessous la description de toutes les colonnes du tableau des transactions.

Identifiant L'identifiant unique pour identifier la transaction.
Identifiant utilisateur L'identifiant de l'utilisateur pour identifier l'utilisateur associé à la transaction.
Identifiant du fournisseur L'identifiant du fournisseur pour identifier le fournisseur associé à la transaction.
Identifiant de commande L'identifiant de la commande pour identifier la commande associée à la transaction.
Code L'identifiant de paiement fourni par la passerelle de paiement.
Type Le type de transaction de commande peut être crédit ou débit.
Mode Le mode de transaction de la commande peut être Hors ligne, Paiement à la livraison, Chèque, Brouillon, Virement bancaire et En ligne.
Statut Le statut de la transaction de commande peut être Nouveau, Annulé, Échec, En attente, Refusé, Rejeté et Réussi.
Créé à Il stocke la date et l'heure auxquelles la transaction de commande est créée.
Mis à jour à Il stocke la date et l'heure auxquelles la transaction de commande est mise à jour.
Contenu The column used to store the additional details of the transaction.

The Transaction Table with the appropriate constraints is as shown below.

CREATE TABLE `restaurant`.`transaction` (
  `id` BIGINT NOT NULL AUTO_INCREMENT,
  `userId` BIGINT NOT NULL,
  `vendorId` BIGINT NOT NULL,
  `orderId` BIGINT NOT NULL,
  `code` VARCHAR(100) NOT NULL,
  `type` SMALLINT(6) NOT NULL DEFAULT 0,
  `mode` SMALLINT(6) NOT NULL DEFAULT 0,
  `status` SMALLINT(6) NOT NULL DEFAULT 0,
  `createdAt` DATETIME NOT NULL,
  `updatedAt` DATETIME NULL DEFAULT NULL,
  `content` TEXT NULL DEFAULT NULL,
  PRIMARY KEY (`id`),
  INDEX `idx_transaction_user` (`userId` ASC),
  CONSTRAINT `fk_transaction_user`
    FOREIGN KEY (`userId`)
    REFERENCES `restaurant`.`user` (`id`)
    ON DELETE NO ACTION
    ON UPDATE NO ACTION);

ALTER TABLE `restaurant`.`transaction` 
ADD INDEX `idx_transaction_vendor` (`vendorId` ASC),
ADD INDEX `idx_transaction_order` (`orderId` ASC);

ALTER TABLE `restaurant`.`transaction` 
ADD CONSTRAINT `fk_transaction_vendor`
  FOREIGN KEY (`vendorId`)
  REFERENCES `restaurant`.`user` (`id`)
  ON DELETE NO ACTION
  ON UPDATE NO ACTION,
ADD CONSTRAINT `fk_transaction_order`
  FOREIGN KEY (`orderId`)
  REFERENCES `restaurant`.`order` (`id`)
  ON DELETE NO ACTION
  ON UPDATE NO ACTION;

Address Table

An address table can be used to avoid the redundant columns in the Booking and Order table depending on the actual implementation. It can be directly mapped to the Booking Table and Order Table using the appropriate foreign keys.

Résumé

In this tutorial, we have discussed the database design of a Restaurant Ordering System or Food Ordering System to store the users, book tables, automate kitchen, and manage product inventory. The same database schema can be used to accept online table booking and pre-orders. The database schema provided in this tutorial can be considered as the starting point and further optimized or updated based on the actual needs. The On-Premises Restaurant Ordering System Flowchart can be referred to implement the restaurant order system.

Vous pouvez soumettre vos commentaires pour participer à la discussion. You may also be interested in designing the database of the Blog, Online Shopping Cart, and Poll &Survey applications. Le schéma complet de la base de données est également disponible sur GitHub.