შეკითხვები Access-ში არის ძირითადი ინსტრუმენტი მონაცემთა ბაზის ცხრილებში მონაცემების შერჩევის, განახლებისა და დამუშავებისთვის. Access, რელაციური მონაცემთა ბაზების კონცეფციის შესაბამისად, იყენებს Structured Query Language (SQL) მოთხოვნების შესასრულებლად. SQL განცხადებების დახმარებით, Access-ში ნებისმიერი მოთხოვნა ხორციელდება.

მოთხოვნის ძირითადი ტიპი არის შერჩეული მოთხოვნა. ამ მოთხოვნის შედეგი არის ახალი ცხრილი, რომელიც არსებობს მოთხოვნის დახურვამდე. ჩანაწერები იქმნება იმ ცხრილების ჩანაწერებთან შეერთებით, რომლებზეც აგებულია მოთხოვნა. ცხრილის ჩანაწერების გაერთიანების მეთოდი მითითებულია მონაცემთა სქემაში მათი ურთიერთობის განსაზღვრისას ან მოთხოვნის შექმნისას. მოთხოვნაში ჩამოყალიბებული შერჩევის პირობები საშუალებას გაძლევთ გაფილტროთ ჩანაწერები, რომლებიც ქმნიან ცხრილების შეერთების შედეგს.

Access-ში შეიძლება შეიქმნას რამდენიმე ტიპის მოთხოვნა:

• ნიმუშის მოთხოვნა- ირჩევს მონაცემებს ერთი ცხრილიდან ან მოთხოვნიდან ან რამდენიმე დაკავშირებული ცხრილიდან და სხვა მოთხოვნებიდან. შედეგი არის ცხრილი, რომელიც არსებობს მოთხოვნის დახურვამდე. შედეგების ცხრილის ჩანაწერების ფორმირება ხდება მითითებული შერჩევის პირობების შესაბამისად და რამდენიმე ცხრილის გამოყენებისას მათი ჩანაწერების გაერთიანებით;
• შეკითხვა ცხრილის შესაქმნელად- ირჩევს მონაცემებს დაკავშირებული ცხრილებიდან და სხვა მოთხოვნებიდან, მაგრამ, შერჩეული მოთხოვნისაგან განსხვავებით, ინახავს შედეგს ახალ მუდმივ ცხრილში;
• ითხოვს განახლებას, დამატებას, წაშლას- არის სამოქმედო მოთხოვნები, რის შედეგადაც იცვლება ცხრილების მონაცემები.

მოთხოვნები წვდომის დიზაინის რეჟიმში შეიცავს მონაცემთა სქემას, რომელიც აჩვენებს გამოყენებულ ცხრილებს და შეკითხვის ფორმას, რომელშიც აგებულია შეკითხვის ცხრილის სტრუქტურა და ჩანაწერების შერჩევის პირობები (ნახ. 4.1).

შეკითხვის გამოყენებით შეგიძლიათ განახორციელოთ მონაცემთა დამუშავების შემდეგი ტიპები:

• მომხმარებლის მიერ შერჩეული ცხრილის ველების ჩართვა შეკითხვის ცხრილში;
• განახორციელოს გამოთვლები თითოეულ მიღებულ ჩანაწერში;
• შეარჩიეთ ჩანაწერები, რომლებიც აკმაყოფილებს შერჩევის კრიტერიუმებს;
• ახალი ვირტუალური ცხრილის ჩამოყალიბება დაკავშირებული ცხრილების ჩანაწერების გაერთიანების საფუძველზე;
• ჯგუფური ჩანაწერები, რომლებსაც აქვთ იგივე მნიშვნელობა ერთ ან მეტ ველში, ერთდროულად ასრულებენ სტატისტიკურ ფუნქციებს ჯგუფის სხვა ველებზე და შედეგში აერთიანებენ თითო ჩანაწერს თითოეული ჯგუფისთვის;
• მონაცემთა ბაზის ახალი ცხრილის შექმნა არსებული ცხრილების მონაცემების გამოყენებით;
• ველების განახლება ჩანაწერების არჩეულ ქვეჯგუფში;
• მონაცემთა ბაზის ცხრილიდან არჩეული ჩანაწერების ქვეჯგუფის წაშლა;
• დაამატეთ ჩანაწერების არჩეული ქვეჯგუფი სხვა ცხრილში.

შეკითხვები Access-ში ემსახურება როგორც ჩანაწერის წყაროს სხვა მოთხოვნებისთვის, ფორმებისთვის, ანგარიშებისთვის. შეკითხვის გამოყენებით, შეგიძლიათ შეაგროვოთ სრული ინფორმაცია, რომ ჩამოაყალიბოთ გარკვეული საგნობრივი დოკუმენტი რამდენიმე ცხრილიდან, შემდეგ გამოიყენოთ იგი ფორმის შესაქმნელად - ამ დოკუმენტის ელექტრონული წარმოდგენა. თუ ფორმა ან მოხსენება შექმნილია ოსტატის მიერ რამდენიმე ურთიერთდაკავშირებულ ცხრილზე დაყრდნობით, მაშინ მათთვის მოთხოვნა ავტომატურად იქმნება, როგორც ჩანაწერის წყარო.
გამოსასწორებლად, ნახეთ ვიდეო გაკვეთილი.

მოთხოვნები იწერება გაქცევის ციტატების გარეშე, რადგან MySQL, MS SQLდა PostGreeისინი განსხვავებულები არიან.

SQL შეკითხვა: ცხრილიდან მითითებული (საჭირო) ველების მიღება

SELECT id, country_title, count_people FROM table_name

ჩვენ ვიღებთ ჩანაწერების ჩამონათვალს: ყველა ქვეყანა და მათი მოსახლეობა. საჭირო ველების სახელები გამოყოფილია მძიმეებით.

SELECT * FROM table_name

* აღნიშნავს ყველა ველს. ანუ იქნება ჩვენებები ყველაფერიმონაცემთა ველები.

SQL შეკითხვა: აჩვენებს ჩანაწერებს ცხრილიდან დუბლიკატების გამოკლებით

აირჩიეთ DISTINCT country_title FROM table_name

ჩვენ ვიღებთ ჩანაწერების ჩამონათვალს: ქვეყნებს, სადაც ჩვენი მომხმარებლები არიან განთავსებული. შეიძლება იყოს ბევრი მომხმარებელი ერთი ქვეყნიდან. ამ შემთხვევაში, ეს თქვენი მოთხოვნაა.

SQL შეკითხვა: ცხრილიდან ჩანაწერების ჩვენება მოცემული მდგომარეობის მიხედვით

აირჩიეთ ID, ქვეყნის_სათაური, ქალაქის_სათაური FROM table_name WHERE count_people>100000000

ჩვენ ვიღებთ ჩანაწერების ჩამონათვალს: ქვეყნები, სადაც ხალხის რაოდენობა 100 000 000-ზე მეტია.

SQL შეკითხვა: ცხრილიდან ჩანაწერების ჩვენება შეკვეთით

