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

მაგრამ, მიუხედავად მონაცემთა ბაზების მუდმივი გამოყენებისა, პროგრამული სისტემების მრავალი დეველოპერისთვისაც კი არსებობს მრავალი „თეთრი ლაქა“ ერთი და იგივე ტერმინების განსხვავებული ინტერპრეტაციების გამო. ჩვენ მივცემთ მონაცემთა ბაზის ძირითადი ტერმინების მოკლე განმარტებას 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 სინტაქსის სტანდარტს, მონაცემთა ბაზების რეპლიკაციას და ღრუბლოვან სერვისებს.

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

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

მოთხოვნის ტიპი კონსტრუქტორში:

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

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

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

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

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

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

საბოლოო მოთხოვნა იქმნება რეჟიმის გამოყენებით - Summary query.

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

ამ შემთხვევაში, თქვენ შეგიძლიათ გამოიძახოთ კონტექსტური მენიუ მოთხოვნის ნებისმიერი ადგილიდან (მაუსის მარჯვენა ღილაკი) და აირჩიოთ "ჯგუფური ოპერაციების" ფუნქცია.

მოთხოვნის ფორმა გამოჩნდება ახალი ხაზიდაჯგუფება.

ჯამური ფუნქციები: ველში, რომლისთვისაც გვინდა გამოვთვალოთ ჯამები, აირჩიეთ სიიდან "ჯამ" ფუნქცია არჩეული ველების ყველა მნიშვნელობის შესაჯამებლად. Count ფუნქცია დათვლის ველის მნიშვნელობების რაოდენობას. ინფორმაციის რედაქტირება microsoft

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

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

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

მოთხოვნის ტიპები:

• - სინჯის აღება;
• - მაგიდის შექმნა;
• - განახლება (მონაცემთა ცვლილება);
• - ჩანაწერების დამატება;
• - ჩანაწერების წაშლა.

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

Microsoft Access-ში არსებობს რამდენიმე სახის მოთხოვნა.

DBMS წვდომა

Microsoft Access არის DBMS-ის რელაციური ტიპი, რომელიც გონივრულად აბალანსებს მონაცემთა ბაზის მართვის თანამედროვე სისტემებისთვის დამახასიათებელ ყველა ინსტრუმენტს და შესაძლებლობებს. რელაციური მონაცემთა ბაზა აადვილებს მონაცემთა პოვნას, ანალიზს, შენარჩუნებას და დაცვას, რადგან ისინი ინახება ერთ ადგილას. წვდომა ინგლისურიდან თარგმანში ნიშნავს "წვდომას". MS Access არის ერთ-ერთი ყველაზე ძლიერი, მოქნილი და ადვილად გამოსაყენებელი DBMS. თქვენ შეგიძლიათ მასში შექმნათ აპლიკაციების უმეტესობა პროგრამის ერთი ხაზის დაწერის გარეშე, მაგრამ თუ გჭირდებათ რაიმე ძალიან რთული შექმნა, მაშინ ამ შემთხვევაში MS Access გთავაზობთ პროგრამირების მძლავრ ენას - Visual Basic Application.

Microsoft Access DBMS-ის პოპულარობა განპირობებულია შემდეგი მიზეზებით:

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

OLE ტექნოლოგიის გამოყენების უნარი;

Microsoft Office პაკეტთან ინტეგრაცია;

ვებ ტექნოლოგიების სრული მხარდაჭერა;

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

ობიექტების განვითარებისთვის "ოსტატების" დიდი ნაკრების არსებობა.

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

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

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

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

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

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

ვიზუალური განვითარების პროგრამირების ბაზა

გვერდი - გამოიყენება მონაცემთა წვდომისათვის მიმდინარე Access მონაცემთა ბაზაში.

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

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

DBMS გაშვებულია Start - პროგრამები - Microsoft Access-ის მიერ. გაუშვით ბრძანება File - New.

მონაცემთა ბაზის ობიექტებთან მუშაობის ინტერფეისი ერთიანია. თითოეული მათგანისთვის არსებობს მუშაობის სტანდარტული რეჟიმები: შექმნა (ობიექტების სტრუქტურის შექმნა); კონსტრუქტორი (ობიექტების სტრუქტურის შეცვლა); Open (View, Run - შექმნილია მონაცემთა ბაზის ობიექტებთან მუშაობისთვის).

SQL შეკითხვის ენა

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

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

SQL ენა არის ოპერატორების ნაკრები:

მონაცემთა განსაზღვრის ოპერატორები (Data Definition Language, DDL);

მონაცემთა მანიპულირების ოპერატორები (Data Manipulation Language, DML);

მონაცემთა წვდომის განსაზღვრის ოპერატორები (Data Control Language, DCL);

ტრანზაქციის კონტროლის ენის (TCL) განცხადებები.

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

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

SQL იყენებს სამ ღირებულებიან ლოგიკას. ტრადიციულ ლოგინებთან ერთად TRUE და FALSE გამოიყენება NULL (უცნობი ან NO DATA).

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

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

დროთა განმავლობაში, პროცესმა შეიძლება მოითხოვოს Microsoft Office Access (Access) ფაილ-სერვერის მონაცემთა ბაზის მიგრაცია კლიენტ-სერვერის DBMS ფორმატში. ჩვეულებრივ ODBC გამოიყენება ამ მიზნით. თუმცა, Microsoft SQL Server-ზე (MS SQL) გადასატანად Access და MS SQL DBMS აქვს მოსახერხებელი სპეციალიზებული ხელსაწყოები.

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

მონაცემთა ბაზის გადატანა გამოყენებითწვდომა ("ოსტატი ფორმატში კონვერტაციისთვისSQLსერვერი")

გადაცემის დასაწყებად, თქვენ უნდა დააჭიროთ ღილაკს "SQL Server" ჩანართში "მონაცემთა მოძრაობა" განყოფილებაში "მუშაობა მონაცემთა ბაზებთან".

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

არსებობს ორი ვარიანტი:

1. ექსპორტი არსებულ MS SQL მონაცემთა ბაზაში;
2. შექმენით ახალი მონაცემთა ბაზა (ნაგულისხმევი).

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

ერთი ცხრილის ასარჩევად გამოიყენეთ ">" ღილაკი, ხოლო ყველა ცხრილის ასარჩევად გამოიყენეთ ღილაკი ">>". გადარიცხვაზე უარის თქმის მიზნით, ღილაკები "<» и «<<» соответственно.

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

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

