Explication de l'auto-jointures

c'est assez courant quand vous avez un tableau qui se réfère à lui-même. Exemple: une table d'employés où chaque employé peut avoir un gestionnaire, et vous voulez énumérer tous les employés et le nom de leur gestionnaire.

SELECT e.name, m.name
FROM employees e LEFT OUTER JOIN employees m
ON e.manager = m.id

Une auto-jointure est une jointure d'une table avec elle-même.

un cas d'usage courant est lorsque la table stocke des entités (enregistrements) qui ont une relation hiérarchique entre elles . Par exemple, un tableau contenant des informations sur la personne (Nom, Date de naissance, adresse)...) et y compris une colonne où L'identification du Père (et/ou de la mère) est incluse. Puis avec une petite requête comme

SELECT Child.ID, Child.Name, Child.PhoneNumber, Father.Name, Father.PhoneNumber
FROM myTableOfPersons As Child
LEFT OUTER JOIN  myTableOfPersons As Father ON Child.FatherId = Father.ID
WHERE Child.City = 'Chicago'  -- Or some other condition or none

nous pouvons obtenir des informations sur l'enfant et le père (et la mère, avec un second moi rejoignent etc. et même les grands parents etc...) dans la même requête.

disons que vous avez une table users , configurée comme ceci:

• ID utilisateur
• nom d'utilisateur
• du responsable de l'utilisateur ID

dans cette situation, si vous voulez extraire à la fois l'information de l'utilisateur et l'information du gestionnaire dans une requête, vous pourriez faire ceci:

SELECT users.user_id, users.user_name, managers.user_id AS manager_id, managers.user_name AS manager_name INNER JOIN users AS manager ON users.manager_id=manager.user_id

Ils sont utiles si votre table est auto-référentielle. Par exemple, pour un tableau de pages, chaque page peut avoir un lien next et previous . Ce sont les Id des autres pages du même tableau. Si à un certain moment vous voulez obtenir un triple de pages successives, vous feriez deux auto-jointures sur les colonnes next et previous avec la même colonne de table id .

sans la possibilité pour une table de se référencer, nous aurions à créer autant de tables pour les niveaux de hiérarchie que le nombre de couches dans la hiérarchie. Mais puisque cette fonctionnalité est disponible, vous rejoignez la table à elle-même et sql le traite comme deux tables séparées, de sorte que tout est bien stocké dans un endroit.

Imaginez une table appelée Employee comme décrit ci-dessous. Tous les employés ont un gestionnaire qui est aussi un employé (peut-être à l'exception du CEO, dont le manager_id serait nul)

Table (Employee): 

int id,
varchar name,
int manager_id

vous pouvez ensuite utiliser le select suivant pour trouver tous les employés et leurs gestionnaires:

select e1.name, e2.name as ManagerName
from Employee e1, Employee e2 where
where e1.manager_id = e2.id

il y a beaucoup de bonnes réponses ici, mais il y a une variation qui est tout aussi correcte. Vous pouvez placer vos conditions de jointure dans la déclaration de jointure au lieu de la clause où.

SELECT e1.emp_id AS 'Emp_ID'
  , e1.emp_name AS 'Emp_Name'
  , e2.emp_id AS 'Manager_ID'
  , e2.emp_name AS 'Manager_Name'
FROM Employee e1 RIGHT JOIN Employee e2 ON e1.emp_id = e2.emp_id

gardez à l'esprit que parfois vous voulez e1.manager_id > e2.carte d'identité no 151930920."

l'avantage de connaître les deux scénarios est parfois vous avez une tonne D'où ou rejoindre les conditions et vous voulez placer vos conditions d'adhésion dans l'autre clause pour garder votre code lisible.

personne n'a parlé de ce qui se passe lorsqu'un employé n'a pas de gestionnaire. Hein? Ils ne sont pas inclus dans le jeu de résultats. Que faire si vous voulez inclure des employés qui n'ont pas de gestionnaires, mais que vous ne voulez pas que les combinaisons incorrectes soient retournées?

essayez ce chiot;

SELECT e1.emp_id AS 'Emp_ID'
   , e1.emp_name AS 'Emp_Name'
   , e2.emp_id AS 'Manager_ID'
   , e2.emp_name AS 'Manager_Name'
FROM Employee e1 LEFT JOIN Employee e2 
   ON e1.emp_id = e2.emp_id
   AND e1.emp_name = e2.emp_name
   AND e1.every_other_matching_column = e2.every_other_matching_column

en dehors des réponses mentionnées ci-dessus (qui sont très bien expliquées), je voudrais ajouter un exemple pour que l'utilisation de L'auto-jointure puisse être facilement montrée. Supposons que vous ayez une table nommée CUSTOMERS qui possède les attributs suivants:: CustomerID, Nomclient, Contact, Ville, Pays. Maintenant, vous voulez lister tous ceux qui sont de la "même ville" . Vous devrez penser à une réplique de cette table afin que nous puissions les rejoindre sur la base de la ville. La requête ci-dessous montre clairement ce que cela signifie:

SELECT A.CustomerName AS CustomerName1, B.CustomerName AS CustomerName2, 
A.City
FROM Customers A, Customers B
WHERE A.CustomerID <> B.CustomerID
AND A.City = B.City 
ORDER BY A.City;

un cas d'utilisation est la vérification des enregistrements en double dans une base de données.

SELECT A.Id FROM My_Bookings A, My_Bookings B
WHERE A.Name = B.Name
AND A.Date = B.Date
AND A.Id != B.Id

C'est la base de données équivalent d'une liste chaînée/arbre, où une ligne contient une référence à une autre ligne.

voici l'exaplanation de moi-même rejoindre en termes profanes. SELF join n'est pas un type différent de join. Si vous avez compris d'autres types de jointures (internes, externes et croisées), alors la jointure de soi doit être simple en avant. Dans les joints intérieurs, extérieurs et en croix, vous rejoignez 2 ou plusieurs tables différentes. Cependant, en vous rejoignez vous rejoignez la même table avec sonlef. Ici, nous n'avons pas deux tables différentes, mais traitons la même table comme une table différente en utilisant des alias de table. Si ce n'est toujours pas clair, je recommande de regarder les vidéos youtube suivantes.

Auto Jointure avec un exemple