აირჩიეთ ID, city_title FROM table_name ORDER BY city_title

ჩვენ ვიღებთ ჩანაწერების ჩამონათვალს: ქალაქები ანბანური თანმიმდევრობით. A დასაწყისში, Z ბოლოს.

აირჩიეთ ID, city_title FROM table_name ORDER BY city_title DESC

ჩვენ ვიღებთ ჩანაწერების ჩამონათვალს: ქალაქები საპირისპირო ( DESC) კარგად არის. დასაწყისში მე, ბოლოს ა.

SQL შეკითხვა: ჩანაწერების რაოდენობის დათვლა

აირჩიეთ COUNT(*) ცხრილის_სახელიდან

ვიღებთ ცხრილში ჩანაწერების რაოდენობას (რაოდენობას). ამ შემთხვევაში, არ არის ჩანაწერების სია.

SQL მოთხოვნა: ჩანაწერების სასურველი დიაპაზონის ჩვენება

SELECT * FROM table_name LIMIT 2, 3

ცხრილიდან ვიღებთ 2 (მეორე) და 3 (მესამე) ჩანაწერს. მოთხოვნა სასარგებლოა ვებ გვერდებზე ნავიგაციის შექმნისას.

SQL მოთხოვნები პირობებით

ცხრილიდან ჩანაწერების ჩვენება მოცემული პირობის მიხედვით ლოგიკური ოპერატორების გამოყენებით.

SQL მოთხოვნა: AND კონსტრუქცია (AND)

აირჩიეთ ID, city_title FROM table_name WHERE country="Russia" AND oil=1

ჩანაწერების სიის მიღება: ქალაქები რუსეთიდან დააქვს წვდომა ზეთზე. როდის გამოიყენება ოპერატორი? და, მაშინ ორივე პირობა უნდა ემთხვეოდეს.

SQL მოთხოვნა: OR კონსტრუქცია (OR)

აირჩიეთ ID, city_title FROM table_name WHERE country="Russia" OR country="USA"

მიიღეთ ჩანაწერების სია: ყველა ქალაქი რუსეთიდან ანᲐᲨᲨ. როდის გამოიყენება ოპერატორი? ან, მაშინ მინიმუმ ერთი პირობა უნდა შეესაბამებოდეს.

SQL შეკითხვა: AND NOT Build (და არა)

აირჩიეთ id, user_login FROM table_name WHERE country="Russia" და არ დაითვალოთ_კომენტარები<7

მიიღეთ ჩანაწერების სია: ყველა მომხმარებელი რუსეთიდან დაგააკეთა ᲐᲠᲐᲜᲐᲙᲚᲔᲑ 7 კომენტარი.

SQL მოთხოვნა: IN კონსტრუქცია (B)

SELECT ID, user_login FROM table_name WHERE country IN ("რუსეთი", "ბულგარეთი", "ჩინეთი")

ჩვენ ვიღებთ ჩანაწერების ჩამონათვალს: ყველა მომხმარებელი, რომელიც ცხოვრობს ( IN) (რუსეთი, ან ბულგარეთი, ან ჩინეთი)

SQL მოთხოვნა: NOT IN კონსტრუქცია (NOT IN)

აირჩიეთ ID, user_login FROM table_name WHERE country NOT IN ("Russia", "China")

ჩვენ ვიღებთ ჩანაწერების ჩამონათვალს: ყველა მომხმარებელი, რომელიც არ ცხოვრობს ( არ არის) (რუსეთი ან ჩინეთი).

SQL მოთხოვნა: არის NULL კონსტრუქცია (ცარიელი ან არა ცარიელი მნიშვნელობები)

აირჩიეთ ID, user_login FROM table_name WHERE status IS NULL

ჩვენ ვიღებთ ჩანაწერების ჩამონათვალს: ყველა მომხმარებელი, სადაც სტატუსი არ არის განსაზღვრული. NULL ცალკე თემაა და ამიტომ ცალკე მოწმდება.

აირჩიეთ ID, user_login FROM table_name-დან, სადაც მდგომარეობა არ არის NULL

ჩვენ ვიღებთ ჩანაწერების ჩამონათვალს: ყველა მომხმარებელი, სადაც სტატუსი არის განსაზღვრული (NOT ZERO).

SQL შეკითხვა: LIKE კონსტრუქცია

აირჩიეთ id, user_login FROM table_name WHERE გვარი LIKE "John%"

ჩვენ ვიღებთ ჩანაწერების ჩამონათვალს: მომხმარებლები, რომელთა გვარი იწყება კომბინაციით "ივანე". % ნიშანი ნიშნავს ნებისმიერი სიმბოლოს ნებისმიერ რაოდენობას. % ნიშნის საპოვნელად, თქვენ უნდა გამოიყენოთ გაქცევა „Ivan\%“.

SQL შეკითხვა: კონსტრუქციას შორის

აირჩიეთ ID, user_login FROM table_name WHERE ხელფასი 25000-დან 50000-მდე

ჩვენ ვიღებთ ჩანაწერების ჩამონათვალს: მომხმარებლები, რომლებიც იღებენ ხელფასს 25000-დან 50000-მდე.

ძალიან ბევრი ლოგიკური ოპერატორია, ამიტომ დეტალურად შეისწავლეთ SQL სერვერის დოკუმენტაცია.

რთული SQL მოთხოვნები

SQL შეკითხვა: შეუერთდით მრავალ მოთხოვნას

(SELECT id, user_login FROM table_name1) UNION (SELECT id, user_login FROM table_name2)

ჩვენ ვიღებთ ჩანაწერების ჩამონათვალს: მომხმარებლებს, რომლებიც დარეგისტრირებულნი არიან სისტემაში, ასევე იმ მომხმარებლებს, რომლებიც დარეგისტრირებულნი არიან ფორუმზე ცალკე. UNION ოპერატორს შეუძლია დააკავშიროს მრავალი მოთხოვნა. UNION მოქმედებს როგორც SELECT DISTINCT, ანუ ის უგულებელყოფს დუბლიკატულ მნიშვნელობებს. აბსოლუტურად ყველა ჩანაწერის მისაღებად, თქვენ უნდა გამოიყენოთ UNION ALL ოპერატორი.

SQL მოთხოვნა: ველის მნიშვნელობების გაანგარიშება MAX, MIN, SUM, AVG, COUNT

გამომავალი ერთი, მრიცხველის მაქსიმალური მნიშვნელობა ცხრილში:

SELECT MAX(counter) FROM table_name

გამომავალი ერთი, მრიცხველის მინიმალური მნიშვნელობა ცხრილში:

SELECT MIN(counter) FROM table_name

ყველა მრიცხველის მნიშვნელობების ჯამის ჩვენება ცხრილში:

SELECT SUM(counter) FROM table_name

მრიცხველის საშუალო მნიშვნელობის ჩვენება ცხრილში:

აირჩიეთ AVG(counter) FROM table_name

მრიცხველების რაოდენობის ჩვენება ცხრილში:

