მარტივი JOIN მაგალითები. MySQL JOIN: აღწერა, ბრძანების გამოყენების მაგალითი და რეკომენდაციები Mysql განახლება მარცხენა შეერთების მაგალითები
MySQL-ში JOIN-ის გამოყენებით არჩევა შეიძლება განხორციელდეს სხვადასხვა გზით. ჩვენ შევეცდებით განვიხილოთ ყველა ამ ტიპის მოთხოვნა. აქ არის ყველა შეკითხვის სია, რომელიც მოიცავს JOIN-ს:
და აქ არის ამ ტიპის JOIN-ის ილუსტრაცია:
სტატიას დავამაგრებ ფაილებს ჩვენი საიტიდან, რომელთა შორის იქნება join.php რომელშიც ყველა ჩანაწერს გამოვაჩენ სხვადასხვა JOIN ოპერატორის გამოყენებით.
შიდა შეერთებაჩვენ დავიწყებთ ამ INNER JOIN ოპერატორით, რადგან ეს ოპერატორი ნაგულისხმევად მუშაობს, თუ თქვენ უბრალოდ დაწერთ JOIN მოთხოვნაში. ეს ოპერატორი ირჩევს ყველა ჩანაწერს ორი ცხრილიდან, სადაც ON ოპერატორის შემდეგი პირობა დაკმაყოფილებულია. ჩვენ გვაქვს ორი ცხრილი ფაილები და შეტყობინებები:
შეტყობინებების ცხრილი:
JOIN-ით შეკითხვა იქნება შემდეგი:
აირჩიეთ * შეტყობინებებიდან INNER Join ფაილები ON Messages.fid=Files.fid
შედეგად, შემდეგი ჩანაწერები გამოჩნდება:
ფაილების ცხრილი:
LEFT JOIN საჭირო იქნება, როდესაც ჩვენ ვაჩვენებთ ყველა შეტყობინების ჩანაწერს და არის თუ არა მიმაგრებული ფაილი, ჩვენ შევამოწმებთ PHP-ის საშუალებით.
LEFT JOIN მარჯვენა ცხრილთან კვეთის გარეშეLEFT JOIN აბრუნებს ყველა ჩანაწერს მარცხენა ცხრილიდან, გარდა იმ ჩანაწერებისა, რომელთა ფიდი ემთხვევა მარჯვენა ცხრილს.
შეტყობინებების ცხრილი:
შეკითხვა LEFT JOIN-ით კვეთების გარეშე იქნება:
SELECT * FROM Messages LEFT Join Files ON Messages.fid=Files.fid WHERE Files.fid IS NULL
შედეგად, ჩვენ ვიღებთ ასეთ არჩევანს:
ფაილების ცხრილი:
RIGHT JOIN საჭირო იქნება, როდესაც ჩვენ ვაჩვენებთ ყველა მიმაგრებულ ფაილს, არ აქვს მნიშვნელობა გამოიყენება თუ არა ისინი, მხოლოდ ყველა ფაილს.
RIGHT JOIN კვეთების გარეშეRIGHT JOIN კვეთების გარეშე აჩვენებს ყველა ჩანაწერს მარჯვენა ცხრილიდან, გარდა იმ ჩანაწერებისა, რომლებსაც აქვთ კვეთა მარცხენა ცხრილთან.
შეტყობინებების ცხრილი:
მოთხოვნა RIGHT JOIN-ით კვეთების გარეშე იქნება:
SELECT * FROM Messages RIGHT Join Files ON Messages.fid=Files.fid WHERE Messages.fid IS NULL
ამრიგად, ჩვენ მივიღებთ შემდეგ მონაცემებს:
| შუა | სხეულის ტექსტი | ფიდ | გზა |
| NULL | NULL | 1 | /files/1.png |
RIGHT JOIN საჭირო იქნება ყველა თანდართული ფაილის ჩვენებისას, რომლებიც არ არის მიმაგრებული არცერთ შეტყობინებაზე. მაგალითად, თუ გვინდა გამოვაჩინოთ ფაილები, რომლებიც არ გამოიყენება.
სრული გარე შეერთებამიუხედავად იმისა, რომ SQL-ს აქვს FULL OUTER JOIN ოპერატორი, MySQL-ს არ აქვს ეს ოპერატორი. ფაქტია, რომ ასეთი ოპერატორი სერვერზე უზარმაზარი დატვირთვაა. ახლა გვაქვს 3 ფაილი და 3 შეტყობინება, ხოლო მოთხოვნის შესრულების შედეგად ყალიბდება 4 ხაზი. არ ვარ დარწმუნებული, რომ კარგი იდეაა დაწეროთ მოთხოვნა, რომელიც აერთიანებს ორ მოთხოვნას, LEFT JOIN და RIGHT JOIN. მაგრამ მაინც შესაძლებელია FULL OUTER JOIN მოთხოვნის მიბაძვა.
შეტყობინებების ცხრილი:
მოთხოვნის ემულაცია FULL OUTER JOIN-ით იქნება შემდეგი:
SELECT * FROM Messages LEFT Join Files ON Messages.fid = Files.fid UNION SELECT * FROM Messages RIGHT Join Files ON Messages.fid = Files.fid
ამ მოთხოვნაში, ჩვენ ვიყენებთ UNION ოპერატორს, რათა შევუერთოთ ორ მოთხოვნას LEFT JOIN და RIGHT JOIN.
შედეგად, ჩვენ მივიღებთ შემდეგ ჩანაწერებს:
| შუა | სხეულის ტექსტი | ფიდ | გზა |
| 1 | ტესტი | 2 | /files/2.png |
| 2 | გამარჯობა | NULL | NULL |
| 3 | გამარჯობა | 3 | /files/3.png |
| NULL | NULL | 1 | /files/1.png |
და აქ მიჭირს იმის თქმა, თუ რატომ არის საჭირო FULL OUTER JOIN. მაგრამ რადგან ის არის SQL-ში, ის ალბათ მოგვიანებით იქნება საჭირო.
სრული გარე შეერთება კვეთების გარეშესხვა ტიპის JOIN კიდევ უფრო გიჟურია, ვიდრე უბრალოდ FULL OUTER JOIN, კერძოდ FULL OUTER JOIN კვეთების გარეშე. ვერც კი შემოგთავაზებთ სად შეიძლება ამ ტიპის JOIN-ის გამოყენება. რადგან შედეგად ვიღებთ ფაილებს, რომლებიც არ გამოიყენება და შეტყობინებებს ფაილების გარეშე. და როგორც ალბათ უკვე მიხვდით, ეს ოპერატორი ასევე არ არის MySQL-ში. რჩება მხოლოდ მისი მიბაძვა ორი ოპერატორის გამოყენებით: LEFT JOIN ჩამოთვლების გარეშე და RIGHT JOIN კვეთების გარეშე.
FULL OUTER JOIN მოთხოვნის ემულაცია კვეთების გარეშე:
$sql = "SELECT * FROM Messages LEFT Join Files ON Messages.fid = Files.fid WHERE Files.fid IS NULL UNION SELECT * FROM Messages RIGHT Join Files ON Messages.fid = Files.fid WHERE Messages.fid IS NULL";
შედეგად (წყაროს ცხრილები იგივეა, რაც მაგალითში FULL OUTER JOIN) ვიღებთ:
| შუა | სხეულის ტექსტი | ფიდ | გზა |
| 2 | გამარჯობა | NULL | NULL |
| NULL | NULL | 1 | /files/1.png |
ალბათ სულ ეს არის, შემდეგ გაკვეთილებზე ჩვენ დავიწყებთ კიდევ უფრო რთული მოთხოვნების დაწერას რამდენიმე ცხრილზე ერთდროულად.
9.5Kამ სტატიაში ჩვენ განვიხილავთ MySQL LEFT JOIN ოპერატორს და როგორ გამოვიყენოთ იგი მონაცემთა ორი ან მეტი მონაცემთა ბაზის ცხრილიდან მოთხოვნისთვის.
შესავალი LEFT JOIN MySQLMySQL LEFT JOIN ოპერატორი საშუალებას გაძლევთ მოიძიოთ მონაცემები ორი ან მეტი მონაცემთა ბაზის ცხრილიდან. ეს არის SELECT განცხადების არასავალდებულო ნაწილი, რომელიც გამოჩნდება FROM-ის შემდეგ.
დავუშვათ, რომ თქვენ აპირებთ მონაცემთა მოთხოვნას t1 და t2 ცხრილებიდან. ქვემოთ მოყვანილი მოთხოვნის მაგალითის გამოყენებით, ჩვენ ვაჩვენებთ LEFT JOIN სინტაქსის ორი ცხრილის შეერთებით:
SELECT t1.c1, t1.c2, t2.c1, t2.c2 FROM t1 LEFT JOIN t2 ON t1.c1 = t2.c1;
როდესაც თქვენ უერთდებით ცხრილებს t1 და t2 LEFT JOIN ოპერატორის გამოყენებით, თუ მწკრივი მარცხენა ცხრილიდან t1 ემთხვევა მწკრივს მარჯვენა ცხრილიდან t2, შეერთების პირობის საფუძველზე (t1.c1 = t2.c1), ეს მწკრივი ჩაირთვება. შედეგის კომპლექტში.
თუ მარცხენა ცხრილის მნიშვნელობა არ ემთხვევა მარჯვენა ცხრილის მნიშვნელობას, მარცხენა ცხრილის მწკრივი ასევე შეირჩევა და შერწყმულია მარჯვენა ცხრილის "პირობით" სტრიქონს. "პირობითი" მწკრივი შეიცავს NULL-ს ყველა შესაბამისი სვეტისთვის SELECT განცხადებაში.
სხვა სიტყვებით რომ ვთქვათ, MySQL LEFT JOIN პირობა საშუალებას გაძლევთ აირჩიოთ სტრიქონები ორივე ცხრილიდან, რომლებიც ემთხვევა, პლუს ყველა სტრიქონი მარცხენა ცხრილიდან (t1), თუნდაც მარჯვენა ცხრილის შესატყვისი სტრიქონების გარეშე (t2).
შემდეგი დიაგრამა დაგეხმარებათ გაიგოთ, თუ როგორ მუშაობს LEFT JOIN მდგომარეობა. ორი წრის კვეთა არის რიგები, რომლებიც ემთხვევა ორივე ცხრილში, ხოლო მარცხენა წრის დარჩენილი ნაწილი არის რიგები t1 ცხრილში, რომლებსაც არ აქვთ შესაბამისი მწკრივი t2 ცხრილში. მაშასადამე, მარცხენა ცხრილის ყველა მწკრივი შედის შედეგების კომპლექტში.
გაითვალისწინეთ, რომ დაბრუნებული მნიშვნელობები ასევე უნდა ემთხვეოდეს პირობებს WHERE და HAVING პუნქტებში, თუ ეს პუნქტები ხელმისაწვდომია მოთხოვნაში. LEFT JOIN-ის გამოყენების მაგალითები MySQL LEFT JOIN ოპერატორის გამოყენება ორი ცხრილის შესაერთებლად
ავიღოთ მომხმარებლებისა და შეკვეთების ორი ცხრილი დემო ბაზიდან:
დიაგრამაში აღწერილ მონაცემთა ბაზაში:
- შეკვეთების ცხრილის თითოეული შეკვეთა უნდა ეკუთვნოდეს კლიენტს მომხმარებელთა ცხრილში;
- კლიენტების ცხრილის თითოეულ მომხმარებელს შეუძლია შეკვეთების ცხრილში ნული ან მეტი შეკვეთა.
თითოეული მომხმარებლის კუთვნილი შეკვეთების საპოვნელად, შეგიძლიათ გამოიყენოთ MySQL LEFT JOIN მაგალითი:
SELECT c.customerNumber, c.customerName, orderNumber, o.status FROM კლიენტები c LEFT JOIN შეკვეთები o ON c.customerNumber = o.customerNumber
მაგალითის ნახვა
მარცხენა ცხრილი არის კლიენტები, ამიტომ ყველა კლიენტი შედის შედეგების კომპლექტში. მაგრამ მას აქვს რიგები, რომლებსაც აქვთ მომხმარებლის მონაცემები, მაგრამ არ აქვთ შეკვეთის მონაცემები, მაგალითად. 168, 169 და ა.შ. შეკვეთის მონაცემები ამ რიგებში არის NULL. ეს ნიშნავს, რომ ამ მომხმარებლებს არ აქვთ შეკვეთები შესაბამის ცხრილში.
ვინაიდან ჩვენ გამოვიყენეთ სვეტის ერთი და იგივე სახელი (orderNumber) ორი ცხრილის შესაერთებლად, შეგვიძლია მოთხოვნა უფრო მოკლე გავხადოთ ქვემოთ მოცემული სინტაქსის გამოყენებით:
SELECT c.customerNumber, customerName, orderNumber, status FROM customers c LEFT JOIN შეკვეთების გამოყენებით (customerNumber);
თუ შეცვლით MySQL SELECT LEFT JOIN განცხადებას INNER JOIN განაცხადით, თქვენ მიიღებთ მხოლოდ კლიენტებს, რომლებმაც განათავსეს მინიმუმ ერთი შეკვეთა.
MySQL LEFT JOIN ოპერატორის გამოყენება შეუსაბამო რიგების მოსაძებნადLEFT JOIN ოპერატორი შეიძლება სასარგებლო იყოს, თუ გსურთ იპოვოთ რიგები მარცხენა ცხრილში, რომლებიც არ ემთხვევა მარჯვენა ცხრილის სტრიქონებს. იმისათვის, რომ იპოვოთ სტრიქონები, რომლებიც არ ემთხვევა ორ ცხრილს, თქვენ უნდა დაამატოთ WHERE პუნქტი SELECT შერჩევაში, რათა მოითხოვოთ მხოლოდ ის რიგები, რომელთა სვეტის მნიშვნელობები მარჯვენა ცხრილში შეიცავს NULL-ს.
მაგალითად, ყველა მომხმარებლის საპოვნელად, ვისაც არ გაუკეთებია შეკვეთა, გამოიყენეთ შემდეგი მოთხოვნა:
მაგალითის ნახვა
მდგომარეობა WHERE პუნქტში ან პირობა ON პუნქტშიგანვიხილოთ შემდეგი მაგალითი MySQL LEFT JOIN WHERE-ს გამოყენებით:
ამ მაგალითში, ჩვენ გამოვიყენეთ LEFT JOIN ოპერატორი შეკვეთების და orderDetails ცხრილებიდან მონაცემების გამოსათხოვად. მოთხოვნა აბრუნებს შეკვეთას და მის დეტალებს, ასეთის არსებობის შემთხვევაში, შეკვეთისთვის 10123.
SQL JOIN ოპერატორი შექმნილია ორი ან მეტი მონაცემთა ბაზის ცხრილის შესაერთებლად შესაბამისი პირობების საფუძველზე. ეს ოპერატორი არსებობს მხოლოდ რელაციურ მონაცემთა ბაზებში. JOIN-ის წყალობით, ურთიერთობების მონაცემთა ბაზებს აქვთ ისეთი ძლიერი ფუნქციონირება, რომელიც საშუალებას იძლევა არა მხოლოდ მონაცემთა შენახვა, არამედ მათი, სულ მცირე, უმარტივესი, ანალიზის შეკითხვის გამოყენებით. მოდით შევხედოთ SQL მოთხოვნების დაწერის ძირითად ნიუანსებს JOIN ოპერატორთან, რომლებიც საერთოა ყველა DBMS-ისთვის (მონაცემთა ბაზის მართვის სისტემები). ორი ცხრილის შესაერთებლად, SQL JOIN ოპერატორს აქვს შემდეგი სინტაქსი:
აირჩიეთ COLUMN_NAMES (1..N) TABLE_NAME_1-დან, შეუერთდით TABLE_NAME_2-ს CONDITION-ზე
ერთ ან რამდენიმე ბმულს JOIN ოპერატორთან შეიძლება მოჰყვეს სურვილისამებრ WHERE ან HAVING განყოფილება, რომელშიც, ისევე როგორც მარტივი SELECT შეკითხვაში, მითითებულია შერჩევის პირობა. ყველა DBMS-ისთვის საერთოა ის, რომ ამ კონსტრუქციაში, JOIN-ის ნაცვლად, შეიძლება იყოს მითითებული შიდა შეერთება, LEFT OUTER JOIN, RIGHT OUTER JOIN, FULL OUTER JOIN, CROSS JOIN (ან, ალტერნატიულად, მძიმით).
შიდა შეერთებამოთხოვნა INNER JOIN ოპერატორთან შექმნილია ცხრილების შესაერთებლად და შედეგად მიღებული ცხრილის ჩვენებისთვის, რომელშიც მონაცემები მთლიანად იკვეთება ON-ის შემდეგ მითითებული მდგომარეობის მიხედვით.
მარტივი JOIN აკეთებს იგივეს. ამრიგად, სიტყვა INNER არჩევითია.
მაგალითი 1. არსებობს სარეკლამო პორტალის მონაცემთა ბაზა. იგი შეიცავს კატეგორიების (რეკლამების კატეგორიების) და ნაწილების (ნაწილები, ან სხვაგვარად - სათაურები, რომლებიც მიეკუთვნება კატეგორიებს) ცხრილს. მაგალითად, ნაწილები ბინები და კოტეჯები ეკუთვნის უძრავი ქონების კატეგორიას, ხოლო ნაწილები მანქანები და მოტოციკლები ტრანსპორტის კატეგორიას. ეს ცხრილები შევსებული მონაცემებით ასე გამოიყურება:
ნაწილების ცხრილი:
გაითვალისწინეთ, რომ ნაწილების ცხრილში წიგნებს აქვს კატა - ბმული კატეგორიასთან, რომელიც არ არის კატეგორიების ცხრილში, ხოლო კატეგორიების ცხრილში აღჭურვილობას აქვს Cat_ID - პირველადი გასაღები, რომლის ბმული არ არის ნაწილებში. მაგიდა. საჭიროა ამ ორი ცხრილის მონაცემების გაერთიანება ისე, რომ მიღებული ცხრილი შეიცავდეს ნაწილის, კატას და ფასის ველებს და ისე, რომ მონაცემები მთლიანად ემთხვევა მდგომარეობის მიხედვით. პირობა არის შესაბამისობა კატეგორიის იდენტიფიკატორს შორის კატეგორიების ცხრილში და კატეგორიის ბმულს შორის ნაწილების ცხრილში. ამისათვის დაწერეთ შემდეგი მოთხოვნა:
SELECT PARTS.Part, CATEGORIES.Cat_ID AS Cat, CATEGORIES.Price FROM PARTS INNER Join CATEGORIES ON PARTS.Cat = CATEGORIES.Cat_ID
| ნაწილი | Კატა | ფასი |
| ბინები | 505 | 210,00 |
| მანქანები | 205 | 160,00 |
| დაფები | 10 | 105,00 |
| კარადები | 30 | 77,00 |
შედეგად ცხრილში არ არის წიგნები, რადგან ეს ჩანაწერი მიუთითებს კატეგორიაზე, რომელიც არ არის კატეგორიების ცხრილში, და აღჭურვილობა, რადგან ამ ჩანაწერს აქვს უცხო გასაღები კატეგორიების ცხრილში, რომელიც არ არის მითითებული ნაწილების ცხრილში.
ზოგიერთ შემთხვევაში, ცხრილების შეერთებისას, შეგიძლიათ შექმნათ ნაკლებად რთული მოთხოვნები EXISTS პრედიკატის გამოყენებით და JOIN-ის გამოყენების გარეშე.
არსებობს მონაცემთა ბაზა „თეატრი“. Play ცხრილი შეიცავს მონაცემებს პროდუქციის შესახებ. გუნდური მაგიდა - მსახიობების როლების შესახებ. მსახიობის მაგიდა მსახიობებზეა. დირექტორის მაგიდა - რეჟისორების შესახებ. ცხრილის ველები, პირველადი და უცხოური გასაღებები შეგიძლიათ იხილოთ ქვემოთ მოცემულ ფიგურაში (დააწკაპუნეთ მარცხნივ გასადიდებლად).
მაგალითი 3. აჩვენეთ მსახიობების სია, რომლებიც თამაშობენ ერთზე მეტ როლს ერთ სპექტაკლში და მათი როლების რაოდენობა.
გამოიყენეთ JOIN ოპერატორი 1 ჯერ. გამოიყენეთ HAVING, GROUP BY.
ნახავ. HAVING ოპერატორი ვრცელდება COUNT აგრეგატის ფუნქციით დათვლილი როლების რაოდენობაზე.
LEFT გარე შეერთებაშეკითხვა LEFT OUTER JOIN ოპერატორთან შექმნილია ცხრილების შესაერთებლად და შედეგად მიღებული ცხრილის ჩვენებისთვის, რომელშიც მონაცემები მთლიანად იკვეთება ON-ის შემდეგ მითითებულ პირობით და ავსებს ჩანაწერებს პირველი (მარცხნივ) ცხრილიდან, მაშინაც კი, თუ ისინი არ არიან. დააკმაყოფილოს პირობა. მარცხენა ცხრილის ჩანაწერებს, რომლებიც არ აკმაყოფილებენ პირობას, ექნება სვეტის მნიშვნელობა მარჯვენა ცხრილიდან, რომელიც არის NULL (განუსაზღვრელი).
მაგალითი 4. მონაცემთა ბაზა და ცხრილები იგივეა, რაც მაგალითად 1-ში.
მიღებული ცხრილის მისაღებად, რომელშიც ორი ცხრილის მონაცემები მთლიანად იკვეთება პირობით და ემატება ნაწილების ცხრილის ყველა მონაცემი, რომელიც არ აკმაყოფილებს პირობას, ჩაწერეთ შემდეგი მოთხოვნა:
SELECT PARTS.Part, CATEGORIES.Cat_ID AS Cat, CATEGORIES.Price FROM PARTS LEFT EXTER JOIN CATEGORIES ON PARTS.Cat = CATEGORIES.Cat_ID
შეკითხვის შედეგი იქნება შემდეგი ცხრილი:
| ნაწილი | Კატა | ფასი |
| ბინები | 505 | 210,00 |
| მანქანები | 205 | 160,00 |
| დაფები | 10 | 105,00 |
| კარადები | 30 | 77,00 |
| წიგნები | 160 | NULL |
მიღებულ ცხრილში, მაგალითად 1-ის ცხრილისგან განსხვავებით, არის წიგნები, მაგრამ Price სვეტის მნიშვნელობა არის NULL, რადგან ამ ჩანაწერს აქვს კატეგორიის იდენტიფიკატორი, რომელიც არ არის კატეგორიების ცხრილში.
მარჯვენა გარე შეერთებამოთხოვნა RIGHT OUTER JOIN ოპერატორით შექმნილია ცხრილების შესაერთებლად და შედეგად მიღებული ცხრილის საჩვენებლად, რომელშიც მონაცემები მთლიანად იკვეთება ჩართვის შემდეგ მითითებულ პირობით და ავსებს ჩანაწერებს მეორე (მარჯვნივ) ცხრილიდან, მაშინაც კი, თუ ისინი არ არიან. დააკმაყოფილოს პირობა. მარჯვენა ცხრილის ჩანაწერებს, რომლებიც არ აკმაყოფილებენ პირობას, ექნება სვეტის მნიშვნელობა მარცხენა ცხრილიდან, რომელიც არის NULL (განუსაზღვრელი).
მაგალითი 5.
მიღებული ცხრილის მისაღებად, რომელშიც ორი ცხრილის მონაცემები მთლიანად იკვეთება პირობის მიხედვით და ემატება ყველა მონაცემი კატეგორიების ცხრილიდან, რომელიც არ აკმაყოფილებს პირობას, ჩაწერეთ შემდეგი მოთხოვნა:
SELECT PARTS.Part, CATEGORIES.Cat_ID AS Cat, CATEGORIES.Price FROM PARTS RIGHT OUTER JOIN CATEGORIES ON PARTS.Cat = CATEGORIES.Cat_ID
შეკითხვის შედეგი იქნება შემდეგი ცხრილი:
| ნაწილი | Კატა | ფასი |
| ბინები | 505 | 210,00 |
| მანქანები | 205 | 160,00 |
| დაფები | 10 | 105,00 |
| კარადები | 30 | 77,00 |
| NULL | 45 | 65,00 |
მიღებულ ცხრილში, მაგალითი 1-ის ცხრილისგან განსხვავებით, არის ჩანაწერი 45 კატეგორიით და ფასი 65.00, მაგრამ ნაწილი სვეტის მნიშვნელობა არის NULL, რადგან ამ ჩანაწერს აქვს კატეგორიის იდენტიფიკატორი, რომელიც არ არის მითითებული ნაწილების ცხრილში.
სრული გარე შეერთება (სრული გარე შეერთება)FULL OUTER JOIN ოპერატორის მოთხოვნა შექმნილია ცხრილების შესაერთებლად და შედეგად მიღებული ცხრილის ჩვენებისთვის, რომელშიც მონაცემები მთლიანად იკვეთება ON-ის შემდეგ მითითებულ პირობით და ავსებს ჩანაწერებს პირველი (მარცხნივ) და მეორე (მარჯვნივ) ცხრილებიდან. მაშინაც კი, თუ ისინი არ აკმაყოფილებენ პირობას. ჩანაწერებს, რომლებიც არ აკმაყოფილებენ პირობას, ექნება სვეტები სხვა ცხრილიდან, რომლებიც არის NULL (განუსაზღვრელი).
მაგალითი 6. მონაცემთა ბაზა და ცხრილები იგივეა, რაც წინა მაგალითებში.
მიღებული ცხრილის მისაღებად, რომელშიც ორი ცხრილის მონაცემები მთლიანად იკვეთება პირობით და დამატებულია ყველა მონაცემი ნაწილების ცხრილიდან და კატეგორიების ცხრილიდან, რომლებიც არ აკმაყოფილებენ პირობას, ჩაწერეთ შემდეგი მოთხოვნა:
SELECT PARTS.Part, CATEGORIES.Cat_ID AS Cat, CATEGORIES.Price FROM PARTS FULL OUTER JOIN CATEGORIES ON PARTS.Cat = CATEGORIES.Cat_ID
შეკითხვის შედეგი იქნება შემდეგი ცხრილი:
| ნაწილი | Კატა | ფასი |
| ბინები | 505 | 210,00 |
| მანქანები | 205 | 160,00 |
| დაფები | 10 | 105,00 |
| კარადები | 30 | 77,00 |
| წიგნები | 160 | NULL |
| NULL | 45 | 65,00 |
შედეგად მიღებული ცხრილი შეიცავს წიგნების ჩანაწერებს (მარცხნივ ცხრილიდან) და კატეგორიაში 45 (მარჯვენა ცხრილიდან), მათგან პირველს აქვს განუსაზღვრელი ფასი (სვეტი მარჯვენა ცხრილიდან), ხოლო მეორეს აქვს განუსაზღვრელი ნაწილი (სვეტი). მარცხენა მაგიდიდან).
მეტსახელები გაერთიანებული ცხრილებისთვისწინა შეკითხვებში ჩვენ დავაზუსტეთ ამ ცხრილების სრული სახელები სხვადასხვა ცხრილებიდან ამოღებული სვეტების სახელებით. ასეთი კითხვები რთულად გამოიყურება: ერთი და იგივე სიტყვა რამდენჯერმე მეორდება. შესაძლებელია თუ არა დიზაინის როგორმე გამარტივება? გამოდის, რომ ეს შესაძლებელია. ამისათვის თქვენ უნდა გამოიყენოთ ცხრილის მეტსახელები - მათი შემოკლებული სახელები. მეტსახელი ასევე შეიძლება შედგებოდეს ერთი ასოსგან. ასოების ნებისმიერი რაოდენობა შესაძლებელია, მთავარია, რომ მოთხოვნა შემოკლების შემდეგ გასაგები იყოს თქვენთვის. ზოგადი წესია, რომ შეკითხვის შეერთების განყოფილებაში, ანუ სიტყვა JOIN-ის ირგვლივ, თქვენ უნდა მიუთითოთ ცხრილის სრული სახელები და თითოეულ სახელს უნდა მოჰყვეს ცხრილის მეტსახელი.
მაგალითი 7: გადაწერეთ მოთხოვნა 1-ლი მაგალითიდან, გაერთიანებული ცხრილების მეტსახელების გამოყენებით.
მოთხოვნა იქნება შემდეგი:
აირჩიეთ P.Part, C.Cat_ID AS Cat, C.Price ნაწილებიდან P შიდა შეერთება CATEGORIES C ON P.Cat = C.Cat_ID
მოთხოვნა დააბრუნებს იგივეს, რაც მოთხოვნას მაგალითში 1, მაგრამ ის ბევრად უფრო კომპაქტურია.
JOIN და შეუერთდი ორზე მეტ მაგიდასრელატიური მონაცემთა ბაზები უნდა შეესაბამებოდეს მონაცემთა მთლიანობისა და არაზედმეტობის მოთხოვნებს და, შესაბამისად, მონაცემები ერთი ბიზნეს პროცესის შესახებ შეიძლება შეიცავდეს არა მხოლოდ ერთ, ორ, არამედ სამ ან მეტ ცხრილში. ამ შემთხვევებში, მონაცემთა გასაანალიზებლად გამოიყენება დაკავშირებული ცხრილების ჯაჭვები: მაგალითად, ერთი (პირველი) ცხრილი შეიცავს გარკვეულ რაოდენობრივ ინდიკატორს, მეორე ცხრილი პირველსა და მესამეს უკავშირდება უცხო კლავიშებით - მონაცემები იკვეთება, მაგრამ მხოლოდ მესამე. ცხრილი შეიცავს პირობას, რომლის მიხედვითაც ეს შეიძლება იყოს რაოდენობრივი მაჩვენებელი პირველი ცხრილიდან გამომდინარეობს. და შეიძლება კიდევ უფრო მეტი მაგიდა იყოს. SQL JOIN ოპერატორის გამოყენებით, შეგიძლიათ შეუერთდეთ ცხრილების დიდ რაოდენობას ერთ მოთხოვნაში. ასეთ შეკითხვებში, ერთი შეერთების განყოფილებას მოსდევს მეორე და ყოველი მომდევნო JOIN უერთდება შემდეგ ცხრილს ცხრილს, რომელიც მეორე იყო ჯაჭვის წინა რგოლში. ამრიგად, SQL შეკითხვის სინტაქსი ორზე მეტი ცხრილის შესაერთებლად არის შემდეგი:
აირჩიეთ COLUMN_NAMES (1..N) TABLE_NAME_1-დან. შეუერთდით TABLE_NAME_2-ს, შემოუერთდით TABLE_NAME_3-ს CONDITION-ზე... შეუერთდით TABLE_NAME_M-ს CONDITION-ზე
მაგალითი 8. მონაცემთა ბაზა იგივეა, რაც წინა მაგალითებში. ამ მაგალითში რეკლამის ცხრილი დაემატება კატეგორიების და ნაწილების ცხრილებს, რომლებიც შეიცავს მონაცემებს პორტალზე გამოქვეყნებული რეკლამების შესახებ. აქ მოცემულია რეკლამის ცხრილის ფრაგმენტი, რომელშიც ჩანაწერებს შორის არის იმ რეკლამების ჩანაწერები, რომელთა გამოქვეყნების ვადა იწურება 02.04.2018.
| A_Id | ნაწილი_ID | თარიღი_დაწყება | თარიღი_დასრულება | ტექსტი |
| 21 | 1 | "2018-02-11" | "2018-04-20" | "ვყიდი..." |
| 22 | 1 | "2018-02-11" | "2018-05-12" | "ვყიდი..." |
| ... | ... | ... | ... | ... |
| 27 | 1 | "2018-02-11" | "2018-04-02" | "ვყიდი..." |
| 28 | 2 | "2018-02-11" | "2018-04-21" | "ვყიდი..." |
| 29 | 2 | "2018-02-11" | "2018-04-02" | "ვყიდი..." |
| 30 | 3 | "2018-02-11" | "2018-04-22" | "ვყიდი..." |
| 31 | 4 | "2018-02-11" | "2018-05-02" | "ვყიდი..." |
| 32 | 4 | "2018-02-11" | "2018-04-13" | "ვყიდი..." |
| 33 | 3 | "2018-02-11" | "2018-04-12" | "ვყიდი..." |
| 34 | 4 | "2018-02-11" | "2018-04-23" | "ვყიდი..." |
წარმოვიდგინოთ, რომ დღეს არის "2018-04-02", ანუ ეს მნიშვნელობა აღებულია CURDATE() ფუნქციით - მიმდინარე თარიღი. გაინტერესებთ, რომელ კატეგორიას განეკუთვნება ის რეკლამები, რომელთა გამოქვეყნების ბოლო ვადა დღეს არის. კატეგორიების სახელები მხოლოდ CATEGORIES ცხრილშია, ხოლო რეკლამის ვადის გასვლის თარიღები მხოლოდ ADS ცხრილში. PARTS ცხრილში - გამოქვეყნებული რეკლამის კატეგორიების ნაწილები (ან უფრო მარტივად, ქვეკატეგორიები). მაგრამ PARTS ცხრილი დაკავშირებულია უცხო გასაღების Cat_ID-ით CATEGORIES ცხრილთან, ხოლო ADS ცხრილი უკავშირდება უცხო გასაღების Part_ID PARTS ცხრილს. ამიტომ, ჩვენ ვაკავშირებთ სამ ცხრილს ერთ მოთხოვნაში და ამ შეკითხვას შეიძლება ეწოდოს ჯაჭვი მაქსიმალური სისწორით.
მოთხოვნა იქნება შემდეგი:
შეკითხვის შედეგი არის ცხრილი, რომელიც შეიცავს ორი კატეგორიის სახელებს - "უძრავი ქონება" და "ტრანსპორტი":
| კატა_სახელი |
| Უძრავი ქონება |
| ტრანსპორტი |
SQL CROSS JOIN ოპერატორის უმარტივესი ფორმით გამოყენება - შეერთების პირობის გარეშე - ახორციელებს დეკარტის პროდუქტის ოპერაციას რელაციურ ალგებრაში. ასეთი შეერთების შედეგი იქნება პირველი ცხრილის თითოეული მწკრივის შეერთება მეორე ცხრილის თითოეულ მწკრივთან. ცხრილები შეიძლება დაიწეროს მოთხოვნაში ან CROSS JOIN ოპერატორის საშუალებით ან გამოყოფილი მძიმით.
მაგალითი 9. მონაცემთა ბაზა ისევ იგივეა, ცხრილები არის კატეგორიები და ნაწილები. განახორციელეთ ამ ორი ცხრილის დეკარტისეული პროდუქტის მოქმედება.
მოთხოვნა იქნება შემდეგი:
აირჩიეთ (*) კატეგორიები CROSS JOIN ნაწილები
ან ცალსახად CROSS JOIN-ის მითითების გარეშე - გამოყოფილი მძიმეებით:
აირჩიეთ (*) კატეგორიები, ნაწილები
მოთხოვნა დააბრუნებს ცხრილს 5 * 5 = 25 სტრიქონით, რომლის ფრაგმენტი მოცემულია ქვემოთ:
| Cat_ID | კატა_სახელი | ფასი | ნაწილი_ID | ნაწილი | Კატა |
| 10 | Სამშენებლო მასალები | 105,00 | 1 | ბინები | 505 |
| 10 | Სამშენებლო მასალები | 105,00 | 2 | მანქანები | 205 |
| 10 | Სამშენებლო მასალები | 105,00 | 3 | დაფები | 10 |
| 10 | Სამშენებლო მასალები | 105,00 | 4 | კარადები | 30 |
| 10 | Სამშენებლო მასალები | 105,00 | 5 | წიგნები | 160 |
| ... | ... | ... | ... | ... | ... |
| 45 | ტექნიკა | 65,00 | 1 | ბინები | 505 |
| 45 | ტექნიკა | 65,00 | 2 | მანქანები | 205 |
| 45 | ტექნიკა | 65,00 | 3 | დაფები | 10 |
| 45 | ტექნიკა | 65,00 | 4 | კარადები | 30 |
| 45 | ტექნიკა | 65,00 | 5 | წიგნები | 160 |
როგორც მაგალითიდან ჩანს, თუ ასეთი მოთხოვნის შედეგს აქვს რაიმე მნიშვნელობა, მაშინ ეს შეიძლება იყოს ვიზუალური მნიშვნელობა ზოგიერთ შემთხვევაში, როდესაც არ არის საჭირო სტრუქტურირებული ინფორმაციის ჩვენება, განსაკუთრებით თუნდაც უმარტივესი ანალიტიკური ნიმუში. სხვათა შორის, თქვენ შეგიძლიათ მიუთითოთ სვეტები, რომლებიც უნდა იყოს ნაჩვენები თითოეული ცხრილიდან, მაგრამ მაშინაც კი, ასეთი მოთხოვნის საინფორმაციო ღირებულება არ გაიზრდება.
მაგრამ CROSS JOIN-ისთვის შეგიძლიათ დააყენოთ შეერთების პირობა! შედეგი სრულიად განსხვავებული იქნება. CROSS JOIN ცალსახად მითითების ნაცვლად მძიმე ოპერატორის გამოყენებისას, შეერთების პირობა მითითებულია არა ON სიტყვით, არამედ WHERE სიტყვით.
მაგალითი 10. იგივე სარეკლამო პორტალის მონაცემთა ბაზა, კატეგორიების და ნაწილების ცხრილები. ჯვარედინი შეერთების გამოყენებით, დააკავშირეთ ცხრილები ისე, რომ მონაცემები მთლიანად ემთხვევა მდგომარეობის მიხედვით. პირობა არის შესაბამისობა კატეგორიის იდენტიფიკატორს შორის კატეგორიების ცხრილში და კატეგორიის ბმულს შორის ნაწილების ცხრილში.
მოთხოვნა იქნება შემდეგი:
მოთხოვნა დაბრუნდება ისევე, როგორც მოთხოვნა მაგალითში 1:
| ნაწილი | Კატა | ფასი |
| ბინები | 505 | 210,00 |
| მანქანები | 205 | 160,00 |
| დაფები | 10 | 105,00 |
| კარადები | 30 | 77,00 |
და ეს დამთხვევა შემთხვევითი არ არის. შეერთების პირობის მიხედვით ჯვარედინი შეერთებით შეკითხვა მთლიანად ჰგავს შიდა შეერთებით შეკითხვას - INNER JOIN - ან, იმის გათვალისწინებით, რომ სიტყვა INNER არჩევითია, უბრალოდ JOIN.
ამრიგად, შეკითხვის რომელი ვარიანტი უნდა გამოვიყენოთ, ეს არის მონაცემთა ბაზის სპეციალისტის სტილის ან თუნდაც ჩვევის საკითხი. შესაძლოა, ჯვრის შეერთება ორ მაგიდაზე მდგომარეობით შეიძლება იყოს უფრო კომპაქტური. მაგრამ ორზე მეტი ცხრილისთვის ჯვარედინი შეერთების სარგებელი (ეს ასევე შესაძლებელია) ძალიან სადავოა. ამ შემთხვევაში გადაკვეთის WHERE პირობები ჩამოთვლილია AND სიტყვის მეშვეობით. ეს დიზაინი შეიძლება იყოს შრომატევადი და ძნელად წასაკითხი, თუ ასევე არის WHERE პუნქტი მოთხოვნის დასასრულს მისაღებად პირობებით.
რელატიური მონაცემთა ბაზები და SQL ენა
MySQL მხარს უჭერს შემდეგ JOIN განცხადების სინტაქსს SELECT განცხადებებში გამოყენებისას:
Table_reference, table_reference table_reference JOIN table_reference table_reference INNER JOIN table_reference join_condition table_reference STRAIGHT_JOIN table_reference table_reference LEFT JOIN table_reference join_condition table_reference LEFT JOIN table_reference table_reference JOINF_reference _ მითითება ჩართულია პირობითი_ ექსპრე ] JOIN table_reference
სადაც table_reference განისაზღვრება როგორც:
ცხრილის_სახელი[სხვა სახელი]
და join_condition განისაზღვრება როგორც:
ON conditional_expr | გამოყენება (სვეტის_სიტი)
თქვენ არასოდეს არ უნდა მიუთითოთ რაიმე პირობა ON პუნქტში, რომელიც აწესებს შეზღუდვებს შედეგების ნაკრების რიგებში. თუ თქვენ უნდა მიუთითოთ რომელი რიგები უნდა იყოს წარმოდგენილი შედეგში, ეს უნდა გააკეთოთ WHERE პუნქტში.
გთხოვთ გაითვალისწინოთ, რომ 3.23.17-მდე ვერსიებში, INNER JOIN ოპერატორი არ იღებს join_condition პარამეტრს!
LEFT OUTER JOIN გამოხატვის ზემოაღნიშნული ბოლო კონსტრუქციების არსებობა განპირობებულია მხოლოდ ODBC თავსებადობის მოთხოვნებით:
- ცხრილის მითითების ნაცვლად შეიძლება გამოყენებულ იქნას მეტსახელი, რომელიც მინიჭებულია გამონათქვამების tbl_name AS alias_name ან tbl_name alias_name: mysql> SELECT t1.name, t2.salary FROM თანამშრომელი AS t1, info AS t2 WHERE t1.name = t2. სახელი;
- ON პირობითი განცხადება არის პირობა ნებისმიერი ფორმით, რომელიც შეიძლება გამოყენებულ იქნას WHERE პუნქტში.
- თუ მარჯვენა ცხრილის ჩანაწერი არ არის ნაპოვნი LEFT JOIN-ის ON ან USING ნაწილებში, მაშინ ამ ცხრილისთვის გამოიყენება მწკრივი ყველა სვეტით დაყენებული NULL-ით. ამ მახასიათებლის გამოყენება შესაძლებელია ცხრილში შედეგების საპოვნელად, რომელსაც არ აქვს ექვივალენტი სხვა ცხრილში: mysql> SELECT table1.* FROM table1 LEFT JOIN table2 ON table1.id=table2.id WHERE table2.id IS NULL; ეს მაგალითი პოულობს ცხრილის 1-ის ყველა მწკრივს ID მნიშვნელობით, რომელიც არ არის ცხრილში2 (ანუ ცხრილის 1-ის ყველა სტრიქონი, რომლებისთვისაც არ არის შესაბამისი სტრიქონები ცხრილში2). რა თქმა უნდა, ეს ვარაუდობს, რომ table2.id გამოცხადებულია როგორც NOT NULL. იხილეთ ნაწილი 5.2.6 როგორ ახდენს MySQL ოპტიმიზებას LEFT JOIN და RIGHT JOIN.
- USING(column_list) გამოიყენება სვეტების სიის დასადგენად, რომელიც უნდა არსებობდეს ორივე ცხრილში. USING გამონათქვამი, როგორიცაა: A LEFT JOIN B USING (C1,C2,C3,...) სემანტიკურად იდენტურია ON გამოსახულებისა, მაგალითად: A.C1=B.C1 AND A.C2=B.C2 AND A. .C3=B .C3,...
- ორ ცხრილს შორის ბუნებრივი შეერთება განისაზღვრება, როგორც შიდა შეერთების ან LEFT JOIN-ის სემანტიკური ეკვივალენტი USING პუნქტით, რომელიც განსაზღვრავს ორივე ცხრილის ყველა სვეტს.
- INNER JOIN და (მძიმით) არის სემანტიკური ეკვივალენტები. ორივე ასრულებს სრულ შეერთებას გამოყენებულ ცხრილებზე. ცხრილების დაკავშირების გზა ჩვეულებრივ მითითებულია WHERE პუნქტში.
- RIGHT JOIN მუშაობს LEFT JOIN-ის მსგავსად. კოდის პორტაბელურობის შესანარჩუნებლად სხვადასხვა მონაცემთა ბაზებს შორის, რეკომენდირებულია გამოიყენოთ LEFT JOIN ნაცვლად RIGHT JOIN.
- STRAIGHT_JOIN იდენტურია JOIN-ისა, გარდა იმისა, რომ მარცხენა ცხრილი ყოველთვის იკითხება მარჯვენას წინ. ეს გამოთქმა შეიძლება გამოყენებულ იქნას იმ (რამდენიმე) შემთხვევისთვის, როდესაც შეერთების ოპტიმიზატორი ცხრილებს არასწორი თანმიმდევრობით აყენებს.
- MySQL 3.23.12 ვერსიით დაწყებული, შეგიძლიათ მითითება MySQL-ს, რომელი ინდექსი უნდა იყოს გამოყენებული ცხრილიდან ინფორმაციის მიღებისას. ეს ფუნქცია სასარგებლოა, თუ EXPLAIN განცხადება (რომელიც აჩვენებს ინფორმაციას SELECT მოთხოვნის სტრუქტურისა და რიგის შესახებ) მიუთითებს, რომ MySQL არასწორ ინდექსს იყენებს. USE INDEX-ში (key_list) ინდექსის მნიშვნელობის მითითებით, შეგიძლიათ აიძულოთ MySQL გამოიყენოს მითითებული ინდექსებიდან მხოლოდ ერთი ჩანაწერის მოსაძებნად. ალტერნატიული განცხადება, IGNORE INDEX (key_list), ხელს უშლის MySQL-ს ამ კონკრეტული ინდექსის გამოყენებაში. გამოთქმები USE/IGNORE KEY არის USE/IGNORE INDEX-ის სინონიმები.
რამდენიმე მაგალითი:
Mysql> SELECT * FROM table1,table2 WHERE table1.id=table2.id; mysql> SELECT * FROM table1 LEFT JOIN table2 ON table1.id=table2.id; mysql> SELECT * FROM table1 LEFT JOIN table2 USING (id); mysql> SELECT * FROM table1 LEFT Join table2 ON table1.id=table2.id LEFT JOIN table3 ON table2.id=table3.id; mysql> SELECT * FROM table1 გამოიყენეთ INDEX (key1,key2) WHERE key1=1 AND key2=2 AND key3=3; mysql> SELECT * FROM table1 იგნორირება INDEX (key3) WHERE key1=1 AND key2=2 AND key3=3;
საკმაოდ დიდი ხნის განმავლობაში, ჩემი კარიერის დასაწყისში, როგორც ვებ დეველოპერი, ვმუშაობდი ამ მონაცემთა ბაზასთან, როგორც შემეძლო, მაგრამ ბევრი არაფერი ვიცოდი. მან შეადგინა მარტივი პრიმიტიული შეკითხვები და ზოგჯერ კითხვებს მარყუჟებშიც კი აყენებდა. იმ დროს, სამწუხაროდ, MySQL-ზე სწორ წიგნზე ხელი არ მომიწია და საცდელი და შეცდომით სწავლა მომიწია. ბევრმა სტატიამ ინტერნეტში რატომღაც მაშინვე არ გადმომცა მშვენიერი MySQL შეკითხვა - JOIN.
ამ პუბლიკაციაში ვისაუბრებ JOIN-თან მუშაობის ყველა შესაძლო ვარიანტზე და მეტიც, წარმოგიდგენთ თითოეული ბრძანების მუშაობის პრინციპს - ვიზუალურად.
ცალ-ცალკე უნდა აღინიშნოს პუნქტები 5,6 და 7. სინამდვილეში, ეს მოთხოვნები არ აკავშირებს ორ ცხრილს, არამედ გამორიცხავს სვეტებს ერთი ცხრილიდან, რომლებიც წარმოდგენილია მეორეში. სინამდვილეში, ეს შეიძლება იყოს ძალიან სასარგებლო.
შიდა JOIN 
ერთ-ერთი ყველაზე გავრცელებული მოთხოვნა ძალიან ხშირად ხდება. ეს მოთხოვნა დააბრუნებს ყველა ჩანაწერს მარცხენა ცხრილიდან (ცხრილი A) და ჩანაწერებს (ცხრილი B), მაგრამ დააბრუნებს მხოლოდ შესაბამის სვეტებს.
მოთხოვნის მაგალითი:
კოდის ნახვა SQL
| აირჩიეთ< select_list>FROM Table_A A INNER JOIN Table_B B ON A. გასაღები = B. გასაღები |
დატოვე JOIN 
ეს მოთხოვნა დააბრუნებს ყველა სვეტს მარცხენა ცხრილიდან (ცხრილი A), ისევე როგორც ყველა სვეტი მარჯვენა ცხრილიდან (ცხრილი B), მაგრამ მხოლოდ იმ სვეტებს, რომლებიც ემთხვევა მარცხენა ცხრილის სვეტებს.
მოთხოვნის მაგალითი:
კოდის ნახვა SQL
| აირჩიეთ< select_list>FROM Table_A A LEFT JOIN Table_B B ON A. გასაღები = B. გასაღები |
მარჯვენა JOIN 
წინა მოთხოვნის მსგავსი, მაგრამ დააბრუნებს ყველა სვეტს მარჯვენა ცხრილიდან (ცხრილი B), ისევე როგორც ყველა სვეტი მარცხენა ცხრილიდან (ცხრილი A), რომლებიც ემთხვევა მარჯვენა ცხრილის სვეტებს.
მოთხოვნის მაგალითი:
კოდის ნახვა SQL
| აირჩიეთ< select_list>FROM Table_A RIGHT Join Table_B B ON A. Key = B. Key |
გარე JOIN 
ხშირად ეს მოთხოვნა იწერება როგორც FULL OUTER JOIN ან FULL JOIN, ყველა ვარიაცია ასრულებს ერთ მოქმედებას, კერძოდ, დააბრუნებს ყველა სვეტს ორივე ცხრილიდან, ხოლო შესატყვისი სვეტები გადაფარავს სვეტებს მარცხენა ცხრილიდან.
მოთხოვნის მაგალითი:
კოდის ნახვა SQL
| აირჩიეთ< select_list>FROM Table_A A FULL OUTER JOIN Table_B B ON A. გასაღები = B. გასაღები |
მარცხნივ JOIN-ის გამოკლებით 
ეს მოთხოვნა დააბრუნებს ყველა სვეტს მარცხენა ცხრილიდან (ცხრილი A), რომლებიც არ ემთხვევა მარჯვენა ცხრილის სვეტებს (ცხრილი B).
მოთხოვნის მაგალითი:
კოდის ნახვა SQL
