Mysql
 sql >> Database >  >> RDS >> Mysql

Guida alla progettazione di database per il sistema di ordini di ristoranti in MySQL

Questo tutorial fornisce i passaggi completi per progettare uno schema di database del sistema di ordinazione dei ristoranti per gestire gli utenti, le prenotazioni dei tavoli, i menu, l'inventario, gli ordini e i pagamenti. Fornisce la progettazione del database degli ordini di cibo per gestire gli ordini di cibo per i ristoranti. Può essere ulteriormente utilizzato per sviluppare applicazioni di sistema di ordini di ristoranti in loco.

Tali sistemi di ordinazione vengono implementati per automatizzare l'elaborazione degli ordini e gestire in modo efficiente i picchi di ordinazione, migliorando così la soddisfazione dei clienti con meno sforzi:una situazione vantaggiosa per tutti i ristoranti.

Il diagramma della relazione tra entità o il design del database visivo è mostrato di seguito.

Sistema di ordinazione dei ristoranti

Note :Può essere utilizzato per la prenotazione online dei tavoli e il preordine prima di raggiungere il ristorante. La sicurezza può essere gestita anche seguendo il database RBAC in MySQL.

Puoi anche visitare i tutorial popolari tra cui Come installare MySQL 8 su Ubuntu, Come installare MySQL 8 su Windows, Come installare MySQL 8 con Workbench su Windows 10, Database RBAC in MySql, Database del blog in MySql, Database dei quiz in MySQL, Database di sondaggi e sondaggi in MySQL, database del carrello degli acquisti online e informazioni sulle query SQL di base in MySQL.

Banca dati ristorante

Il primo passo è creare il database del ristorante. Può essere creato utilizzando la query come mostrato di seguito.

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

Ho usato il set di caratteri utf8mb4 per supportare un'ampia gamma di caratteri.

Tabella utenti

In questa sezione, progetteremo la Tabella utente per memorizzare le informazioni sull'utente. La stessa tabella può essere utilizzata per gestire diversi tipi di utenti inclusi amministratori, chef, agenti e clienti. Può essere utilizzato per mettere in relazione gli utenti con menu, articoli, prenotazioni di tavoli e ordini. Gli utenti possono tenere traccia dei propri tavoli e ordini. Di seguito è riportata la descrizione di tutte le colonne della Tabella Utente.

ID L'ID univoco per identificare l'utente.
Nome Il nome dell'utente.
Secondo nome Il secondo nome dell'utente.
Cognome Il cognome dell'utente.
Cellulare Il numero di cellulare dell'utente. Può essere utilizzato per scopi di accesso e registrazione.
E-mail L'e-mail dell'utente. Può essere utilizzato per scopi di accesso e registrazione.
Hash password L'hash della password generato dall'algoritmo appropriato. Dobbiamo evitare di memorizzare password semplici o crittografate.
Amministratore Il flag per identificare se l'utente è un amministratore. Non è necessario se le tabelle RBAC vengono create seguendo la progettazione del database RBAC.
Fornitore Il flag per identificare se l'utente può ricevere ordini di inventario. Non è necessario se le tabelle RBAC vengono create seguendo la progettazione del database RBAC.
Chef Il flag per identificare se l'utente può cucinare gli articoli. Non è necessario se le tabelle RBAC vengono create seguendo la progettazione del database RBAC.
Agente Il flag per identificare se l'utente può ospitare una tabella. Non è necessario se le tabelle RBAC vengono create seguendo la progettazione del database RBAC.
Registrato presso Questa colonna può essere utilizzata per calcolare la vita dell'utente con l'applicazione.
Ultimo accesso Può essere utilizzato per identificare l'ultimo accesso dell'utente.
Introduzione La breve introduzione del Vendor User da visualizzare nella Pagina del Prodotto.
Profilo I dettagli del fornitore da visualizzare nella pagina del prodotto.

La tabella utente con i vincoli appropriati è quella mostrata di seguito.

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) );

Tabelle degli ingredienti, degli articoli, delle ricette e dei menu

In questa sezione, progetteremo le tabelle degli ingredienti, degli articoli, delle ricette e dei menu per memorizzare i dati dei menu e delle voci.