SELECT COUNT(counter) FROM table_name

No1 მაღაზიაში მრიცხველების რაოდენობის დასკვნა ცხრილში:

SELECT COUNT(counter) FROM table_name WHERE office="Workshop #1"

ეს არის ყველაზე პოპულარული ბრძანებები. რეკომენდირებულია, სადაც ეს შესაძლებელია, გამოიყენოს ამ ტიპის SQL მოთხოვნები გაანგარიშებისთვის, რადგან არცერთი პროგრამირების გარემო არ შეიძლება შედარდეს მონაცემთა დამუშავების სიჩქარით, ვიდრე თავად SQL სერვერი საკუთარი მონაცემების დამუშავებისას.

SQL შეკითხვა: ჩანაწერების დაჯგუფება

აირჩიეთ კონტინენტი, SUM(country_area) FROM ქვეყნებიდან ჯგუფი კონტინენტის მიხედვით

ჩვენ ვიღებთ ჩანაწერების ჩამონათვალს: კონტინენტის სახელწოდებით და მათი ყველა ქვეყნის ტერიტორიების ჯამით. ანუ, თუ არსებობს ქვეყნების დირექტორია, სადაც თითოეულ ქვეყანას აქვს თავისი ტერიტორია ჩაწერილი, მაშინ GROUP BY კონსტრუქციის გამოყენებით, შეგიძლიათ გაიგოთ თითოეული კონტინენტის ზომა (კონტინენტების მიხედვით დაჯგუფების საფუძველზე).

SQL მოთხოვნა: მრავალი ცხრილის გამოყენება ალიასის (ალიასის) საშუალებით

SELECT o.order_no, o.amount_paid, c.company FROM შეკვეთებიდან AS o, კლიენტი როგორც WHERE o.custno=c.custno AND c.city="Tyumen"

ჩვენ ვიღებთ ჩანაწერების ჩამონათვალს: შეკვეთები მყიდველებისგან, რომლებიც ცხოვრობენ მხოლოდ ტიუმენში.

ფაქტობრივად, ამ ტიპის სათანადოდ შემუშავებული მონაცემთა ბაზის შემთხვევაში მოთხოვნა ყველაზე ხშირია, ამიტომ MySQL-მა შემოიღო სპეციალური ოპერატორი, რომელიც ბევრჯერ უფრო სწრაფად მუშაობს, ვიდრე ზემოთ დაწერილი კოდი.

აირჩიეთ o.order_no, o.amount_paid, z.company შეკვეთებიდან AS o LEFT JOIN მომხმარებელს AS z ON (z.custno=o.custno)

ჩადგმული ქვემოკითხვები

SELECT * FROM table_name WHERE ხელფასი=(SELECT MAX(ხელფასი) თანამშრომლისგან)

ვიღებთ ერთ ჩანაწერს: ინფორმაციას მაქსიმალური ხელფასის მქონე მომხმარებლის შესახებ.

ყურადღება!ჩადგმული ქვემოთხოვნები არის ერთ-ერთი შეფერხება SQL სერვერებში. მოქნილობასთან და სიმძლავრესთან ერთად, ისინი ასევე მნიშვნელოვნად ზრდის სერვერის დატვირთვას. რაც იწვევს კატასტროფულ შენელებას სხვა მომხმარებლებისთვის. ძალიან ხშირია რეკურსიული ზარების შემთხვევები ჩადგმული მოთხოვნებით. ამიტომ, კატეგორიულად გირჩევთ, არ გამოიყენოთ წყობილი მოთხოვნები, არამედ დაშალოთ ისინი პატარაებად. ან გამოიყენეთ ზემოთ აღწერილი LEFT JOIN კომბინაცია. ამ ტიპის მოთხოვნების გარდა, ისინი უსაფრთხოების დარღვევის გაზრდილი აქცენტია. თუ გადაწყვეტთ გამოიყენოთ ჩადგმული ქვემოთხოვნები, მაშინ თქვენ უნდა დააპროექტოთ ისინი ძალიან ფრთხილად და გააკეთოთ საწყისი გაშვებები მონაცემთა ბაზის ასლებზე (სატესტო მონაცემთა ბაზები).

SQL მოთხოვნები ცვლის მონაცემებს

SQL მოთხოვნა: INSERT

ინსტრუქცია ჩასმასაშუალებას გაძლევთ ჩაწეროთ ჩანაწერები ცხრილში. მარტივი სიტყვებით, შექმენით ხაზი მონაცემებით ცხრილში.

ვარიანტი ნომერი 1. ხშირად გამოყენებული ინსტრუქცია:

INSERT INTO table_name (id, user_login) VALUES (1, "ivanov"), (2, "petrov")

Მაგიდაზე " ცხრილის_სახელი» ჩასვამს 2 (ორ) მომხმარებელს ერთდროულად.

ვარიანტი ნომერი 2. უფრო მოსახერხებელია სტილის გამოყენება:

INSERT table_name SET id=1, user_login="ivanov"; INSERT table_name SET id=2, user_login="petrov";

ამას აქვს თავისი დადებითი და უარყოფითი მხარეები.

ძირითადი ნაკლოვანებები:

• ბევრი მცირე SQL მოთხოვნა ოდნავ უფრო ნელია, ვიდრე ერთი დიდი SQL მოთხოვნა, მაგრამ სხვა მოთხოვნები იქნება რიგში მომსახურებისთვის. ანუ, თუ დიდი SQL მოთხოვნა გადის 30 წუთის განმავლობაში, მაშინ მთელი ამ დროის განმავლობაში დანარჩენი მოთხოვნები ბამბუკის მოწევას და დაელოდება თავის რიგს.
• მოთხოვნა უფრო მასიურია, ვიდრე წინა ვერსია.

ძირითადი უპირატესობები:

• მცირე SQL მოთხოვნების დროს, სხვა SQL მოთხოვნები არ არის დაბლოკილი.
• კითხვის სიმარტივე.
• მოქნილობა. ამ პარამეტრში, თქვენ არ შეგიძლიათ დაიცვას სტრუქტურა, მაგრამ დაამატეთ მხოლოდ საჭირო მონაცემები.
• ამ გზით არქივების შექმნისას, თქვენ შეგიძლიათ მარტივად დააკოპიროთ ერთი ხაზი და გაუშვათ იგი ბრძანების ხაზის (კონსოლის) მეშვეობით, რითაც არ აღადგენთ მთელ არქივს.
• წერის სტილი ჰგავს UPDATE განცხადებას, რომლის დამახსოვრება უფრო ადვილია.

SQL მოთხოვნა: განახლება

განაახლეთ ცხრილის_სახელი SET user_login="ivanov", user_surname="Ivanov" WHERE id=1

Მაგიდაზე " ცხრილის_სახელი» ჩანაწერში ნომრით id=1, user_login და user_surname ველების მნიშვნელობები შეიცვლება მითითებულ მნიშვნელობებში.

SQL მოთხოვნა: DELETE

წაშლა ცხრილის_სახელიდან WHERE id=3