როდესაც ყველა საჭირო ინფორმაცია შეგროვდება, შეგიძლიათ ან დაუბრუნდეთ ერთ-ერთ წინა ნაბიჯს გადამოწმებისთვის, ან დაიწყოთ გადაცემის პროცესი ღილაკზე „დასრულება“ დაწკაპუნებით.

გადაცემის პროცესის პროგრესი ნათლად არის ნაჩვენები სპეციალურ ფანჯარაში.

მიგრაციის დასრულების შემდეგ, შეგიძლიათ გახსნათ SQL Server Management Studio და ნახოთ შედეგი.

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

მონაცემთა ბაზის იმპორტიწვდომის საშუალებამაიკროსოფტიSQLსერვერი

MS SQL-ს შეუძლია მონაცემთა იმპორტი სხვადასხვა წყაროდან. მაგრამ პირდაპირი იმპორტი Access-დან შესაძლებელია მხოლოდ ძველი ფორმატის მონაცემთა ბაზებისთვის (.mdb).

ასეთი მონაცემთა ბაზების იმპორტის დეტალური ინსტრუქციები შეგიძლიათ იხილოთ.

ახალი ფორმატების (2007 და ზემოთ) მონაცემთა ბაზების იმპორტი გაცილებით რთულია.

ამ პრობლემის მოგვარების ორი გზა არსებობს:

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

სამწუხაროდ, ODBC მიდგომა საკმაოდ რთულია Windows-ის 64-ბიტიან ვერსიებზე.

მიზეზი ის არის, რომ MS SQL-ის 64-ბიტიანი ვერსიები შეფუთულია SQL Server Management Studio-ის 32-ბიტიან ვერსიებთან. ეს გარემოება ნიშნავს, რომ Access მონაცემთა ბაზები, რომლებისთვისაც მონაცემთა წყაროები შეიქმნა 64-ბიტიან დრაივერებზე დაყრდნობით, არ შეიძლება იმპორტირებული იყოს ამ პროგრამის გამოყენებით.

ისევ არსებობს ორი გამოსავალი (იგულისხმება მხოლოდ გრაფიკული ინტერფეისის გამოყენებით მეთოდები):

• გამოიყენეთ Windows, MS SQL, Office 32-ბიტიანი ვერსიები;
• გამოიყენეთ მხოლოდ 32-ბიტიანი Access და დააკონფიგურირეთ მონაცემთა წყარო 32-ბიტიანი ODBC მენეჯერის გამოყენებით (ჩვეულებრივ C:\Windows\SysWOW64\odbcad32.exe);
• გამოიყენეთ ალტერნატიული პროგრამული უზრუნველყოფა MS SQL-თან მუშაობისთვის.

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

იმპორტის დროს გადადის მხოლოდ თავად ცხრილები და მათი შიგთავსი და სხვა არაფერი (შედარება წინა მეთოდის შესაძლებლობებთან).

აქვე უნდა აღინიშნოს, რომ Access-დან პირდაპირი იმპორტით ნაწილობრივ მოგვარებულია მოთხოვნების ექსპორტის პრობლემა (ODBC-ის საშუალებით შეკითხვებზე წვდომა არ არის). მაგრამ, ნაგულისხმევად, მოთხოვნები იმპორტირებულია MS SQL მონაცემთა ბაზაში ჩვეულებრივი ცხრილების სახით.

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

ამისათვის, არჩეული წვდომის მოთხოვნის ზემოთ სკრინშოტის ფანჯარაში დააჭირეთ ღილაკს "შეცვლა".

ფანჯარაში, რომელიც იხსნება, დააჭირეთ ღილაკს "Change SQL ...".

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

საკუთართან ერთად.

შედეგად, მოთხოვნა Access-დან გადაეცემა MS SQL მონაცემთა ბაზაში სწორად, როგორც ხედი და არა ცხრილი.

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

ამიტომ, Access მონაცემთა ბაზების MS SQL-ზე გადატანის ეს მეთოდი უფრო შესაფერისია ორივე DBMS-ის კვალიფიციური სპეციალისტებისთვის.

ქვემოთ მოცემულია Access მონაცემთა ბაზის იმპორტის მაგალითი ODBC-ის გამოყენებით Windows-ის 32-ბიტიან ვერსიაზე. Windows-ის 64-ბიტიან ვერსიაზე, Access-ის 32-ბიტიანი ვერსიის გამოყენებისას, იმპორტი მსგავსია, მაგრამ მონაცემთა წყარო იქმნება 32-ბიტიან ODBC მენეჯერში.

ჩვენ ვქმნით მონაცემთა წყაროს.

ფანჯარაში, რომელიც იხსნება, შეიყვანეთ მისი სახელი.

შემდეგ დააწკაპუნეთ ღილაკზე „აირჩიეთ“ და მიუთითეთ Access-ის რომელ მონაცემთა ბაზასთან გსურთ დაკავშირება.

როდესაც მითითებულია წყაროს სახელი და მონაცემთა ბაზის ფაილი, რჩება ღილაკზე "Ok" დაწკაპუნება და სასურველი Access მონაცემთა ბაზის მონაცემთა წყარო მზად არის.

ახლა თქვენ შეგიძლიათ პირდაპირ გააგრძელოთ მონაცემთა ბაზის იმპორტი MS SQL-ში.

ამისათვის, მონაცემთა ბაზის კონტექსტურ მენიუში, რომელშიც გსურთ იმპორტი, აირჩიეთ ელემენტი "დავალებები" -\u003e "მონაცემების იმპორტი".

გაიხსნება "მონაცემთა იმპორტისა და ექსპორტის ოსტატი".

ჩამოსაშლელ სიაში „მონაცემთა წყარო“ უნდა აირჩიოთ „.Net Framework Data Provider for Odbc“ (თუ ნაგულისხმევად არ არის არჩეული) და ცხრილის Dsn სტრიქონში მიუთითეთ წვდომისთვის ზემოთ შექმნილი მონაცემთა წყაროს სახელი. მონაცემთა ბაზა. კავშირის სტრიქონი ("დაკავშირების სტრიქონი") ავტომატურად გენერირებული იქნება.

