Auswählen von Werten aus fremden Tabellen

Question

Ich arbeite an der SELECT-Klausel für den VALUES-Abschnitt einer SQL-INSERT-Anweisung. Eines der Felder des Datensatzes ist ein Fremdschlüssel für eine Tabelle von Fremdschlüsseln für andere Datensätze.

Gegeben: Tabelle - Ing_Fundamental

+----------------+-------------------+ 
| ID_Fundamental | ID_Title_Category | 
+----------------+-------------------+ 

Tabelle - Title_Category

+-------------------+----------+-------------+ 
| ID_Title_Category | ID_Title | ID_Category | 
+-------------------+----------+-------------+ 

Tabelle - Titel

+----------+-------+ 
| ID_Title | Title | 
+----------+-------+ 

Tabelle - Kategorien

+-------------+----------+ 
| ID_Category | Category | 
+-------------+----------+ 

Ich möchte das ID_Title_Category Feld auswählen, wo und Categories.Category = "Meat".

My SQL INSERT-Anweisung:

INSERT INTO Ing_Fundamental 
(
    Ing_Fundamental.ID_Title_Category 
) 
VALUES 
(
    (SELECT ????) 
) 

Hier ist die SQL für Ing_Fundamental CREATE TABLE-Anweisung:

CREATE TABLE IF NOT EXISTS Ing_Fundamental 
(
    ID_Fundamental INTEGER UNSIGNED PRIMARY KEY AUTO_INCREMENT NOT NULL, 
    ID_Title_Category INTEGER UNSIGNED, 
    FOREIGN KEY fk_ID_Title_Category(ID_Title_Category) 
     REFERENCES ing_title_categories(ID_Title_Category) 
     ON UPDATE CASCADE 
     ON DELETE RESTRICT, 
    UNIQUE(ID_Title_Category) 
) 

Mein Versuch an der SELECT-Anweisung ist:

(SELECT Ing_Title_Categories.ID_Title_Category 
FROM Ing_Title_Categories 
WHERE (ID_Title_Category = 0)) 

Aber die oben Anweisung wird nicht ordnungsgemäß funktionieren, da ID_Title_Category Feldwert ist n ot richtig, es muss durch Nachschlagen von Werten in den Titles und Categories Tabellen ermittelt werden. Wie lautet die SQL-Syntax für die Auswahl des Felds ID_Title_Category basierend auf den Feldern in den Tabellen Titles und Categories?

Edit 1: Hintergrund/design
Ein grundlegender Bestandteil hat eine eindeutige ID.
Eine grundlegende Zutat hat einen Titel und eine Kategorie.
Kategorien sind festgelegt (begrenzt).

Ein Benutzer möchte die Datenbank anhand eines Titels und einer Kategorie nach einer Zutat durchsuchen.

Ein Rezept enthält einen oder mehrere Bestandteile (Inhaltsstoff-IDs).

Ich erinnere mich nicht an meine Begründung für die Title_Category-Tabelle; Es könnte entweder Normalisierung sein oder die Notwendigkeit eines zusammengesetzten Primärschlüssels verringern.

Ich schreibe eine Anwendung in C++, um über SQL-Anweisungen und Abfragen mit der Datenbank zu interagieren.

In Programmierungsterminologie:
Der Ing_Fundamental-Datensatz enthält einen Title_Category-Datensatz.
Der Title_Category-Datensatz enthält einen Titeldatensatz und einen Kategoriedatensatz.
Alle Datensätze enthalten ein ID-Feld und ein oder mehrere Datenfelder (z. B. Text).

Answer 1

Ich möchte das ID_Title_Category Feld, wo Titles.Title = "Hamburger" und Categories.Category = "Meat" auszuwählen.

Das ergibt keinen Sinn. Vermutlich meinst du so etwas wie du willst select ID_Title_Category from Title_Category wherecondition. Aber was ist condition? Was sind die Zeilen Titles und Categories? Sie müssen nicht mehr SQL wissen, um das zu sagen.

Sie könnte bedeuten, dass Sie select ID_Title_Category fromTitle_Category Reihen wollen, wo Zeile (ID_Title) in select ID_Table from Titles where Title = 'Hamburger' ist und wo Reihe (ID_Category) ist in select ID_Category from Categories where Category = 'Meat'.

Dann ist es hilfreich zu wissen, dass SQL Sie (...) in (subselect) schreiben lässt.

select ID_Title_Category 
from Title_Category 
where (ID_Title) in (select ID_Title from Titles where Title = 'Hamburger') 
and (ID_Category) in (select ID_Category from Categories where Category = 'Meat') 

Oder Sie könnte bedeuten, dass Sie select ID_Title_Category fromTitle_Category Reihen TC (sagen wir), wo es Werte gibt es für T.ID_Title & C.ID_Category wo Zeile T (sagen wir) in Titles und TC.ID_Title = T.ID_Title and T.Title = 'Hamburger' und Reihen C (sagen wir) in Categories ist und TC.ID_Category = C.ID_Category and C.Category = 'Meat'.

Dann ist es gut zu wissen, dass in SQL T cross join U Zeilen (T.X,...,U.Y,...) wo Zeile (T.X,...) in T ist und Zeile (U.Y,...) ist in U. (, ist cross join Bindung lockerer als die verschiedenen join s.)

select TC.ID_Title_Category 
from Title_Category TC 
cross join Titles T 
cross join Categories C 
where TC.ID_Title = T.ID_Title and T.Title = 'Hamburger' 
and TC.ID_Category = C.ID_Category and C.Category = 'Meat' 

Auch T cross join U und condition kann als T join U oncondition ausgedrückt werden.

select TC.ID_Title_Category 
from Title_Category TC 
join Titles T 
on TC.ID_Title = T.ID_Title and T.Title = 'Hamburger' 
join Categories C 
on TC.ID_Category = C.ID_Category and C.Category = 'Meat' 

Sie könnten eine andere Version schreiben zu wissen, dass in SQL dort in subselect wenn EXISTS(subselect) eine Zeile vorhanden ist.

Wir müssen keine Abhängigkeiten (PK, UNIQUE, FK, usw.) zur Abfrage kennen. Wir müssen, was jede Basis-Tabellenzeile über die Situation sagt. Dann können wir ausdrücken, welche Zeilen im Ergebnis stehen über welche Zeilen in Basistabellen sind. Um Beziehungsoperatoren zu verwenden, müssen wir wissen, wie man zwischen Prädikatausdrücken & Relationen übersetzen kann. Wir können auch die Zeilen im Ergebnis über das, was jede Zeile über die Situation sagt, beschreiben. (So ​​würden Sie die intuitive Verwendung von in rechtfertigen.) Is there any rule of thumb to construct SQL query from a human-readable description?