Selbstverknüpfung in SQL | Beste Erklärung mit Beispielen-js-Tutorial-php.cn

Self Join in SQL | Best Explanation with Examples

Was ist ein Self-Join in SQL?

Ein Self-Join in SQL ist eine Art Join, bei dem eine Tabelle mit sich selbst verknüpft wird. Dies ist nützlich, wenn Sie Zeilen innerhalb derselben Tabelle vergleichen oder verwandte Daten aus demselben Datensatz abrufen möchten. Selbstverknüpfungen werden häufig verwendet, um hierarchische Beziehungen zu modellieren (z. B. Mitarbeiter-Manager-Strukturen) oder um Kombinationen innerhalb einer Gruppe zu finden (z. B. mögliche Match-Ups zwischen Teams).

Definition:

Ein Self-Join ist ein regulärer Join, bei dem die Tabelle unter Verwendung verschiedener Aliase mit sich selbst verbunden wird. Es wird im Wesentlichen verwendet, um Zeilen einer Tabelle mit anderen Zeilen innerhalb derselben Tabelle zu vergleichen.

Syntax:

SELECT a.column1, b.column2
FROM table_name a
JOIN table_name b ON a.common_column = b.common_column;

Nach dem Login kopieren

Erklärung:

table_name a: Erstellt einen Alias (a) für die Tabelle.
table_name b: Erstellt einen weiteren Alias (b) für dieselbe Tabelle.
ON a.common_column = b.common_column: Die Bedingung zum Verbinden der beiden Aliase basierend auf gemeinsamen Spalten.

1. Beispiel für einen Selbstbeitritt: Mitarbeiter- und Manager-Szenario

Szenario:

Sie haben eine Mitarbeitertabelle und müssen herausfinden, welcher Mitarbeiter welchem Manager unterstellt ist. Jede Zeile in der Tabelle enthält Details zu den Mitarbeitern und die Spalte „ManagerID“ enthält die Mitarbeiter-ID des Managers.

Beispieltabellenerstellung und Dateneinfügung:

-- Create the Employees table
CREATE TABLE Employees (
    EmployeeID NUMBER PRIMARY KEY,
    EmployeeName VARCHAR2(50),
    ManagerID NUMBER
);

Nach dem Login kopieren

-- Insert sample data
INSERT INTO Employees (EmployeeID, EmployeeName, ManagerID) 
VALUES (1, 'John', NULL);
INSERT INTO Employees (EmployeeID, EmployeeName, ManagerID) 
VALUES (2, 'Mike', 1);
INSERT INTO Employees (EmployeeID, EmployeeName, ManagerID) 
VALUES (3, 'Sarah', 1);
INSERT INTO Employees (EmployeeID, EmployeeName, ManagerID) 
VALUES (4, 'Kate', 2);
INSERT INTO Employees (EmployeeID, EmployeeName, ManagerID) 
VALUES (5, 'Tom', 2);


-- Commit the changes
COMMIT;

Nach dem Login kopieren

Selbstverknüpfungsabfrage in Oracle:

SELECT e1.EmployeeName AS Employee, 
       e2.EmployeeName AS Manager
FROM Employees e1
LEFT JOIN Employees e2 ON e1.ManagerID = e2.EmployeeID;

Nach dem Login kopieren

Erklärung:

e1 ist ein Alias, der Mitarbeiter repräsentiert.
e2 ist ein weiterer Alias, der Manager repräsentiert.

Der LEFT JOIN hilft dabei, alle Mitarbeiter einzubeziehen, auch diejenigen, die keinen Manager haben (ManagerID ist NULL).

Ausgabe:

Employee	Manager
John	NULL
Mike	John
Sarah	John
Kate	Mike
Tom	Mike

2. Beispiel für den Selbstbeitritt: IPL-Spiele (jedes Team spielt einmal gegen jedes andere Team)

Szenario:

Sie haben eine Liste von IPL-Teams und möchten eine Liste von Spielen erstellen, bei denen jedes Team einmal gegen jedes andere Team spielt.

Beispieltabellenerstellung und Dateneinfügung:

-- Create the Teams table
CREATE TABLE Teams (
    TeamID NUMBER PRIMARY KEY,
    TeamName VARCHAR2(100)
);

Nach dem Login kopieren

-- Insert sample data
INSERT INTO Teams (TeamID, TeamName) 
VALUES (1, 'Mumbai Indians');
INSERT INTO Teams (TeamID, TeamName) 
VALUES (2, 'Chennai Super Kings');
INSERT INTO Teams (TeamID, TeamName) 
VALUES (3, 'Royal Challengers Bangalore');
INSERT INTO Teams (TeamID, TeamName) 
VALUES (4, 'Kolkata Knight Riders');

-- Commit the changes
COMMIT;

Nach dem Login kopieren

Selbstverknüpfungsabfrage in Oracle:

SELECT t1.TeamName AS Team1, 
       t2.TeamName AS Team2
FROM Teams t1
JOIN Teams t2 ON t1.TeamID < t2.TeamID;

Nach dem Login kopieren

Erklärung:

t1 und t244 sind Aliase für die Teams-Tabelle.