შემდეგი, თქვენ უნდა მიუთითოთ რომელი მონაცემთა ბაზა, MS SQL იმპორტის რომელი მაგალითი. ამისათვის, ღილაკზე „შემდეგი“ დაწკაპუნების შემდეგ, ჩამოსაშლელ სიაში „დანიშნულების ადგილი“ აირჩიეთ „Microsoft SQL Server Native Client“ (როგორც ნაჩვენებია ქვემოთ მოცემულ ეკრანის სურათზე) ან „Microsoft OLE DB Provider SQL Server-ისთვის“, მიუთითეთ მონაცემთა ბაზის სასურველი მომხმარებლის სახელი და პაროლი კავშირებისთვის.

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

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

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

ღილაკზე „დასრულება“ დაჭერის შემდეგ იმპორტის პროცესი დასრულდება. თუ ყველაფერი გაკეთდა სწორად და იმპორტი წარმატებულია, ფანჯარაში, სადაც ინფორმაციაა იმპორტის შესახებ, შეცდომებს არ შეიცავს (იხილეთ ეკრანის სურათი ქვემოთ).

ოსტატის დასასრულებლად, უბრალოდ დააჭირეთ ღილაკს "დახურვა".

შედეგის ნახვა შეგიძლიათ SQL Server Management Studio-ით.

მონაცემთა ბაზის გვერდიდან გადატანა საშუალებითODBC

ეს მეთოდი უნივერსალურია წვდომიდან მონაცემების ნებისმიერ სხვა DBMS-ზე ექსპორტისთვის. საკმარისია, რომ ის მხარს უჭერს ODBC-თან მუშაობას.

ასეთი ექსპორტის მაგალითი უკვე განვიხილეთ სტატიაში ""

ამისთვისᲥᲐᲚᲑᲐᲢᲝᲜᲘSQL-მ საშუალება მისცა მონაცემთა ბაზის მიგრაციასწვდომა არ არის საჭირო, ვინაიდან მხოლოდ მონაცემების მქონე ცხრილები ექსპორტირებულია, ხოლო მოთხოვნები მხოლოდ ჩვეულებრივი ცხრილების სახით.

თუმცა, ეს პორტაბელურობა ჯერ კიდევ ხელმისაწვდომია (გამონაკლისი არ იყო 2014 წლის ვერსია). ასე რომ, მოდით, ამასაც მივხედოთ.

პირველი, მოდით შევქმნათ მონაცემთა წყარო MS SQL-თან მუშაობისთვის (მოდით, ეს იყოს მორგებული DSN).

მიუთითეთ დრაივერი წყაროსთვის.

ამის შემდეგ დაიწყება მისი შექმნისა და კონფიგურაციის პროცესი.

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

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

ღილაკზე "დასრულება" დაწკაპუნების შემდეგ გამოჩნდება ფანჯარა შემაჯამებელი ინფორმაციით შექმნილი მონაცემთა წყაროს შესახებ.

იმისათვის, რომ მონაცემთა წყარო საბოლოოდ შეიქმნას, უბრალოდ დააჭირეთ ღილაკს "OK". მაგრამ, უმჯობესია ჯერ შეამოწმოთ მისი შესრულება ღილაკზე "შეამოწმეთ მონაცემთა წყარო".

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

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

ამისათვის აირჩიეთ ის მაუსით და დააჭირეთ ღილაკს "Advanced" ჩანართში "ექსპორტი" განყოფილებაში "გარე მონაცემები". ჩამოსაშლელ მენიუში აირჩიეთ "ODBC მონაცემთა ბაზა".

ამ შემთხვევაში, თავდაპირველი მნიშვნელობა რჩება.

"Ok" ღილაკზე დაჭერის შემდეგ, თქვენ უნდა აირჩიოთ შექმნილი მონაცემთა წყარო.

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

"Ok" ღილაკზე დაჭერის შემდეგ განხორციელდება ექსპორტი.

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

„კონტაქტების მოთხოვნის“ ხედის ნაცვლად, MS SQL მონაცემთა ბაზაში შეიქმნა ამავე სახელწოდების ცხრილი.

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

საგანმანათლებლო პროექტის "მაღაზია" აღწერა

ცხრილის ბმული სქემა

ცხრილების აღწერა

m_category - პროდუქტის კატეგორიები

მ_შემოსავალი - საქონლის მიღება

m_შედეგი - საქონლის მოხმარება

m_product - დირექტორია, პროდუქტის აღწერა

m_supplier - დირექტორია; მიმწოდებლის ინფორმაცია

m_unit - დირექტორია; ერთეულები

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

Microsoft Access 2003 ან უფრო ახალი.

SQL მოთხოვნა MS Access-ში. დაწყება

ცხრილის შინაარსის სანახავად, ორჯერ დააწკაპუნეთ ცხრილის სახელზე მარცხენა პანელში:

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

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

SQL შეკითხვის რედაქტირების რეჟიმში გადასასვლელად აირჩიეთ SQL რეჟიმი ზედა პანელზე:

SQL შეკითხვა. მაგალითები MS Access-ში. SELECT: 1-10

SQL მოთხოვნაში SELECT განცხადება გამოიყენება მონაცემთა ბაზის ცხრილებიდან ასარჩევად.

SQL შეკითხვა Q001. SQL მოთხოვნის მაგალითი, რომ მიიღოთ მხოლოდ საჭირო ველები სასურველი თანმიმდევრობით:

SELECT dt, product_id, თანხა

მ_ შემოსავალი;

SQL შეკითხვა Q002.ამ SQL შეკითხვის მაგალითში, ვარსკვლავის სიმბოლო (*) გამოიყენება m_product ცხრილის ყველა სვეტის საჩვენებლად, სხვა სიტყვებით რომ ვთქვათ, m_product კავშირის ყველა ველის მისაღებად:

აირჩიეთ *
FROM m_პროდუქტი;

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

აირჩიეთ DISTINCT product_id

მ_ შემოსავალი;

SQL შეკითხვა Q004. ORDER BY განცხადება გამოიყენება ჩანაწერების დასალაგებლად (შეკვეთა) კონკრეტული ველის მნიშვნელობებით. ველის სახელი მიჰყვება ORDER BY პუნქტს:

აირჩიეთ *
მ_შემოსავლიდან

შეკვეთა ფასის მიხედვით;

SQL შეკითხვა Q005. ASC განცხადება გამოიყენება ORDER BY განცხადების დამატებით და გამოიყენება აღმავალი დალაგების დასადგენად. DESC განცხადება გამოიყენება ORDER BY განცხადების დამატებით და გამოიყენება კლებადი დალაგების დასადგენად. იმ შემთხვევაში, როდესაც არც ASC და არც DESC არ არის მითითებული, ASC-ის არსებობა (ნაგულისხმევი) ვარაუდობენ:

აირჩიეთ *
მ_შემოსავლიდან

შეკვეთა dt DESC-ით, ფასი;

SQL შეკითხვა Q006.ცხრილიდან საჭირო ჩანაწერების შესარჩევად გამოიყენება სხვადასხვა ლოგიკური გამონათქვამები, რომლებიც გამოხატავს შერჩევის მდგომარეობას. ლოგიკური გამოხატულება მოდის WHERE პუნქტის შემდეგ. m_income ცხრილიდან ყველა ჩანაწერის მიღების მაგალითი, რომლის თანხის მნიშვნელობა 200-ზე მეტია:

აირჩიეთ *
მ_შემოსავლიდან

WHERE თანხა>200;

SQL შეკითხვა Q007.რთული პირობების გამოსახატავად გამოიყენება ლოგიკური ოპერაციები AND (შეერთება), OR (დისიუნქცია) და NOT (ლოგიკური უარყოფა). m_outcome ცხრილიდან ყველა ჩანაწერის მიღების მაგალითი, რომლის თანხის მნიშვნელობა არის 20 და ფასის მნიშვნელობა 10-ზე მეტი ან ტოლია:

ფასი

FROM m_შედეგი
WHERE თანხა=20 და ფასი>=10;

SQL შეკითხვა Q008.ორი ან მეტი ცხრილის მონაცემების შესაერთებლად გამოიყენეთ INNER JOIN, LEFT JOIN, RIGHT JOIN განცხადებები. შემდეგი მაგალითი ამოიღებს dt, product_id, თანხა, ფასის ველებს m_income ცხრილიდან და სათაურის ველს m_product ცხრილიდან. m_income ცხრილის ჩანაწერი დაკავშირებულია m_product ცხრილის ჩანაწერთან, როდესაც m_income.product_id მნიშვნელობა უდრის m_product.id მნიშვნელობას:

ON m_income.product_id=m_product.id;

SQL შეკითხვა Q009.არის ორი რამ, რასაც ყურადღება უნდა მიაქციოთ ამ SQL მოთხოვნაში: 1) საძიებო ტექსტი ჩასმულია ერთ ბრჭყალებში ("); 2) თარიღი არის #Month/Day/Year# ფორმატში, რაც სწორია MS-ისთვის. წვდომა. სხვა სისტემებში თარიღის ფორმატი შეიძლება განსხვავებული იყოს. რძის მიღების შესახებ ინფორმაციის ჩვენების მაგალითი 2011 წლის 12 ივნისს. ყურადღება მიაქციეთ თარიღის ფორმატს #6/12/2011#:

SELECT dt, product_id, სათაური, თანხა, ფასი

FROM m_income INNER JOIN m_product

WHERE title="რძე" And dt=#6/12/2011#; !}

SQL შეკითხვა Q010. BETWEEN ინსტრუქცია გამოიყენება შესამოწმებლად, ეკუთვნის თუ არა მას მნიშვნელობების დიაპაზონი. SQL მოთხოვნის მაგალითი, რომელიც აჩვენებს ინფორმაციას 2011 წლის 1 ივნისიდან 30 ივნისამდე მიღებულ საქონელზე:

აირჩიეთ *
FROM m_income INNER JOIN m_product

ON m_income.product_id=m_product.id
WHERE dt შორის #6/1/2011# და #6/30/2011#;

SQL შეკითხვა. მაგალითები MS Access-ში. SELECT: 11-20

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

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

აირჩიეთ *
FROM m_product

WHERE id IN (SELECT product_id FROM m_income);

მოთხოვნა Q012.ნაჩვენებია პროდუქტების სია m_product ცხრილიდან, რომელთა კოდები არ არის m_outcome ცხრილში:

აირჩიეთ *
FROM m_product

WHERE id NOT IN (SELECT product_id FROM m_outcome);

მოთხოვნა Q013.ეს SQL მოთხოვნა აბრუნებს კოდებისა და პროდუქტის სახელების უნიკალურ სიას, რომლებსაც აქვთ კოდები m_income ცხრილში, მაგრამ არა m_outcome ცხრილში:

აირჩიეთ DISTINCT product_id, სათაური

FROM m_income INNER JOIN m_product
ON m_income.product_id=m_product.id
WHERE product_id NOT IN (SELECT product_id FROM m_outcome);

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

აირჩიეთ განსხვავებული სათაური

FROM m_product
WHERE სათაური LIKE "M*";

მოთხოვნა Q015.მოთხოვნის ველებზე არითმეტიკული მოქმედებების შესრულების მაგალითი და შეკითხვაში ველების სახელის გადარქმევა (სხვა სახელი). ეს მაგალითი ითვლის ხარჯს = რაოდენობას * ფასს და მოგებას თითოეული პროდუქტის მოხმარების ჩანაწერისთვის, თუ ვივარაუდებთ, რომ მოგება არის გაყიდვების 7 პროცენტი:

თანხა*ფასი/100*7 AS მოგება
FROM m_შედეგი;

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

SELECT dt, product_id, თანხა, ფასი, თანხა*ფასი AS outcome_sum,

შედეგი_ჯამ *0.07 AS მოგება
FROM m_შედეგი;

მოთხოვნა Q017. INNER JOIN განაცხადის გამოყენებით, შეგიძლიათ დააკავშიროთ მონაცემები მრავალი ცხრილიდან. შემდეგ მაგალითში, ctgry_id-ის მნიშვნელობიდან გამომდინარე, m_income ცხრილის თითოეული ჩანაწერი ემთხვევა იმ კატეგორიის სახელს m_category ცხრილიდან, რომელსაც ეკუთვნის პროდუქტი:

აირჩიეთ c.title, b.title, dt, თანხა, ფასი, თანხა*ფასი AS შემოსავალი_ჯამად

FROM (მ_შემოსავალი AS INNER JOIN m_product AS b ON a.product_id=b.id)
INNER JOIN m_category AS c ON b.ctgry_id=c.id
ORDER BY c.title, b.title;

მოთხოვნა Q018.ისეთ ფუნქციებს, როგორიცაა SUM - ჯამი, COUNT - რაოდენობა, AVG - საშუალო არითმეტიკული, MAX - მაქსიმალური მნიშვნელობა, MIN - მინიმალური მნიშვნელობა ეწოდება აგრეგატის ფუნქციებს. ისინი იღებენ მრავალ მნიშვნელობას და დამუშავებისას აბრუნებენ ერთ მნიშვნელობას. ველების ოდენობისა და ფასის ნამრავლის ჯამის გამოთვლის მაგალითი აგრეგატის ფუნქციაჯამი:

SELECT SUM(თანხა*ფასი) AS Total_Sum

მ_ შემოსავალი;

მოთხოვნა Q019.მრავალი აგრეგატის ფუნქციის გამოყენების მაგალითი:

SELECT Sum(amount) AS Amount_Sum, AVG(amount) AS Amount_AVG,

MAX(ოდენობა) AS Amount_Max, Min(amount) AS Amount_Min,
Count(*) AS Total_Number
მ_ შემოსავალი;

მოითხოვეთ Q020.ამ მაგალითში გამოითვლება 2011 წლის ივნისში მიღებული 1 კოდის მქონე ყველა ელემენტის ჯამი:

აირჩიეთ თანხა(თანხა*ფასი) AS შემოსავალი_ჯამად

მ_შემოსავლიდან
WHERE product_id=1 და dt #6/1/2011# და #6/30/2011# შორის#;.

მოითხოვეთ Q021.შემდეგი SQL მოთხოვნა ითვლის, თუ რა ფასად გაიყიდა 4 ან 6 კოდის მქონე საქონელი:

აირჩიეთ თანხა (თანხა*ფასი) როგორც შედეგი_ჯამად

FROM m_შედეგი
WHERE product_id=4 ან product_id=6;

მოითხოვეთ Q022.გამოითვლება რა ოდენობით გაიყიდა 2011 წლის 12 ივნისს საქონელი 4 ან 6 კოდით:

აირჩიეთ თანხა (თანხა*ფასი) როგორც outcome_sum

FROM m_შედეგი
WHERE (product_id=4 OR product_id=6) AND dt=#6/12/2011#;

მოითხოვეთ Q023.ამოცანა ეს არის. გამოთვალეთ ჯამური თანხა, რისთვისაც ჩაირიცხა კატეგორიის „ცომეული პროდუქტები“ საქონელი.

ამ პრობლემის გადასაჭრელად, თქვენ უნდა იმუშაოთ სამ ცხრილზე: m_income, m_product და m_category, რადგან:

- დაკრედიტებული საქონლის რაოდენობა და ფასი ინახება m_შემოსავლების ცხრილში;
- თითოეული პროდუქტის კატეგორიის კოდი ინახება m_product ცხრილში;
- კატეგორიის სათაურის სახელი ინახება m_category ცხრილში.

ამ პრობლემის გადასაჭრელად ვიყენებთ შემდეგ ალგორითმს:

- კატეგორიის კოდის "ცომეული პროდუქტები" განსაზღვრა ცხრილიდან m_კატეგორიიდან ქვეშეკითხვის საშუალებით;
- m_income და m_product ცხრილების შეერთება თითოეული დაკრედიტებული პროდუქტის კატეგორიის დასადგენად;
- ქვითრის ოდენობის (= რაოდენობა * ფასი) გამოთვლა საქონელზე, რომლის კატეგორიის კოდი უდრის ზემოაღნიშნული ქვემოთხოვნით განსაზღვრულ კოდს.
აირჩიეთ
FROM m_product AS INNER JOIN m_income AS b ON a.id=b.product_id
WHERE ctgry_id = (SELECT id FROM m_category WHERE title="ცომეული"); !}