ჩანაწერი ID ნომრით 3 წაიშლება ცხრილის_სახელის ცხრილში.

1. ყველა ველის სახელები რეკომენდირებულია დაიწეროს პატარა ასოებით და, საჭიროების შემთხვევაში, გამოყოფილი იყოს იძულებითი სივრცით "_" სხვადასხვა პროგრამირების ენებთან თავსებადობისთვის, როგორიცაა Delphi, Perl, Python და Ruby.
2. SQL ბრძანებები იწერება დიდი ასოებით წაკითხვისთვის. ყოველთვის დაიმახსოვრე, რომ სხვა ადამიანებს შეუძლიათ წაიკითხონ კოდი თქვენს შემდეგ, მაგრამ, სავარაუდოდ, თქვენ თვითონ N დროის შემდეგ.
3. დაასახელეთ ველები ჯერ არსებითი სახელით და შემდეგ მოქმედებით. მაგალითად: city_status, user_login, user_name.
4. შეეცადეთ თავიდან აიცილოთ სარეზერვო სიტყვები სხვადასხვა ენაზე, რამაც შეიძლება გამოიწვიოს პრობლემები SQL, PHP ან Perl-ში, როგორიცაა (სახელი, რაოდენობა, ბმული). მაგალითად: ბმული შეიძლება გამოყენებულ იქნას MS SQL-ში, მაგრამ დაცულია MySQL-ში.

ეს მასალა არის მოკლე მინიშნება ყოველდღიური მუშაობისთვის და არ წარმოადგენს სუპერ მეგა ავტორიტეტულ წყაროს, რომელიც არის კონკრეტული მონაცემთა ბაზის SQL მოთხოვნების პირველადი წყარო.

თითოეული ჩვენგანი რეგულარულად ხვდება და იყენებს სხვადასხვა მონაცემთა ბაზას. როდესაც ჩვენ ვირჩევთ ელექტრონული ფოსტის მისამართს, ჩვენ ვმუშაობთ მონაცემთა ბაზასთან. მონაცემთა ბაზები იყენებენ საძიებო სერვისებს, ბანკებს კლიენტების მონაცემების შესანახად და ა.შ.

მაგრამ, მიუხედავად მონაცემთა ბაზების მუდმივი გამოყენებისა, პროგრამული სისტემების მრავალი დეველოპერისთვისაც კი არსებობს მრავალი „თეთრი ლაქა“ ერთი და იგივე ტერმინების განსხვავებული ინტერპრეტაციების გამო. ჩვენ მივცემთ მონაცემთა ბაზის ძირითადი ტერმინების მოკლე განმარტებას SQL ენის განხილვამდე. Ისე.

Მონაცემთა ბაზა - ფაილი ან ფაილების ნაკრები შეკვეთილი მონაცემთა სტრუქტურებისა და მათი ურთიერთობის შესანახად. ძალიან ხშირად, მონაცემთა ბაზას უწოდებენ მართვის სისტემას - ეს არის მხოლოდ ინფორმაციის საცავი გარკვეული ფორმატით და შეუძლია მუშაობა სხვადასხვა DBMS-თან.

მაგიდა - წარმოვიდგინოთ საქაღალდე, რომელიც ინახავს დოკუმენტებს, რომლებიც დაჯგუფებულია გარკვეული ატრიბუტის მიხედვით, მაგალითად, ბოლო თვის შეკვეთების სიას. ეს არის ცხრილი კომპიუტერში ცალკე ცხრილს აქვს თავისი უნიკალური სახელი.

Მონაცემთა ტიპი - ინფორმაციის ტიპი, რომელიც დასაშვებია შესანახად კონკრეტულ სვეტში ან მწკრივში. ეს შეიძლება იყოს ციფრები ან ტექსტი გარკვეული ფორმატის.

სვეტი და მწკრივი- ჩვენ ყველანი ვიმუშავეთ ცხრილებთან, რომლებსაც ასევე აქვთ რიგები და სვეტები. ნებისმიერი რელაციური მონაცემთა ბაზა იგივენაირად მუშაობს ცხრილებთან. რიგებს ზოგჯერ ჩანაწერებს უწოდებენ.

მთავარი გასაღები- ცხრილის თითოეულ რიგს შეიძლება ჰქონდეს ერთი ან მეტი სვეტი მისი ცალსახად იდენტიფიცირებისთვის. პირველადი გასაღების გარეშე, ძალიან რთულია სასურველი რიგების განახლება, შეცვლა და წაშლა.

რა არის SQL?

SQL(ინგლისური - სტრუქტურირებული შეკითხვის ენა) შეიქმნა მხოლოდ მონაცემთა ბაზებთან მუშაობისთვის და ამჟამად არის სტანდარტი ყველა პოპულარული DBMS-ისთვის. ენის სინტაქსი შედგება მცირე რაოდენობის ოპერატორებისგან და ადვილად შესასწავლია. მაგრამ, მიუხედავად გარეგანი სიმარტივისა, ის საშუალებას გაძლევთ შექმნათ sql მოთხოვნები რთული ოპერაციებისთვის ნებისმიერი ზომის მონაცემთა ბაზით.

1992 წლიდან არსებობს საყოველთაოდ მიღებული სტანდარტი სახელწოდებით ANSI SQL. ის განსაზღვრავს ოპერატორების ძირითად სინტაქსს და ფუნქციებს და მხარს უჭერს DBMS ბაზრის ყველა ლიდერს, როგორიცაა ORACLE. შეუძლებელია ენის ყველა შესაძლებლობის დაფარვა ერთ პატარა სტატიაში, ამიტომ მოკლედ განვიხილავთ მხოლოდ ძირითად SQL შეკითხვებს. მაგალითები ნათლად აჩვენებს ენის სიმარტივეს და შესაძლებლობებს:

• მონაცემთა ბაზებისა და ცხრილების შექმნა;
• მონაცემთა შერჩევა;
• ჩანაწერების დამატება;
• ინფორმაციის შეცვლა და წაშლა.

SQL მონაცემთა ტიპები

მონაცემთა ბაზის ცხრილის ყველა სვეტი ინახავს იმავე ტიპის მონაცემებს. მონაცემთა ტიპები SQL-ში იგივეა, რაც სხვა პროგრამირების ენებში.

ცხრილებისა და მონაცემთა ბაზების შექმნა

SQL-ში ახალი მონაცემთა ბაზების, ცხრილების და სხვა მოთხოვნების შესაქმნელად ორი გზა არსებობს:

• DBMS კონსოლის საშუალებით
• მონაცემთა ბაზის სერვერთან დართული ინტერაქტიული ადმინისტრირების ინსტრუმენტების გამოყენებით.

ოპერატორის მიერ იქმნება ახალი მონაცემთა ბაზა მონაცემთა ბაზის შექმნა<наименование базы данных>; . როგორც ხედავთ, სინტაქსი მარტივი და ლაკონურია.