Die Bedingung t1.TeamID < t2.TeamID stellt sicher, dass jede Spielpaarung nur einmal aufgeführt wird (wodurch Duplikate wie Team A vs. Team B und Team B vs. Team A vermieden werden).

Ausgabe:

Team1	Team2
Mumbai Indians	Chennai Super Kings
Mumbai Indians	Royal Challengers Bangalore
Mumbai Indians	Kolkata Knight Riders
Chennai Super Kings	Royal Challengers Bangalore
Chennai Super Kings	Kolkata Knight Riders
Royal Challengers Bangalore	Kolkata Knight Riders

3. Self-Join Example: IPL Matches (Every Team Plays Against Every Other Team Twice)

Scenario:

You want to generate a list where each IPL team plays against every other team twice (once as the home team, and once as the away team).

Self-Join Query in Oracle:

SELECT t1.TeamName AS Team1, 
       t2.TeamName AS Team2
FROM Teams t1
JOIN Teams t2 ON t1.TeamID != t2.TeamID;

Nach dem Login kopieren

Explanation:

t1 and t2 are aliases for the Teams table.

The condition t1.TeamID != t2.TeamID ensures that all possible match-ups are listed, including both Team A vs. Team B and Team B vs. Team A.

Output:

Team1	Team2
Mumbai Indians	Chennai Super Kings
Mumbai Indians	Royal Challengers Bangalore
Mumbai Indians	Kolkata Knight Riders
Chennai Super Kings	Mumbai Indians
Chennai Super Kings	Royal Challengers Bangalore
Chennai Super Kings	Kolkata Knight Riders
Royal Challengers Bangalore	Mumbai Indians
Royal Challengers Bangalore	Chennai Super Kings
Royal Challengers Bangalore	Kolkata Knight Riders
Kolkata Knight Riders	Mumbai Indians
Kolkata Knight Riders	Chennai Super Kings
Kolkata Knight Riders	Royal Challengers Bangalore

Finding Duplicate Customer Records - Additional Example

Scenario:
You have a Customers table where each customer should have a unique combination of FirstName, LastName, and DateOfBirth. However, there may be accidental duplicates, and you want to identify them using a self-join.

Sample Table Creation and Data Insertion:

-- Create the Customers table
CREATE TABLE Customers (
    CustomerID NUMBER PRIMARY KEY,
    FirstName VARCHAR2(50),
    LastName VARCHAR2(50),
    DateOfBirth DATE
);

Nach dem Login kopieren

-- Insert sample data (including duplicates)
INSERT INTO Customers (CustomerID, FirstName, LastName, DateOfBirth) VALUES (1, 'John', 'Doe', TO_DATE('1990-01-01', 'YYYY-MM-DD'));
INSERT INTO Customers (CustomerID, FirstName, LastName, DateOfBirth) VALUES (2, 'Jane', 'Smith', TO_DATE('1992-02-02', 'YYYY-MM-DD'));
INSERT INTO Customers (CustomerID, FirstName, LastName, DateOfBirth) VALUES (3, 'John', 'Doe', TO_DATE('1990-01-01', 'YYYY-MM-DD'));
INSERT INTO Customers (CustomerID, FirstName, LastName, DateOfBirth) VALUES (4, 'Alice', 'Johnson', TO_DATE('1995-03-03', 'YYYY-MM-DD'));
INSERT INTO Customers (CustomerID, FirstName, LastName, DateOfBirth) VALUES (5, 'John', 'Doe', TO_DATE('1990-01-01', 'YYYY-MM-DD'));

-- Commit the changes
COMMIT;

Nach dem Login kopieren

Self-Join Query to Find Duplicates:

SELECT c1.CustomerID AS DuplicateRecordID1, 
       c2.CustomerID AS DuplicateRecordID2, 
       c1.FirstName, 
       c1.LastName, 
       c1.DateOfBirth
FROM Customers c1
JOIN Customers c2 ON c1.FirstName = c2.FirstName
                 AND c1.LastName = c2.LastName
                 AND c1.DateOfBirth = c2.DateOfBirth
                 AND c1.CustomerID < c2.CustomerID;

Nach dem Login kopieren

Explanation:

c1 and c2 are aliases for the same Customers table.
The condition c1.FirstName = c2.FirstName AND c1.LastName = c2.LastName AND c1.DateOfBirth = c2.DateOfBirth checks for matching values across multiple columns, indicating a duplicate.
c1.CustomerID < c2.CustomerID ensures that each duplicate pair is shown only once, avoiding repetition like Customer A vs. Customer B and Customer B vs. Customer A.

Output:

RecordID1	RecordID2	FirstName	LastName	DateOfBirth
1	3	John	Doe	1990-01-01
1	5	John	Doe	1990-01-01
3	5	John	Doe	1990-01-01

Conclusion:

A self-join allows you to connect rows from the same table by creating multiple aliases. It is useful in scenarios where data needs to be compared within the same dataset. In the above examples:
The employee-manager example shows how to use self-joins for hierarchical data.
The IPL match-ups illustrate how to generate combinations within a single dataset, whether for a single match per pair or double matches (home and away games).
These scenarios demonstrate the flexibility and power of self-joins in SQL.

Das obige ist der detaillierte Inhalt vonSelbstverknüpfung in SQL | Beste Erklärung mit Beispielen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!