მოითხოვეთ Q024.კატეგორიის „ცომეული პროდუქტების“ დაკრედიტებული საქონლის ჯამური ოდენობის გამოთვლის პრობლემა მოგვარდება შემდეგი ალგორითმით:
- m_income ცხრილის თითოეული ჩანაწერი, მისი პროდუქტის_id მნიშვნელობიდან გამომდინარე, m_category ცხრილიდან ემთხვევა კატეგორიის სახელს;
- შეარჩიეთ ჩანაწერები, რომლებისთვისაც კატეგორია უდრის „ცომეულ პროდუქტებს“;
- გამოთვალეთ შემოსავლის ოდენობა = რაოდენობა * ფასი.

FROM (m_პროდუქტი, როგორც შიდა JOIN m_შემოსავალი AS b ON a.id=b.product_id)

WHERE c.title="ცომეული"; !}

მოითხოვეთ Q025.ეს მაგალითი ითვლის რამდენი ელემენტი იქნა მოხმარებული:

აირჩიეთ COUNT(product_id) როგორც product_cnt

FROM (აირჩიეთ DISTINCT product_id FROM m_outcome) AS t;

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

აირჩიეთ სათაური, SUM(თანხა*ფასი) როგორც outcome_sum

FROM m_product AS INNER JOIN m_შედეგი AS b
ON a.id=b.product_id
ჯგუფი სათაურის მიხედვით;

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

SELECT c.title, SUM(amount*price) AS outcome_sum,

ROUND(AVG(თანხა*ფასი),2) AS outcome_sum_avg
FROM (m_პროდუქტი როგორც შიდა შეერთება m_შედეგი AS b ON a.id=b.product_id)
INNER JOIN m_category AS c ON a.ctgry_id=c.id
GROUP BY c.title;

მოითხოვეთ Q028.თითოეული პროდუქტისთვის გამოითვლება მისი ქვითრების მთლიანი და საშუალო რაოდენობა და აჩვენებს ინფორმაციას საქონლის შესახებ, რომლის ქვითრების საერთო რაოდენობა არის მინიმუმ 500:

SELECT product_id, SUM(amount) AS თანხა_sum,

მრგვალი(საშ.(ოდენობა),2) AS თანხა_საშ
მ_შემოსავლიდან
GROUP BY product_id
HAVING თანხა(თანხა)>=500;

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

აირჩიეთ სათაური, SUM(თანხა*ფასი) AS შემოსავალი_ჯამად

FROM m_income a INNER JOIN m_product b ON a.product_id=b.id
სად dt #4/1/2011# და #6/30/2011# შორის
ჯგუფი სათაურის მიხედვით
თანხის მქონე (თანხა*ფასი)>=1000;