ჩვენ ვქმნით ცხრილებს მონაცემთა ბაზაში CREATE TABLE განაცხადის გამოყენებით შემდეგი პარამეტრებით:

• მაგიდის სახელი
• სვეტების სახელები და მონაცემთა ტიპები

მაგალითად, მოდით შევქმნათ საქონლის ცხრილი შემდეგი სვეტებით:

ჩვენ ვქმნით ცხრილს:

შექმენით მაგიდა საქონელი

(commodity_id CHAR(15) NOT NULL,

vendor_id CHAR(15) NOT NULL,

commodity_name CHAR(254) NULL,

საქონლის_ფასი DECIMAL(8,2) NULL,

commodity_desc VARCHAR(1000) NULL);

ცხრილს აქვს ხუთი სვეტი. სახელის შემდეგ მოდის მონაცემთა ტიპი, სვეტები გამოყოფილია მძიმეებით. სვეტის მნიშვნელობა შეიძლება იყოს ცარიელი (NULL) ან უნდა იყოს შევსებული (NOT NULL) და ეს განისაზღვრება ცხრილის შექმნისას.

მონაცემების შერჩევა ცხრილიდან

მონაცემთა შერჩევის ოპერატორი არის ყველაზე ხშირად გამოყენებული SQL მოთხოვნა. ინფორმაციის მისაღებად უნდა მიუთითოთ რა გვინდა ავირჩიოთ ასეთი ცხრილიდან. ჯერ მარტივი მაგალითი:

SELECT commodity_name FROM Commodity-დან

SELECT განცხადების შემდეგ, ჩვენ ვაზუსტებთ სვეტის სახელს ინფორმაციის მისაღებად და FROM განსაზღვრავს ცხრილს.

შეკითხვის შესრულების შედეგი იქნება ცხრილის ყველა სტრიქონი Commodity_name მნიშვნელობებით იმ თანმიმდევრობით, რომლითაც ისინი შევიდა მონაცემთა ბაზაში, ე.ი. ყოველგვარი დახარისხების გარეშე. შედეგის შესაკვეთად გამოიყენება დამატებითი ORDER BY პუნქტი.

მრავალ ველზე შეკითხვისთვის, ჩამოთვალეთ ისინი გამოყოფილი მძიმეებით, როგორც შემდეგ მაგალითში:

SELECT commodity_id, commodity_name, commodity_price FROM Commodity

შეკითხვის შედეგად შესაძლებელია მწკრივის ყველა სვეტის მნიშვნელობის მიღება. ამისათვის გამოიყენება "*" ნიშანი:

აირჩიეთ * საქონლისგან

• დამატებით SELECT მხარს უჭერს:
• მონაცემთა დახარისხება (ORDER BY განცხადების მიხედვით)
• აირჩიეთ პირობების მიხედვით (WHERE)
• დაჯგუფების ვადა (GROUP BY)

ხაზის დამატება

ცხრილის მწკრივის დასამატებლად გამოიყენება SQL მოთხოვნები INSERT განაცხადით. დამატება შეიძლება გაკეთდეს სამი გზით:

• დაამატეთ ახალი მთელი ხაზი;
• სტრიქონის ნაწილი;
• შეკითხვის შედეგები.

სრული მწკრივის დასამატებლად, თქვენ უნდა მიუთითოთ ცხრილის სახელი და ახალი მწკრივის სვეტების (ველების) მნიშვნელობები. აი მაგალითი:

ჩადეთ საქონლის ღირებულებებში ("106", "50", "კოკა-კოლა", "1.68", "არა ალკოჰოლი ,)

მაგალითი ამატებს ახალ პროდუქტს ცხრილში. ღირებულებები მითითებულია VALUES-ის შემდეგ თითოეული სვეტისთვის. თუ არ არის შესაბამისი მნიშვნელობა სვეტისთვის, მაშინ NULL უნდა იყოს მითითებული. სვეტები შევსებულია მნიშვნელობებით ცხრილის შექმნისას მითითებული თანმიმდევრობით.

თუ თქვენ დაამატებთ მწკრივის მხოლოდ ნაწილს, მკაფიოდ უნდა მიუთითოთ სვეტების სახელები, როგორც მაგალითში:

ჩასმა საქონელში (საქონლის_ID, გამყიდველის_იდენტიფიკატორი, საქონლის_სახელი)

VALUES("106", "50", "კოკა კოლა")

ჩვენ შევიყვანეთ მხოლოდ პროდუქტის იდენტიფიკატორები, მიმწოდებელი და მისი სახელწოდება, ხოლო დანარჩენი ველები ცარიელი დავტოვეთ.

შეკითხვის შედეგების დამატება

INSERT ძირითადად გამოიყენება რიგების დასამატებლად, მაგრამ ასევე შეიძლება გამოყენებულ იქნას SELECT განცხადების შედეგების დასამატებლად.

შეცვალეთ მონაცემები

მონაცემთა ბაზის ცხრილის ველებში ინფორმაციის შესაცვლელად, თქვენ უნდა გამოიყენოთ განცხადება UPDATE. ოპერატორის გამოყენება შესაძლებელია ორი გზით:

• ცხრილის ყველა სტრიქონი განახლებულია.
• მხოლოდ გარკვეული ხაზისთვის.

UPDATE შედგება სამი ძირითადი ელემენტისგან:

• ცხრილი, რომელშიც აუცილებელია ცვლილებების შეტანა;
• ველების სახელები და მათი ახალი მნიშვნელობები;
• შესაცვლელი რიგების არჩევის პირობები.

განვიხილოთ მაგალითი. ვთქვათ ID=106 პროდუქტის ფასი შეიცვალა, ამიტომ ეს მწკრივი განახლებას საჭიროებს. ჩვენ ვწერთ შემდეგ განცხადებას:

განაახლეთ საქონლის ნაკრები commodity_price = "3.2" WHERE commodity_id = "106"

ჩვენ დავაზუსტეთ ცხრილის სახელი, ჩვენს შემთხვევაში Commodity, სადაც განხორციელდება განახლება, შემდეგ SET-ის შემდეგ - სვეტის ახალი მნიშვნელობა და ვიპოვეთ სასურველი ჩანაწერი WHERE-ში სასურველი ID მნიშვნელობის მითითებით.

მრავალი სვეტის შესაცვლელად, მიუთითეთ რამდენიმე სვეტი-მნიშვნელობის წყვილი, რომლებიც გამოყოფილია მძიმეებით SET განცხადების შემდეგ. მოდით შევხედოთ მაგალითს, რომელშიც განახლებულია პროდუქტის სახელი და ფასი:

განაახლეთ საქონლის ნაკრები commodity_name='Fanta', commodity_price = "3.2" WHERE commodity_id = "106"

სვეტში ინფორმაციის წასაშლელად, შეგიძლიათ დააყენოთ NULL, თუ ცხრილის სტრუქტურა ამის საშუალებას იძლევა. უნდა გვახსოვდეს, რომ NULL არის ზუსტად "არა" მნიშვნელობა და არა ნული ტექსტის ან რიცხვის სახით. პროდუქტის აღწერილობის წაშლა:

განაახლეთ საქონლის ნაკრები commodity_desc = NULL WHERE commodity_id = "106"

რიგების ამოღება

SQL მოთხოვნები ცხრილის რიგების წასაშლელად შესრულებულია DELETE განაცხადით. გამოყენების ორი შემთხვევაა:

• ცხრილის გარკვეული რიგები წაშლილია;
• ცხრილის ყველა სტრიქონი წაშლილია.

ცხრილიდან ერთი მწკრივის წაშლის მაგალითი:

DELETE FROM Commodity WHERE commodity_id = "106"

DELETE FROM-ის შემდეგ ვაზუსტებთ ცხრილის სახელს, რომელშიც სტრიქონები წაიშლება. WHERE პუნქტი შეიცავს პირობას, რომლითაც სტრიქონები შეირჩევა წასაშლელად. მაგალითში ჩვენ ვშლით პროდუქტის ხაზს ID=106-ით. WHERE-ის დაზუსტება ძალიან მნიშვნელოვანია. ამ განცხადების გამოტოვება წაშლის ცხრილის ყველა მწკრივს. ეს ასევე ეხება ველების მნიშვნელობის შეცვლას.

DELETE განცხადება არ აკონკრეტებს სვეტების სახელებს ან მეტანიშნებს. ის მთლიანად შლის სტრიქონებს, მაგრამ არ შეუძლია ერთი სვეტის ამოღება.

SQL-ის გამოყენება Microsoft Access-ში

ჩვეულებრივ გამოიყენება ინტერაქტიულად ცხრილების, მონაცემთა ბაზების შესაქმნელად, მონაცემთა მართვის, შესაცვლელად, ანალიზისთვის და SQL Access მოთხოვნების განსახორციელებლად მოსახერხებელი ინტერაქტიული შეკითხვის დიზაინერის საშუალებით (Query Designer), რომლის გამოყენებითაც შეგიძლიათ შექმნათ და დაუყოვნებლივ შეასრულოთ ნებისმიერი სირთულის SQL განცხადებები.

სერვერზე წვდომის რეჟიმი ასევე მხარდაჭერილია, რომელშიც Access DBMS შეიძლება გამოყენებულ იქნას როგორც SQL მოთხოვნების გენერატორი ODBC მონაცემთა ნებისმიერი წყაროსთვის. ეს შესაძლებლობა საშუალებას აძლევს Access აპლიკაციებს ნებისმიერ ფორმატთან ურთიერთობისას.

SQL გაფართოებები

ვინაიდან SQL მოთხოვნებს არ გააჩნიათ პროცედურული პროგრამირების ენების ყველა მახასიათებელი, როგორიცაა მარყუჟები, ფილიალები და ა.შ., DBMS მომწოდებლები ავითარებენ SQL-ის საკუთარ ვერსიას გაფართოებული ფუნქციებით. პირველ რიგში, ეს არის შენახული პროცედურების მხარდაჭერა და პროცედურული ენების სტანდარტული ოპერატორები.

ენის ყველაზე გავრცელებული დიალექტები:

• Oracle მონაცემთა ბაზა - PL/SQL
• Interbase, Firebird - PSQL
• Microsoft SQL Server - Transact-SQL
• PostgreSQL - PL/pgSQL.

SQL ინტერნეტში

MySQL DBMS განაწილებულია GNU ზოგადი საჯარო ლიცენზიით. არსებობს კომერციული ლიცენზია საბაჟო მოდულების შემუშავების შესაძლებლობით. როგორც განუყოფელი ნაწილი, ის შედის ინტერნეტ სერვერების ყველაზე პოპულარულ ასამბლეებში, როგორიცაა XAMPP, WAMP და LAMP და არის ყველაზე პოპულარული DBMS ინტერნეტში აპლიკაციების შემუშავებისთვის.

ის შემუშავებულია Sun Microsystems-ის მიერ და ამჟამად იმართება Oracle Corporation-ის მიერ. მხარს უჭერს მონაცემთა ბაზებს 64 ტერაბაიტამდე, SQL:2003 სინტაქსის სტანდარტს, მონაცემთა ბაზების რეპლიკაციას და ღრუბლოვან სერვისებს.

ცხრილის გამონათქვამებისახელწოდებით subqueries, რომლებიც გამოიყენება იქ, სადაც მოსალოდნელია ცხრილი. ცხრილის გამონათქვამების ორი ტიპი არსებობს:

მიღებული ცხრილები;

განზოგადებული ცხრილის გამონათქვამები.

ცხრილის გამონათქვამების ეს ორი ფორმა განხილულია შემდეგ ქვეთავებში.

მიღებული ცხრილები

მიღებული ცხრილიარის ცხრილის გამოხატულება, რომელიც შედის შეკითხვის FROM პუნქტში. მიღებული ცხრილების გამოყენება შესაძლებელია მაშინ, როდესაც სვეტის მეტსახელების გამოყენება შეუძლებელია, რადგან SQL თარჯიმანი ამუშავებს სხვა განცხადებას, სანამ მეტსახელი გახდება ცნობილი. ქვემოთ მოყვანილი მაგალითი გვიჩვენებს სვეტის მეტსახელის გამოყენების მცდელობას იმ სიტუაციაში, როდესაც სხვა პუნქტი მუშავდება, სანამ მეტსახელი გახდება ცნობილი:

გამოიყენეთ SampleDb; SELECT MONTH(EnterDate) როგორც enter_month FROM Works_on GROUP BY enter_month;

ამ მოთხოვნის შესრულების მცდელობისას დაბრუნდება შემდეგი შეცდომის შეტყობინება:

შეტყობინება 207, დონე 16, მდგომარეობა 1, ხაზი 5 არასწორი სვეტის სახელი "enter_month". (შეტყობინება 207: დონე 16, მდგომარეობა 1, ხაზი 5 არასწორი სვეტის სახელი enter_month)

შეცდომის მიზეზი არის ის, რომ GROUP BY პუნქტი მუშავდება SELECT განცხადების შესაბამისი სიის დამუშავებამდე, ხოლო enter_month სვეტის მეტსახელი უცნობია ჯგუფის დამუშავებისას.

ამ პრობლემის გადაჭრა შესაძლებელია ხედის გამოყენებით, რომელიც შეიცავს წინა მოთხოვნას (GROUP BY პუნქტის გარეშე), რადგან FROM პუნქტი შესრულებულია GROUP BY პუნქტამდე:

გამოიყენეთ SampleDb; SELECT enter_month FROM (SELECT MONTH(EnterDate) as enter_month FROM Works_on) AS m GROUP BY enter_month;

ამ შეკითხვის შედეგი იქნება ასეთი:

როგორც წესი, ცხრილის გამოხატულება შეიძლება განთავსდეს ნებისმიერ ადგილას SELECT განცხადებაში, სადაც შეიძლება გამოჩნდეს ცხრილის სახელი. (ცხრილის გამოხატვის შედეგი ყოველთვის არის ცხრილი ან, განსაკუთრებულ შემთხვევებში, გამოხატულება.) შემდეგი მაგალითი გვიჩვენებს ცხრილის გამოხატვის გამოყენებას SELECT განცხადების Select სიაში:

ამ მოთხოვნის შედეგია:

ცხრილის ზოგადი გამონათქვამები

ცხრილის საერთო გამოხატულება (OTB) (მოკლედ CTE)არის დასახელებული ცხრილის გამოხატულება, რომელსაც მხარს უჭერს Transact-SQL ენა. ცხრილის საერთო გამონათქვამები გამოიყენება შემდეგი ორი ტიპის შეკითხვებში:

არარეკურსიული;

რეკურსიული.

ამ ორი ტიპის მოთხოვნა განიხილება შემდეგ თავებში.

OTB და არარეკურსიული მოთხოვნები

OTB-ის არარეკურსიული ფორმა შეიძლება გამოყენებულ იქნას როგორც მიღებული ცხრილებისა და ხედების ალტერნატივა. ჩვეულებრივ OTB განისაზღვრება პუნქტებითდა დამატებითი მოთხოვნა, რომელიც ეხება WITH პუნქტში გამოყენებულ სახელს. Transact-SQL-ში WITH საკვანძო სიტყვის მნიშვნელობა ორაზროვანია. გაურკვევლობის თავიდან აცილების მიზნით, WITH-ის წინა განცხადება უნდა დასრულდეს მძიმით.

გამოიყენეთ AdventureWorks2012; SELECT SalesOrderID FROM Sales.SalesOrderHeader WHERE TotalDue > (SELECT AVG(TotalDue) FROM Sales.SalesOrderHeader WHERE YEAR(OrderDate) = "2005") AND Freight > (SELECT AVG(TotalDue)Hederader0rOM ")/2.5;

ამ მაგალითში მოთხოვნა ირჩევს შეკვეთებს, რომელთა ჯამური გადასახადები (TotalDue) მეტია ყველა გადასახადის საშუალოზე და რომლის ტვირთის გადასახადი (Freight) მეტია საშუალო გადასახადების 40%-ზე. ამ მოთხოვნის მთავარი თვისებაა მისი მოცულობითობა, რადგან ჩადგმული შეკითხვა ორჯერ უნდა დაიწეროს. მოთხოვნის კონსტრუქციის ფარგლების შემცირების ერთ-ერთი შესაძლო გზა იქნება ხედის შექმნა, რომელიც შეიცავს ქვემოთხოვნას. მაგრამ ეს გამოსავალი ცოტა რთულია, რადგან ის მოითხოვს ხედის შექმნას და შემდეგ წაშლას მოთხოვნის დასრულების შემდეგ. საუკეთესო მიდგომა იქნება OTB-ის შექმნა. ქვემოთ მოყვანილი მაგალითი გვიჩვენებს არარეკურსიული OTB-ის გამოყენებას, რაც ამცირებს მოთხოვნის განმარტებას ზემოთ:

გამოიყენეთ AdventureWorks2012; WITH price_calc(year_2005) AS (SELECT AVG(TotalDue) FROM Sales.SalesOrderHeader WHERE YEAR(OrderDate) = "2005") SELECT SalesOrderID FROM Sales.SalesOrderHeader WHERE WHEREOrderHeader WHERE FreshOrderHeader WHEREFree_calDue (Free_calDue)წელი (SELECTROCAL) 2005წელი (Free) /2.5;

WITH პუნქტის სინტაქსი არარეკურსიულ შეკითხვებში შემდეგია:

cte_name პარამეტრი არის OTB სახელი, რომელიც განსაზღვრავს მიღებულ ცხრილს, ხოლო column_list პარამეტრი არის სვეტების სია ცხრილის გამოხატულებაში. (ზემოთ მოყვანილ მაგალითში OTB-ს ჰქვია price_calc და აქვს ერთი სვეტი, წელი_2005.) inner_query პარამეტრი წარმოადგენს SELECT განცხადებას, რომელიც განსაზღვრავს შესაბამისი ცხრილის გამოხატვის შედეგების კომპლექტს. განსაზღვრული ცხრილის გამოხატულება შეიძლება გამოყენებულ იქნას outer_query-ში. (ზემოთ მოყვანილ მაგალითში გარე მოთხოვნა იყენებს OTB price_calc და მის year_2005 სვეტს ორმაგი ჩადგმული მოთხოვნის გასამარტივებლად.)

OTB და რეკურსიული მოთხოვნები

ამ განყოფილებაში წარმოდგენილია გაზრდილი სირთულის მასალა. ამიტომ, როცა პირველად წაიკითხავთ, რეკომენდირებულია გამოტოვოთ და მოგვიანებით დაუბრუნდეთ. OTB შეიძლება იყოს რეკურსიული, რადგან OTB შეიძლება შეიცავდეს მითითებებს საკუთარ თავზე. რეკურსიული შეკითხვის ძირითადი OTB სინტაქსი ასე გამოიყურება:

cte_name და column_list პარამეტრებს აქვთ იგივე მნიშვნელობა, რაც OTB-ში არარეკურსიული მოთხოვნებისთვის. WITH პუნქტის ძირითადი ნაწილი შედგება ორი მოთხოვნისაგან, რომლებსაც უერთდება განცხადება UNION ALL. პირველი შეკითხვა იძახება მხოლოდ ერთხელ და ის იწყებს რეკურსიის შედეგის დაგროვებას. UNION ALL ოპერატორის პირველი ოპერანდი არ ეხება OTB-ს. ამ შეკითხვას ეწოდება საცნობარო მოთხოვნა ან წყარო.

მეორე მოთხოვნა შეიცავს ბმულს OTB-თან და წარმოადგენს მის რეკურსიულ ნაწილს. ამის გამო მას რეკურსიულ წევრს უწოდებენ. რეკურსიული ნაწილის პირველ ზარში, OTB მითითება წარმოადგენს საცნობარო მოთხოვნის შედეგს. რეკურსიული წევრი იყენებს მოთხოვნაზე პირველი ზარის შედეგს. ამის შემდეგ სისტემა კვლავ უწოდებს რეკურსიულ ნაწილს. რეკურსიულ წევრზე ზარი მთავრდება, როდესაც მასზე წინა ზარი აბრუნებს ცარიელ შედეგებს.

UNION ALL ოპერატორი უერთდება აქამდე დაგროვილ რიგებს, ისევე როგორც დამატებით რიგებს, რომლებიც დაემატა მიმდინარე ზარის მიერ რეკურსიულ წევრს. (UNION ALL ოპერატორის არსებობა ნიშნავს, რომ დუბლიკატი რიგები არ წაიშლება შედეგიდან.)

და ბოლოს, outer_query პარამეტრი განსაზღვრავს გარე მოთხოვნას, რომელსაც OTB იყენებს ორივე წევრის გაერთიანებაში ყველა ზარის მისაღებად.

OTB-ის რეკურსიული ფორმის საჩვენებლად, ჩვენ ვიყენებთ თვითმფრინავის ცხრილს, რომელიც არის განსაზღვრული და შევსებული ქვემოთ მოცემულ მაგალითში ნაჩვენები კოდით:

გამოიყენეთ SampleDb; CREATE TABLE თვითმფრინავი (ContainingAssembly VARCHAR(10), ContainedAssembly VARCHAR(10), QuantityContained INT, UnitCost DECIMAL(6,2)); INSERT INTO Airplane VALUES ("Airplane", "Fuselage", 1, 10); INSERT INTO Airplane VALUES-ში ("Airplane", "Wings", 1, 11); INSERT INTO Airplane VALUES ("Airplane", "Tail", 1, 12); INSERT INTO Airplane VALUES ("Fuselage", "Salon", 1, 13); INSERT INTO Airplane VALUES-ში ("Fuselage", "Cockpit", 1, 14); INSERT INTO Airplane VALUES ("Fuselage", "Nose", 1, 15); INSERT INTO Airplane VALUES ("Salon", NULL, 1,13); INSERT INTO Airplane VALUES ("კაბინა", NULL, 1, 14); INSERT INTO Airplane VALUES ("ცხვირი", NULL, 1, 15); INSERT INTO Airplane VALUES ("Wings", NULL,2, 11); INSERT INTO Airplane VALUES ("კუდი", NULL, 1, 12);

თვითმფრინავის ცხრილს აქვს ოთხი სვეტი. სვეტი ContainingAssembly განსაზღვრავს ასამბლეას, ხოლო ContainedAssembly სვეტი განსაზღვრავს ნაწილებს (სათითაოდ), რომლებიც ქმნიან შესაბამის ასამბლეას. ქვემოთ მოყვანილი სურათი გვიჩვენებს შესაძლო ტიპის თვითმფრინავისა და მისი შემადგენელი ნაწილების გრაფიკულ ილუსტრაციას:

თვითმფრინავის ცხრილი შედგება შემდეგი 11 მწკრივისაგან:

შემდეგი მაგალითი იყენებს WITH პუნქტს შეკითხვის დასადგენად, რომელიც ითვლის თითოეული აშენების მთლიან ღირებულებას:

გამოიყენეთ SampleDb; WITH list_of_parts(აწყობა1, რაოდენობა, ღირებულება) AS (SELECT ContainingAssembly, QuantityContained, UnitCost FROM Airplane WHERE ContainedAssembly IS NULL UNION ALL SELECT a.ContainingAssembly, a.QuantityAssembly, a.QuantityAssembly, a.QuantityASTContained. ) FROM list_of_parts l, Airplane a WHERE l.assembly1 = a.ContainedAssembly) SELECT assembly1 "Part", რაოდენობა "Quantity", ღირებულება "Price" FROM list_of_parts;

WITH პუნქტი განსაზღვრავს OTB სიას სახელად list_of_parts, რომელიც შედგება სამი სვეტისაგან: assembly1, რაოდენობა და ღირებულება. მაგალითში პირველი SELECT განცხადება გამოიძახება მხოლოდ ერთხელ რეკურსიის პროცესის პირველი საფეხურის შედეგების შესანახად. მაგალითის ბოლო სტრიქონზე SELECT განცხადება აჩვენებს შემდეგ შედეგს.

ბოლო განახლება: 07/05/2017

ბოლო თემაში SQL Management Studio-ში შეიქმნა მარტივი მონაცემთა ბაზა ერთი ცხრილით. ახლა მოდით განვსაზღვროთ და შევასრულოთ პირველი SQL მოთხოვნა. ამისათვის გახსენით SQL Management Studio, დააწკაპუნეთ მარჯვენა ღილაკით Object Explorer-ის ზედა დონის ელემენტზე (სერვერის სახელი) და აირჩიეთ ახალი შეკითხვა კონტექსტური მენიუდან, რომელიც გამოჩნდება:

ამის შემდეგ პროგრამის ცენტრალურ ნაწილში გაიხსნება ფანჯარა SQL ბრძანებების შესაყვანად.

შევასრულოთ მოთხოვნა მაგიდაზე, რომელიც შეიქმნა წინა თემაში, კერძოდ, მისგან მივიღებთ ყველა მონაცემს. ჩვენს მონაცემთა ბაზას ჰქვია უნივერსიტეტი, ხოლო ცხრილი არის dbo.Students, ამიტომ ცხრილიდან მონაცემების მისაღებად შევიყვანთ შემდეგ შეკითხვას:

SELECT * FROM University.dbo.Students

SELECT განცხადება საშუალებას გაძლევთ აირჩიოთ მონაცემები. FROM განსაზღვრავს წყაროს, საიდანაც უნდა მიიღოთ მონაცემები. სინამდვილეში, ამ შეკითხვით ჩვენ ვამბობთ "SELECT all FROM table University.dbo.Students". აღსანიშნავია, რომ ცხრილის სრული გზა გამოიყენება ცხრილის სახელწოდებისთვის, მონაცემთა ბაზისა და სქემის მითითებით.

მოთხოვნის შეყვანის შემდეგ დააწკაპუნეთ ინსტრუმენტთა ზოლის ღილაკზე Execute, ან შეგიძლიათ დააჭიროთ F5 ღილაკს.

შეკითხვის შესრულების შედეგად, პროგრამის ბოლოში გამოჩნდება პატარა ცხრილი, რომელიც აჩვენებს შეკითხვის შედეგებს - ანუ Students ცხრილის ყველა მონაცემს.

თუ ჩვენ გვჭირდება მრავალი მოთხოვნის გაკეთება იმავე მონაცემთა ბაზის მიმართ, მაშინ შეგვიძლია გამოვიყენოთ USE ბრძანება მონაცემთა ბაზის ჩასადენად. ამ შემთხვევაში, ცხრილების მოთხოვნისას საკმარისია მათი სახელის მითითება მონაცემთა ბაზის სახელისა და სქემის გარეშე:

გამოიყენეთ უნივერსიტეტის SELECT * სტუდენტებისგან

ამ შემთხვევაში, ჩვენ ვასრულებთ მოთხოვნას მთლიანობაში სერვერისთვის, ჩვენ შეგვიძლია სერვერის ნებისმიერ მონაცემთა ბაზაში წვდომა. მაგრამ ჩვენ ასევე შეგვიძლია შევასრულოთ მოთხოვნები მხოლოდ კონკრეტულ მონაცემთა ბაზაში. ამისათვის დააწკაპუნეთ სასურველ მონაცემთა ბაზაზე მარჯვენა ღილაკით და კონტექსტური მენიუდან აირჩიეთ New Query:

თუ ამ შემთხვევაში გვინდოდა გამოვკითხოთ ზემოთ გამოყენებული Students ცხრილი, მაშინ მოთხოვნაში არ მოგვიწევდა მონაცემთა ბაზის სახელის და სქემის მითითება, რადგან ეს მნიშვნელობები უკვე გასაგები იქნებოდა.