Di seguito è riportata la descrizione di tutte le colonne della Tabella degli ingredienti . La tabella degli ingredienti è anche mappata per identificare il fornitore che può fornire l'ingrediente per riempire l'inventario. In uno scenario più avanzato, può esserci una tabella separata per memorizzare l'ingrediente e la relazione con il fornitore per supportare più fornitori per lo stesso ingrediente.

ID L'ID univoco per identificare l'ingrediente.
ID utente L'ID utente per identificare l'amministratore.
ID fornitore L'ID fornitore per identificare il fornitore.
Titolo Il titolo dell'ingrediente da visualizzare sulla Ricetta dell'oggetto.
Slug Lo slug univoco da utilizzare come GID dell'ingrediente.
Riepilogo Il riepilogo per citare i punti salienti.
Tipo Il tipo per distinguere tra i diversi tipi di ingrediente.
SKU L'unità di conservazione delle scorte per tenere traccia dell'inventario degli ingredienti.
Quantità La quantità disponibile dell'ingrediente.
Unità Le unità di misura assegnate all'ingrediente.
Creato a Memorizza la data e l'ora in cui viene creato l'ingrediente.
Aggiornato a Memorizza la data e l'ora in cui l'ingrediente viene aggiornato.
Contenuto La colonna utilizzata per memorizzare i dettagli aggiuntivi dell'ingrediente.

Utilizza la quantità e l'unità delle colonne per tenere traccia delle scorte disponibili nell'inventario degli ingredienti. La tabella degli ingredienti con i vincoli appropriati è quella mostrata di seguito.

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;

Di seguito è riportata la descrizione di tutte le colonne della Tabella Item . La tabella articoli viene inoltre mappata per identificare il fornitore che può fornire l'articolo non da cucina per riempire nuovamente l'inventario. In uno scenario più avanzato, può esserci una tabella separata per memorizzare l'articolo e la relazione con il fornitore per supportare più fornitori per lo stesso articolo.

Note :Possiamo anche utilizzare lo stesso tavolo per conservare gli ingredienti e gli articoli per semplificare gli ordini di ristoranti e fornitori. In tal caso, è necessario un self-join per identificare gli ingredienti dell'articolo. Inoltre, le colonne cottura e prezzo non sono utili per le righe degli ingredienti.

ID L'ID univoco per identificare l'elemento.
ID utente L'ID utente per identificare l'amministratore.
ID fornitore L'ID fornitore per identificare il fornitore.
Titolo Il titolo dell'elemento da visualizzare nel Menu.
Slug Lo slug univoco da utilizzare come GID dell'elemento.
Riepilogo Il riepilogo per citare i punti salienti.
Tipo Il tipo per distinguere tra i diversi tipi di elemento.
Cucina Il flag per identificare se è richiesta la cottura per l'articolo.
SKU L'unità di conservazione delle scorte per monitorare l'inventario degli articoli. È richiesto solo se l'articolo non è associato agli ingredienti.
Prezzo Il prezzo di vendita di un'unità o di una singola porzione.
Quantità La quantità disponibile dell'articolo. È richiesto solo se l'articolo non è associato agli ingredienti.
Unità Le unità di misura assegnate all'articolo. È richiesto solo se l'articolo non è associato agli ingredienti.
Ricetta Le istruzioni necessarie per cuocere l'oggetto.
Istruzioni Le istruzioni necessarie per servire l'articolo.
Creato a Memorizza la data e l'ora di creazione dell'elemento.
Aggiornato a Memorizza la data e l'ora in cui l'articolo viene aggiornato.
Contenuto La colonna utilizzata per memorizzare i dettagli aggiuntivi dell'articolo.

Simile alla tabella degli ingredienti, utilizza la quantità e l'unità delle colonne per tenere traccia delle scorte disponibili nell'inventario degli articoli. La tabella degli articoli con i vincoli appropriati è quella mostrata di seguito.

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;

La Tabella delle ricette può essere utilizzato per tracciare la quantità degli ingredienti necessari per un articolo per una singola porzione. Di seguito è riportata la descrizione di tutte le colonne della Tabella delle Ricette.