მოითხოვეთ Q030.ზოგიერთ შემთხვევაში აუცილებელია რომელიმე ცხრილის თითოეული ჩანაწერის შედარება სხვა ცხრილის თითოეულ ჩანაწერთან; რასაც დეკარტის პროდუქტს უწოდებენ. ასეთი შეერთების შედეგად მიღებულ ცხრილს დეკარტის ცხრილი ეწოდება. მაგალითად, თუ ზოგიერთ A ცხრილს აქვს 100 ჩანაწერი, ხოლო B ცხრილში 15, მაშინ მათი დეკარტისეული ცხრილი შედგება 100*15=150 ჩანაწერისგან. შემდეგი მოთხოვნა უერთდება m_income ცხრილის თითოეულ ჩანაწერს m_outcome ცხრილში:
FROM m_ შემოსავალი, m_შედეგი;

მოითხოვეთ Q031.ჩანაწერების ორი ველის მიხედვით დაჯგუფების მაგალითი. შემდეგი SQL მოთხოვნა ითვლის თითოეული მიმწოდებლისთვის მისგან მიღებული საქონლის რაოდენობას და რაოდენობას:

SUM(თანხა*ფასი) AS შემოსავალი_ჯამ

მოთხოვნა Q032.ჩანაწერების ორი ველის მიხედვით დაჯგუფების მაგალითი. შემდეგი მოთხოვნა ითვლის თითოეული მიმწოდებლისთვის ჩვენს მიერ გაყიდული პროდუქციის რაოდენობას და რაოდენობას:

აირჩიეთ მომწოდებლის_იდენტიფიკატორი, პროდუქტის_იდენტიფიკატორი, ჯამი (თანხა) AS თანხა_ჯამობა,

GROUP BY მიმწოდებლის_ID, პროდუქტის_ID;

მოთხოვნა Q033.ამ მაგალითში, ზემოთ მოცემული ორი მოთხოვნა (q031 და q032) გამოიყენება როგორც ქვემოთხოვნები. ამ მოთხოვნების შედეგები გაერთიანებულია ერთ ანგარიშში LEFT JOIN მეთოდის გამოყენებით. შემდეგი მოთხოვნა აჩვენებს ანგარიშს თითოეული მიმწოდებლისთვის მიღებული და გაყიდული პროდუქციის რაოდენობისა და რაოდენობის შესახებ. ყურადღება უნდა მიაქციოთ იმ ფაქტს, რომ თუ რომელიმე პროდუქტი უკვე ჩამოვიდა, მაგრამ ჯერ არ გაყიდულა, მაშინ ამ ჩანაწერის შედეგის_ჯამის უჯრედი ცარიელი იქნება. რომ ეს შეკითხვა მხოლოდ გამოყენების მაგალითია რთული კითხვებიროგორც ქვემოთხოვნა. ამ SQL მოთხოვნის შესრულება დიდი რაოდენობით მონაცემებით საეჭვოა:

აირჩიეთ *
FROM

SUM(თანხა*ფასი) AS შემოსავალი_ჯამ

ON a.product_id=b.id GROUP BY მიმწოდებლის_id, product_id) AS a
LEFT შეერთება
(SELECT მიმწოდებლის_იდენტიფიკატორი, პროდუქტის_იდენტიფიკატორი, ჯამი (თანხა) AS თანხა_ჯამობა,
SUM(თანხა*ფასი) AS outcome_sum
FROM m_outcome AS INNER JOIN m_product AS b
ON a.product_id=b.id GROUP BY მიმწოდებლის_id, product_id) AS b
ON (a.product_id=b.product_id) AND (a.supplier_id=b.supplier_id);

მოითხოვეთ Q034.ამ მაგალითში, ზემოთ მოცემული ორი მოთხოვნა (q031 და q032) გამოიყენება როგორც ქვემოთხოვნები. ამ მოთხოვნების შედეგები გაერთიანებულია ერთ ანგარიშში RIGTH JOIN მეთოდის გამოყენებით. შემდეგი მოთხოვნა ბეჭდავს ანგარიშს თითოეული მომხმარებლის მიერ გადახდილი გადახდების ოდენობის შესახებ მათ მიერ გამოყენებული გადახდის სისტემებზე და მათ მიერ განხორციელებული ინვესტიციების ოდენობაზე. შემდეგი მოთხოვნა აჩვენებს ანგარიშს თითოეული მიმწოდებლისთვის მიღებული და გაყიდული პროდუქციის რაოდენობისა და რაოდენობის შესახებ. გაითვალისწინეთ, რომ თუ პროდუქტი უკვე გაიყიდა, მაგრამ ჯერ არ მიუღია, მაშინ ამ ჩანაწერის შემოსავალი_ჯამის უჯრედი ცარიელი იქნება. ასეთი ცარიელი უჯრედების არსებობა არის გაყიდვების აღრიცხვის შეცდომის მაჩვენებელი, რადგან გაყიდვამდე, პირველ რიგში, აუცილებელია, რომ შესაბამისი პროდუქტი მოვიდეს:

აირჩიეთ *
FROM

(SELECT მიმწოდებლის_იდენტიფიკატორი, პროდუქტის_იდენტიფიკატორი, ჯამი (თანხა) AS თანხა_ჯამობა,
SUM(თანხა*ფასი) AS შემოსავალი_ჯამ
FROM m_income AS INNER JOIN m_product AS b ON a.product_id=b.id
GROUP BY მიმწოდებლის_ID, product_id) AS a
მარჯვენა შეერთება
(SELECT მიმწოდებლის_იდენტიფიკატორი, პროდუქტის_იდენტიფიკატორი, ჯამი (თანხა) AS თანხა_ჯამობა,
SUM(თანხა*ფასი) AS outcome_sum
FROM m_outcome AS INNER JOIN m_product AS b ON a.product_id=b.id
GROUP BY მიმწოდებლის_ID, product_id) AS b
ON (a.supplier_id=b.supplier_id) AND (a.product_id=b.product_id);

მოითხოვეთ Q035.ნაჩვენებია ანგარიში პროდუქტის მიხედვით შემოსავლებისა და ხარჯების ოდენობის შესახებ. ამისათვის იქმნება პროდუქტების სია m_income და m_outcome ცხრილების მიხედვით, შემდეგ ამ სიიდან თითოეულ პროდუქტზე გამოითვლება მისი შემოსულობების ჯამი m_income ცხრილის მიხედვით და მისი ხარჯების ჯამი m_outcome ცხრილის მიხედვით:

SELECT product_id, SUM(in_mount) AS შემოსავალი_ოდენობა,

SUM(out_mount) AS outcome_amount
FROM
(SELECT product_id, თანხა AS in_mount, 0 AS out_amount
მ_შემოსავლიდან
UNION ALL
SELECT product_id, 0 AS in_mount, თანხა AS out_amount
FROM m_შედეგი) AS t
GROUP BY product_id;

მოითხოვეთ Q036. EXISTS ფუნქცია უბრუნებს TRUE-ს, თუ მასზე გადაცემული ნაკრები შეიცავს ელემენტებს. EXISTS ფუნქცია უბრუნებს FALSE-ს, თუ მასზე გადაცემული ნაკრები ცარიელია, ანუ მას არ აქვს ელემენტები. შემდეგი მოთხოვნა აბრუნებს პროდუქტის კოდებს, რომლებიც შეიცავს როგორც m_income ცხრილში, ასევე m_outcome ცხრილში:

აირჩიეთ DISTINCT product_id

FROM m_income AS ა
WHERE EXISTS( აირჩიეთ product_id FROM m_outcome AS b

მოთხოვნა Q037.ნაჩვენებია პროდუქტის კოდები, რომლებიც შეიცავს როგორც m_income ცხრილში, ასევე m_outcome ცხრილში:

აირჩიეთ DISTINCT product_id

FROM m_income AS ა
WHERE product_id IN (SELECT product_id FROM m_outcome)

მოითხოვეთ Q038.ნაჩვენებია პროდუქტის კოდები, რომლებიც შეიცავს m_income ცხრილში, მაგრამ არ შეიცავს m_outcome ცხრილში:

აირჩიეთ DISTINCT product_id

FROM m_income AS ა
WHERE NOT EXISTS(SELECT product_id FROM m_outcome AS b
WHERE b.product_id=a.product_id);

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

SELECT product_id, SUM (თანხა*ფასი) AS თანხა_ჯამად

FROM m_შედეგი
GROUP BY product_id
თანხის ქონა (თანხა*ფასი) = (აირჩიეთ MAX(s_amount)
FROM (SELECT SUM(ოდენობა*ფასი) AS s_amount FROM m_outcome GROUP BY product_id));

მოითხოვეთ Q040.შეფასებისთვის გამოიყენება დაცული სიტყვა IIF (პირობითი განცხადება). ლოგიკური გამოხატულებადა შეასრულეთ ერთი ან მეორე მოქმედება შედეგის მიხედვით (TRUE ან FALSE). შემდეგ მაგალითში ნივთის მიწოდება ითვლება „პატარად“, თუ რაოდენობა 500-ზე ნაკლებია. წინააღმდეგ შემთხვევაში, ანუ ქვითრის რაოდენობა 500-ზე მეტი ან ტოლია, მიწოდება ითვლება „დიდი“:

SELECT dt, product_id, თანხა,

IIF(თანხა მ_შემოსავალი;

SQL შეკითხვა Q041.იმ შემთხვევაში, როდესაც IIF განცხადება გამოიყენება არაერთხელ, უფრო მოსახერხებელია მისი შეცვლა SWITCH განაცხადით. SWITCH ოპერატორი (მრავალჯერადი არჩევანის ოპერატორი) გამოიყენება ლოგიკური გამოხატვის შესაფასებლად და შედეგის მიხედვით მოქმედების შესასრულებლად. შემდეგ მაგალითში, მიწოდებული ლოტი ითვლება "პატარად", თუ ლოტში საქონლის რაოდენობა 500-ზე ნაკლებია. წინააღმდეგ შემთხვევაში, თუ საქონლის რაოდენობა 500-ზე მეტი ან ტოლია, ლოტი ჩაითვლება "დიდი". ":

SELECT dt, product_id, თანხა,

SWITCH (თანხა =500"დიდი") AS ნიშანი
მ_ შემოსავალი;

მოთხოვნა Q042.შემდეგ შეკითხვაში, თუ შემოსულ პარტიაში საქონლის რაოდენობა 300-ზე ნაკლებია, მაშინ პარტია ითვლება „პატარა“. წინააღმდეგ შემთხვევაში, ანუ თუ პირობის ოდენობა SELECT dt, product_id, თანხა,
IIF(ოდენობა IIF(თანხა FROM მ_შემოსავალი;

SQL შეკითხვა Q043.შემდეგ შეკითხვაში, თუ შემოსულ პარტიაში საქონლის რაოდენობა 300-ზე ნაკლებია, მაშინ პარტია ითვლება „პატარა“. წინააღმდეგ შემთხვევაში, ანუ თუ პირობის ოდენობა SELECT dt, product_id, თანხა,
SWITCH (თანხის ოდენობა>=1000"დიდი") AS მარკა
მ_ შემოსავალი;

SQL შეკითხვა Q044.შემდეგ მოთხოვნაში გაყიდვები იყოფა სამ ჯგუფად: მცირე (150-მდე), საშუალო (150-დან 300-მდე), დიდი (300 და მეტი). შემდეგი, თითოეული ჯგუფისთვის, მთლიანი თანხა გამოითვლება:

აირჩიეთ კატეგორია, SUM(outcome_sum) AS Ctgry_Total

FROM (აირჩიეთ თანხა*ფასი როგორც outcome_sum,
IIf(რაოდენობა*ფასი IIf(თანხა*ფასი FROM m_outcome) AS t
ჯგუფი კატეგორიის მიხედვით;

SQL შეკითხვა Q045. DateAdd ფუნქცია გამოიყენება მოცემულ თარიღს დღეების, თვეების ან წლების დასამატებლად და ახალი თარიღის მისაღებად. შემდეგი მოთხოვნა:
1) დაამატეთ თარიღს 30 დღე dt ველიდან და ჩვენება ახალი თარიღიველში dt_plus_30d;
2) დაამატეთ თარიღს 1 თვე dt ველიდან და აჩვენეთ ახალი თარიღი dt_plus_1m ველში:

SELECT dt, dateadd("d",30,dt) AS dt_plus_30d, dateadd("m",1,dt) AS dt_plus_1m

მ_ შემოსავალი;

SQL შეკითხვა Q046. DateDiff ფუნქცია შექმნილია ორ თარიღს შორის განსხვავების გამოსათვლელად სხვადასხვა ერთეულებში (დღეები, თვეები ან წლები). შემდეგი მოთხოვნა ითვლის სხვაობას dt ველში თარიღსა და მიმდინარე თარიღს შორის დღეებში, თვეებში და წლებში:

SELECT dt, DateDiff("d",dt,Date()) AS last_day,

DateDiff("m",dt,Date()) როგორც ბოლო_თვეები,
DateDiff("yyyy",dt,Date()) AS last_years
მ_ შემოსავალი;

SQL შეკითხვა Q047.დღეების რაოდენობა საქონლის მიღების დღიდან (ცხრილი მ_ შემოსავალი) მდე მიმდინარე თარიღი DateDiff ფუნქციის გამოყენებით და ვადის გასვლის თარიღი შედარებულია (ცხრილი m_პროდუქტი):

DateDiff("d",dt,Date()) AS last_days
FROM m_income AS INNER JOIN m_product AS b
ON a.product_id=b.id;

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

აირჩიეთ a.id, product_id, dt, lifedays,

DateDiff("d",dt,თარიღი()) AS ბოლო_დღეები, IIf(ბოლო_დღეები>სიცოცხლის დღეები,"დიახ","არა") AS date_expire
FROM m_შემოსავლიდან INNER JOIN m_product b
ON a.product_id=b.id;

SQL შეკითხვა Q049.გამოითვლება თვეების რაოდენობა საქონლის მიღებიდან მიმდინარე თარიღამდე. სვეტი month_last1 ითვლის თვეების აბსოლუტურ რაოდენობას, სვეტი month_last2 ითვლის სრული თვეების რაოდენობას:

SELECT dt, DateDiff("m",dt,Date()) AS month_last1,

DateDiff("m",dt,თარიღი())-iif(დღე(dt)>დღე(თარიღი()),1,0) როგორც თვე_ბოლო2
მ_ შემოსავალი;

SQL შეკითხვა Q050.ნაჩვენებია კვარტალური ანგარიში 2011 წელს მიღებული საქონლის რაოდენობისა და რაოდენობის შესახებ:

SELECT kvartal, SUM(outcome_sum) AS სულ

FROM (აირჩიეთ თანხა*ფასი AS outcome_sum, თვე(dt) AS m,
SWITCH(m =10.4) AS კვართალი
FROM m_income WHERE წელი(dt)=2011) როგორც t
GROUP BY ბლოკი;

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

SELECT product_id, SUM(in_sum) AS შემოსავალი_sum, SUM(out_sum) AS outcome_sum

FROM (SELECT product_id, თანხა*ფასი in_sum, 0 out_sum
m_შემოსავლიდან
UNION ALL
SELECT product_id, 0 როგორც in_sum, თანხა*ფასი როგორც out_sum
m_შედეგიდან) AS ტ
GROUP BY product_id
HAVING SUM (in_sum)
მოთხოვნა Q052.შეკითხვით დაბრუნებული ხაზების ნუმერაცია ხორციელდება სხვადასხვა გზით. მაგალითად, შეგიძლიათ ხელახლა დანომროთ MS Access-ში მომზადებული მოხსენების სტრიქონები თავად MS Access-ის გამოყენებით. თქვენ ასევე შეგიძლიათ გადანომრვა პროგრამირების ენების გამოყენებით, მაგალითად, VBA ან PHP. თუმცა, ზოგჯერ ეს უნდა გაკეთდეს თავად SQL შეკითხვაში. ასე რომ, შემდეგი მოთხოვნა დანომრავს m_income ცხრილის რიგებს ID ველის მნიშვნელობების ზრდადი თანმიმდევრობის შესაბამისად:

აირჩიეთ COUNT(*) როგორც N, b.id, b.product_id, b.amount, b.price

FROM m_income a INNER JOIN m_income b ON a.id GROUP BY b.id, b.product_id, b.mount, b.price;

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

აირჩიეთ TOP 5, product_id, ჯამი (თანხა*ფასი) როგორც ჯამი

FROM m_შედეგი
GROUP BY product_id
შეკვეთა თანხის მიხედვით (თანხა*ფასი) DESC;

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

SELECT COUNT(*) AS N, b.product_id, b.summa

FROM


FROM m_შედეგი GROUP BY product_id) AS a
შიდა შეერთება
(SELECT product_id, ჯამი(თანხა*ფასი) როგორც ჯამი,
summa*10000000+product_id AS id
FROM m_შედეგი GROUP BY product_id) AS b
ON a.id>=b.id
ჯგუფი b.product_id, b.summa
HAVING COUNT(*)ORDER BY COUNT(*);

მოთხოვნა Q055.შემდეგი SQL მოთხოვნა აჩვენებს მათემატიკური ფუნქციების COS, SIN, TAN, SQRT, ^ და ABS გამოყენებას MS Access SQL-ში:

SELECT (აირჩიეთ რაოდენობა(*) m_income-დან) როგორც N, 3.1415926 როგორც pi, k,

2*pi*(k-1)/N როგორც x, COS(x) როგორც COS_, SIN(x) როგორც SIN_, TAN(x) როგორც TAN_,
SQR(x) როგორც SQRT_, x^3 როგორც "x^3", ABS(x) როგორც ABS_
FROM (SELECT COUNT(*) AS k
FROM m_income AS INNER JOIN m_income AS b ON a.idGROUP BY b.id) t;

SQL შეკითხვა. მაგალითები MS Access-ში. განახლება: 1-10

მოთხოვნა U001.შემდეგი SQL ცვლილების მოთხოვნა ზრდის m_income ცხრილში 3 კოდის მქონე ნივთების ფასებს 10%-ით:

განაახლეთ m_income SET ფასი = ფასი*1.1

WHERE product_id=3;

მოთხოვნა U002.შემდეგი SQL განახლების მოთხოვნა ზრდის m_income ცხრილში ყველა პროდუქტის რაოდენობას 22 ერთეულით, რომელთა სახელები იწყება სიტყვით "კარაქი":

განაახლეთ m_income SET თანხა = თანხა+22

WHERE product_id IN (SELECT id FROM m_product WHERE სათაური LIKE "Oil*");

მოთხოვნა U003.შემდეგი SQL ცვლილების მოთხოვნა m_outcome ცხრილში ამცირებს ყველა საქონლის ფასებს OOO Sladkoe-ს მიერ 2 პროცენტით:

განაახლეთ m_outcome SET ფასი = ფასი*0.98

WHERE product_id IN
(აირჩიეთ a.id FROM m_product a INNER JOIN m_supplier b
ON a.supplier_id=b.id WHERE b.title="OOO"Сладкое"");. !}