ID L'ID univoco per identificare la ricetta.
ID oggetto L'ID articolo per identificare l'articolo.
ID ingrediente L'ID ingrediente per identificare l'ingrediente.
Quantità La quantità dell'ingrediente necessaria per cuocere l'articolo per una singola porzione.
Unità Le unità di misura per identificare la quantità di ingrediente richiesta per l'articolo.
Istruzioni Le istruzioni sugli ingredienti necessarie per cucinare l'oggetto.

La tabella delle ricette con i vincoli appropriati è quella mostrata di seguito.

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;

Di seguito è riportata la descrizione di tutte le colonne della Tabella dei menu . La tabella dei menu può essere utilizzata per memorizzare più menu dello stesso ristorante.

ID L'ID univoco per identificare il menu.
ID utente L'ID utente per identificare l'amministratore.
Titolo Il titolo del menu da visualizzare sulla scheda menu.
Slug Lo slug univoco da utilizzare come GID del menu.
Riepilogo Il riepilogo per citare i punti salienti della scheda menu.
Tipo Il tipo per distinguere tra i diversi tipi di menu.
Creato a Memorizza la data e l'ora di creazione dell'elemento.
Aggiornato a Memorizza la data e l'ora in cui l'articolo viene aggiornato.
Contenuto La colonna utilizzata per memorizzare i dettagli aggiuntivi del menu.

La tabella dei menu con i vincoli appropriati è quella mostrata di seguito.

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);

La Tabella delle voci di menu può essere utilizzato per tracciare gli elementi disponibili nella Menu Card. Di seguito è indicata la descrizione di tutte le colonne della Tabella delle voci di menu.

ID L'ID univoco per identificare la voce di menu.
ID menu L'ID del menu per identificare il menu.
ID oggetto L'ID articolo per identificare l'articolo.
Attivo Il flag per verificare se l'articolo è disponibile.

La tabella delle voci di menu con i vincoli appropriati è quella mostrata di seguito.

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;

Il Tavolo Item Chef può essere utilizzato per identificare lo Chef incaricato di cucinare l'oggetto. Di seguito è riportata la descrizione di tutte le colonne della Item Chef Table.

ID L'ID univoco per identificare la voce di menu.
ID oggetto L'ID articolo per identificare l'articolo.
ID chef L'ID chef per identificare l'utente.
Attivo Il flag per verificare se lo chef è disponibile per cucinare l'oggetto.

La tabella Item Chef con i vincoli appropriati è quella mostrata di seguito.

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 e tavoli di prenotazione

In questa sezione, progetteremo i Tavoli TableTop e Booking per memorizzare i tavoli del ristorante e i dettagli della loro prenotazione.

Il tavolo da tavolo può essere utilizzato per memorizzare i dettagli dei tavoli al ristorante. Lo stato della tabella può essere Libero, Riservato e Attivo. Ho usato TableTop invece di Table per distinguerlo dalla parola chiave table di MySQL. Di seguito è indicata la descrizione di tutte le colonne del TableTop Table.

ID L'ID univoco per identificare la tabella.
Codice Il codice della tabella.
Stato La valutazione della recensione.
Capacità La capacità totale dei posti a sedere del Tavolo.
Creato a Memorizza la data e l'ora in cui viene creata la tabella.
Aggiornato a Memorizza la data e l'ora in cui la tabella viene aggiornata.
Contenuto La colonna utilizzata per memorizzare i dettagli aggiuntivi della tabella.

La tabella TableTop con i vincoli appropriati è quella mostrata di seguito.

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`));

Tavolo di prenotazione può essere utilizzato per prenotare i tavoli del ristorante sia online che in sede. È possibile associare a Booking anche un utente già registrato o esistente. Presuppone inoltre che solo le tabelle con stato Libero possano essere Riservate. Lo stato del tavolo può essere modificato in Prenotato dopo la conferma della prenotazione. Inoltre, lo stato del tavolo può essere impostato su Attivo non appena gli ospiti lo occupano. Di seguito è riportata la descrizione di tutte le colonne della Tabella delle Prenotazioni.

Note :Il tavolo di prenotazione non copre i pagamenti coinvolti nella prenotazione del tavolo. Può essere ulteriormente aggiornato aggiungendo ulteriori colonne per gestire i pagamenti coinvolti nella prenotazione del tavolo.

ID L'ID univoco per identificare la prenotazione.
ID tabella L'id del tavolo per identificare il tavolo associato alla prenotazione.
ID utente L'ID utente per identificare l'utente registrato associato alla prenotazione.
Segnale Il token univoco associato alla prenotazione.
Stato Lo stato della prenotazione può essere Nuovo, Lounge, Attivo e Completato.
Nome Il nome dell'ospite.
Secondo nome Il secondo nome dell'ospite.
Cognome Il cognome dell'utente.
Cellulare Il numero di cellulare dell'utente.
E-mail L'e-mail dell'utente.
Riga 1 La prima riga per memorizzare l'indirizzo.
Riga 2 La seconda riga per memorizzare l'indirizzo.
Città La città dell'indirizzo.
Provincia La provincia dell'indirizzo.
Paese Il paese dell'indirizzo.
Creato a Memorizza la data e l'ora in cui viene creata la prenotazione.
Aggiornato a Memorizza la data e l'ora in cui viene aggiornata la prenotazione.
Contenuto La colonna utilizzata per memorizzare i dettagli aggiuntivi della prenotazione.

La Tabella delle Prenotazioni con i vincoli appropriati è quella mostrata di seguito.

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;

La Tabella degli elementi di prenotazione è necessario per tracciare gli articoli ordinati dall'ospite. Di seguito è riportata la descrizione di tutte le colonne della Tabella Voci di Prenotazione.

ID L'ID univoco per identificare l'elemento della prenotazione.
ID prenotazione L'ID prenotazione per identificare la prenotazione associata all'elemento della prenotazione.
ID oggetto L'ID articolo per identificare l'articolo associato all'articolo della prenotazione.
SKU SKU dell'articolo al momento dell'ordine.
Prezzo Il prezzo di vendita dell'articolo al momento dell'ordine.
Sconto Lo sconto dell'articolo al momento dell'ordine.
Quantità La quantità dell'articolo ordinato dall'utente. Può essere il moltiplicatore dell'unità articolo o la singola porzione.
Unità Le Unità di Misura durante l'ordine dell'Articolo.
Stato Lo stato per monitorare l'avanzamento dell'oggetto. Può essere Nuovo, Cucina, Cucina, Cotto, Servito.
Creato a Memorizza la data e l'ora in cui viene creato l'elemento della prenotazione.
Aggiornato a Memorizza la data e l'ora in cui l'elemento della prenotazione viene aggiornato.
Contenuto La colonna utilizzata per memorizzare i dettagli aggiuntivi dell'elemento della prenotazione.

La tabella degli elementi di prenotazione con i vincoli appropriati è quella mostrata di seguito.

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;

Tabella dell'ordine e tabella dell'articolo dell'ordine

Questa sezione fornisce le tabelle per la gestione degli ordini. È possibile associare all'ordine anche un utente registrato. La tabella degli ordini può essere utilizzata per memorizzare le prenotazioni completate e gli ordini fornitore. Lo stato degli ordini fornitore può essere impostato su nuovo durante l'effettuazione dell'ordine e può essere impostato per essere completato dopo aver ricevuto gli articoli dal fornitore. Inoltre, il prezzo dell'articolo deve essere compilato manualmente dopo aver ricevuto gli articoli dal fornitore. Di seguito è riportata la descrizione di tutte le colonne della Tabella degli Ordini.

ID L'ID univoco per identificare l'ordine.
ID utente L'ID utente per identificare l'ospite associato all'ordine.
ID fornitore L'ID fornitore per identificare il fornitore associato all'ordine.
Segnale Il token univoco associato all'ordine per metterlo in relazione con la prenotazione. Lo stesso token può anche essere passato al Payment Gateway, se richiesto.
Stato Lo stato dell'ordine può essere Nuovo, Checkout, Pagato, Non riuscito, Spedito, Consegnato, Reso e Completato. Lo stato Spedito, Consegnato e Reso può essere utilizzato per gli ordini fornitore.
Sub Totale Il prezzo totale degli articoli dell'ordine.
Sconto articolo Lo sconto totale degli articoli dell'ordine.
Tasse La tassa sugli articoli dell'ordine.
Spedizione Le spese di spedizione degli Articoli dell'ordine.
Totale Il prezzo totale dell'Ordine comprensivo di tasse e spedizione. Escluso lo sconto articoli.
Promozione Il codice promozionale dell'Ordine.
Sconto Lo sconto totale dell'Ordine in base al codice promozionale o allo sconto del negozio.
Totale generale Il totale complessivo dell'ordine che l'ospite deve pagare al ristorante o il ristorante al venditore.
Nome Il nome dell'utente.
Secondo nome Il secondo nome dell'utente.
Cognome Il cognome dell'utente.
Cellulare Il numero di cellulare dell'utente.
E-mail L'e-mail dell'utente.
Riga 1 La prima riga per memorizzare l'indirizzo.
Riga 2 La seconda riga per memorizzare l'indirizzo.
Città La città dell'indirizzo.
Provincia La provincia dell'indirizzo.
Paese Il paese dell'indirizzo.
Creato a Memorizza la data e l'ora in cui viene creato l'ordine.
Aggiornato a Memorizza la data e l'ora in cui l'ordine viene aggiornato.
Contenuto La colonna utilizzata per memorizzare i dettagli aggiuntivi dell'ordine.

La tabella degli ordini con i vincoli appropriati è quella mostrata di seguito.

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;

Di seguito è riportata la descrizione di tutte le colonne della Tabella degli articoli dell'ordine.

ID L'ID univoco per identificare l'articolo ordinato.
ID oggetto L'ID prodotto per identificare l'articolo associato all'articolo ordinato.
ID ordine L'ID ordine per identificare l'ordine associato all'articolo ordinato.
SKU SKU dell'articolo al momento dell'ordine.
Prezzo Il prezzo dell'articolo al momento dell'ordine.
Sconto Lo sconto dell'articolo al momento dell'ordine.
Quantità La quantità dell'articolo selezionato dall'utente.
Unità Le Unità di Misura durante l'ordine dell'Articolo.
Creato a Memorizza la data e l'ora in cui viene creato l'articolo ordinato.
Aggiornato a Memorizza la data e l'ora in cui l'articolo ordinato viene aggiornato.
Contenuto La colonna utilizzata per memorizzare i dettagli aggiuntivi dell'articolo ordinato.

La tabella degli articoli dell'ordine con i vincoli appropriati è quella mostrata di seguito.

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;

Tabella delle transazioni

Abbiamo anche bisogno di una tabella delle transazioni per tenere traccia dei pagamenti degli ordini effettuati dagli ospiti al ristorante e dal ristorante ai fornitori per la contabilità. Possiamo anche utilizzare la stessa tabella per registrare le transazioni di credito (ospiti) e di debito (fornitori). Di seguito è riportata la descrizione di tutte le colonne della Tabella delle Transazioni.

ID L'ID univoco per identificare la transazione.
ID utente L'ID utente per identificare l'utente associato alla transazione.
ID fornitore L'ID fornitore per identificare il fornitore associato alla transazione.
ID ordine L'ID ordine per identificare l'ordine associato alla transazione.
Codice L'ID pagamento fornito dal gateway di pagamento.
Tipo Il tipo di transazione dell'ordine può essere di credito o di debito.
Modalità La modalità di transazione dell'ordine può essere Offline, Contrassegno, Assegno, Bozza, Bonifico e Online.
Stato Lo stato della transazione dell'ordine può essere Nuovo, Annullato, Non riuscito, In attesa, Rifiutato, Rifiutato e Riuscito.
Creato a Memorizza la data e l'ora in cui viene creata la transazione dell'ordine.
Aggiornato a Memorizza la data e l'ora in cui viene aggiornata la transazione dell'ordine.
Contenuto La colonna utilizzata per memorizzare i dettagli aggiuntivi della transazione.

La tabella delle transazioni con i vincoli appropriati è quella mostrata di seguito.

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.

Riepilogo

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.

Puoi inviare i tuoi commenti per partecipare alla discussione. You may also be interested in designing the database of the Blog, Online Shopping Cart, and Poll &Survey applications. Lo schema completo del database è disponibile anche su GitHub.