sql მოთხოვნა ms წვდომაში. შესავალი

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

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

SELECT select_what FROM select_from;

„რა_აირჩიოთ“ ნაცვლად, ჩვენ უნდა მივუთითოთ ან იმ სვეტის სახელი, რომლის მნიშვნელობების ჩვენება გვინდა, ან მძიმით გამოყოფილი რამდენიმე სვეტის სახელები, ან ვარსკვლავის სიმბოლო (*), რაც ნიშნავს ყველა სვეტის არჩევას. მაგიდა. "from_choose"-ის ნაცვლად, თქვენ უნდა მიუთითოთ ცხრილის სახელი.

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

SELECT * FROM მომხმარებლებისგან;

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

აირჩიეთ id_user მომხმარებლებისგან;

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

აირჩიეთ სახელი, ელფოსტა FROM მომხმარებლებისგან;

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

SELECT * FROM თემებიდან;

ახლა მხოლოდ 4 თემა გვაქვს და თუ არის 100? ვისურვებდი, რომ ისინი გამოჩნდეს, მაგალითად, ანბანურად. ამისათვის არის საკვანძო სიტყვა SQL-ში. შეკვეთამოჰყვება სვეტის სახელი, რომლითაც მოხდება დახარისხება. სინტაქსი შემდეგია:

SELECT სვეტის_სახელი FROM ცხრილის_სახელიდან ORDER BY sort_column_name;

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

ახლა ჩვენი მონაცემები დალაგებულია კლებადობით.

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

შეადარეთ შედეგი წინა მოთხოვნის შედეგს.

ძალიან ხშირად ჩვენ არ გვჭირდება ყველა ინფორმაცია ცხრილიდან. მაგალითად, გვინდა ვიცოდეთ, რომელი თემები შექმნა მომხმარებელმა sveta (id=4). ამისათვის არის საკვანძო სიტყვა SQL-ში. სად, ასეთი მოთხოვნის სინტაქსი ასეთია:

ჩვენი მაგალითისთვის, პირობა არის მომხმარებლის ID, ე.ი. ჩვენ გვინდა მხოლოდ რიგები, რომლებსაც აქვთ 4 id_author სვეტში (მომხმარებლის ID სვეტა):

ან გვინდა ვიცოდეთ ვინ შექმნა თემა "ველოსიპედები":

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

ოპერატორი	აღწერა
= (თანაბარი)	არჩეული მნიშვნელობები უდრის მითითებულს მაგალითი: აირჩიეთ * თემებიდან WHERE id_author=4; შედეგი:
> (მეტი)	არჩეულია მითითებულზე მეტი მნიშვნელობები მაგალითი: აირჩიეთ * თემებიდან WHERE id_author>2; შედეგი:
< (меньше)	არჩეულია მითითებულზე ნაკლები მნიშვნელობები მაგალითი: აირჩიეთ * თემებიდან WHERE id_author შედეგი:
>= (მეტი ან ტოლი)	არჩეულია მითითებულ მნიშვნელობაზე მეტი ან ტოლი მნიშვნელობები. მაგალითი: აირჩიეთ * თემებიდან WHERE id_author>=2; შედეგი:
<= (меньше или равно)	არჩეულია მითითებულ მნიშვნელობაზე ნაკლები ან ტოლი მნიშვნელობები. მაგალითი: აირჩიეთ * თემებიდან WHERE id_author შედეგი:
!= (არა თანაბარი)	არჩეულია მნიშვნელობები, რომლებიც არ უდრის მითითებულს მაგალითი: აირჩიეთ * თემებიდან WHERE id_author!=1; შედეგი:
არ არის NULL	არჩეულია რიგები, რომლებსაც აქვთ მნიშვნელობები მითითებულ ველში მაგალითი: აირჩიეთ * თემებიდან WHERE id_author IS NOT NULL; შედეგი:
არის NULL	არჩეულია რიგები, რომლებსაც არ აქვთ მნიშვნელობა მითითებულ ველში მაგალითი: აირჩიეთ * თემებიდან WHERE id_author IS NULL; შედეგი: ცარიელი ნაკრები - ასეთი სტრიქონები არ არის.
BETWEEN (შორის)	არჩეულია მნიშვნელობები მითითებულ მნიშვნელობებს შორის. მაგალითი: აირჩიეთ * თემებიდან WHERE id_author BETWEEN 1 AND 3; შედეგი:
IN (მნიშვნელობა შეიცავს)	მნიშვნელობები, რომლებიც შეესაბამება მითითებულს მაგალითი: აირჩიეთ * თემებიდან WHERE id_author IN (1, 4); შედეგი:
NOT IN (მნიშვნელობა არ შეიცავს)	არჩეული მნიშვნელობები, გარდა მითითებულისა მაგალითი: აირჩიეთ * თემებიდან WHERE id_author NOT IN (1, 4); შედეგი:
მოწონება (შემთხვევა)	არჩეულია ნიმუშის მნიშვნელობები მაგალითი: SELECT * თემებიდან WHERE topic_name LIKE "vel%"; შედეგი: LIKE ოპერატორის შესაძლო მეტახასიათები ქვემოთ იქნება განხილული.
ᲐᲠ ᲛᲝᲬᲝᲜᲔᲑᲐ	არჩეულია მნიშვნელობები, რომლებიც არ ემთხვევა ნიმუშს მაგალითი: აირჩიეთ * თემებიდან, სადაც თემის_სახელი არ მოსწონს "vel%"; შედეგი:

LIKE ოპერატორის მეტაგმირები

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

ყველაზე გავრცელებული მეტახასიათია % . ეს ნიშნავს ნებისმიერ პერსონაჟს. მაგალითად, თუ გვინდა ვიპოვოთ სიტყვები, რომლებიც იწყება ასოებით "vel", მაშინ დავწერთ LIKE "vel%", ხოლო თუ გვინდა ვიპოვოთ სიტყვები, რომლებიც შეიცავს "club" სიმბოლოებს, მაშინ დავწერთ LIKE "%". კლუბი%". Მაგალითად:

კიდევ ერთი ხშირად გამოყენებული მეტახასიათია _ . %-ისგან განსხვავებით, რომელიც აღნიშნავს რამდენიმე ან საერთოდ არ სიმბოლოს, ხაზგასმული აღნიშნავს ზუსტად ერთ სიმბოლოს. Მაგალითად:

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

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

ეს გაკვეთილი ეხება SQL მოთხოვნებიმონაცემთა ბაზაში VBA წვდომა. ჩვენ შევხედავთ, თუ როგორ ხორციელდება VBA მოთხოვნები მონაცემთა ბაზაში INSERT, UPDATE, DELETE და ასევე ვისწავლით თუ როგორ მივიღოთ კონკრეტული მნიშვნელობა SELECT მოთხოვნიდან.

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

ჩვენ უკვე შევეხეთ SQL სერვერიდან მონაცემების მოპოვების თემას, სადაც დავწერეთ კოდი VBA-ში ამ მონაცემების მისაღებად, მაგალითად, სტატიაში MSSql 2008-დან ტექსტურ ფაილში მონაცემების ატვირთვის შესახებ, ან ცოტა შევეხეთ მასალას. მონაცემთა ატვირთვა წვდომიდან Word-სა და Excel-ის შაბლონიდან. მაგრამ ასე თუ ისე, ჩვენ ეს ზედაპირულად განვიხილეთ და დღეს მე ვთავაზობ ამაზე ცოტა უფრო დეტალურად ვისაუბროთ.

Შენიშვნა! ქვემოთ მოყვანილი ყველა მაგალითი განხილულია Access 2003 ADP პროექტის და MSSql 2008 მონაცემთა ბაზის გამოყენებით.

საწყისი მონაცემები მაგალითებისთვის

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

შექმენით მაგიდა .( NOT NULL, (50) NULL) GO

როგორც ვთქვი, ჩვენ გამოვიყენებთ ADP პროექტს, რომელიც არის კონფიგურირებული MS SQL 2008-თან მუშაობისთვის, რომელშიც შევქმენი ტესტის ფორმა და დავამატე დაწყების ღილაკი წარწერით. "გაიქცე", რომელიც დაგვჭირდება ჩვენი კოდის შესამოწმებლად, ე.ი. ჩვენ დავწერთ ყველა კოდს მოვლენის დამმუშავებელში " ღილაკის დაჭერა».

მონაცემთა ბაზის მოთხოვნები VBA-ში INSERT, Update, DELETE

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

Private Sub start_Click() "გამოაცხადეთ ცვლადი შეკითხვის სტრიქონის შესანახად Dim sql_query როგორც სტრიქონი "ჩაწერეთ მასში საჭირო მოთხოვნა sql_query = "INSERT INTO test_table (id, name_mon) VALUES ("6", "June")" "Execute ის DoCmd-ით RunSQL sql_query End Sub

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

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

ერთი ხაზის წასაშლელად, ჩვენ ვწერთ შემდეგ კოდს.

Private Sub start_Click() "გამოაცხადეთ ცვლადი შეკითხვის სტრიქონის შესანარჩუნებლად Dim sql_query როგორც სტრიქონი "ჩაწერეთ მასში წაშლის მოთხოვნა sql_query = "წაშალე test_table WHERE id = 6" "შეასრულე DoCmd.RunSQL sql_query End Sub

თუ შევამოწმებთ, ვნახავთ, რომ სასურველი ხაზი წაშლილია.

მონაცემების გასაახლებლად, ჩვენ ვწერთ განახლების მოთხოვნას sql_query ცვლადზე, იმედი მაქვს, მნიშვნელობა გასაგებია.

აირჩიეთ მოთხოვნა მონაცემთა ბაზაში VBA-ში

აქ ყველაფერი ცოტა უფრო საინტერესოა, ვიდრე სხვა SQL კონსტრუქციებთან.

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

Private Sub start_Click() "ცვლადების გამოცხადება" მონაცემთა ბაზიდან ჩანაწერების ნაკრებისთვის Dim RS As ADODB.Recordset "Query string Dim sql_query As String "სტრიქონი მთლიანი მონაცემების ჩვენებისთვის შეტყობინებაში Dim str As String "ახალი ობიექტის შექმნა ჩანაწერების ნაკრებისთვის RS = ახალი ADODB .ჩანაწერების ნაკრები "Query string sql_query = "SELECT id, name_mon FROM test_table" "შეასრულეთ მოთხოვნა პროექტის კავშირის მიმდინარე პარამეტრების გამოყენებით შეტყობინების str = str & RS.Fields("id") & "-" & RS. Fields("name_mon") & vbnewline "გადადით შემდეგ ჩანაწერზე RS.MoveNext Wend "გამომავალი შეტყობინების გაგზავნა msgbox str ბოლო ქვე

აქ ჩვენ უკვე ვიყენებთ VBA წვდომის მარყუჟებს ჩვენი ჩანაწერების ნაკრების ყველა მნიშვნელობის გადასატანად.

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

Private Sub start_Click() "ცვლადების გამოცხადება" მონაცემთა ბაზიდან ჩანაწერების ნაკრებისთვის Dim RS As ADODB.Recordset "Query string Dim sql_query As String "სტრიქონი საბოლოო მნიშვნელობის ჩვენებისთვის Dim str როგორც სტრიქონი "ახალი ობიექტის შექმნა ჩანაწერების ნაკრებისთვის RS = ახალი ADODB.Recordset "Query string sql_query = "SELECT name_mon FROM test_table WHERE id = 5" "შეასრულეთ მოთხოვნა პროექტის კავშირის მიმდინარე პარამეტრების გამოყენებით RS.open sql_query, CurrentProject.Connection, adOpenDynamic, adLockOptimistic "Get our valueF. ) msgbox str ბოლოს ქვე

უნივერსალურობისთვის აქ უკვე მივმართეთ არა უჯრედის სახელით, არამედ მისი ინდექსით, ე.ი. 0, რომელიც არის პირველი მნიშვნელობა ჩანაწერების ნაკრები, საბოლოოდ მივიღეთ ღირებულება "მაისი".

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

დღეისთვის სულ ესაა. Წარმატებები!

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

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

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

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 - მინიმალური მნიშვნელობა ეწოდება აგრეგატის ფუნქციებს. ისინი იღებენ მრავალ მნიშვნელობას და დამუშავებისას აბრუნებენ ერთ მნიშვნელობას. ველების ოდენობისა და ფასის ნამრავლის ჯამის გამოთვლის მაგალითი SUM აგრეგატის ფუნქციის გამოყენებით:

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) dt ველიდან თარიღს უმატებს 30 დღეს და აჩვენებს ახალ თარიღს 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.დღეების რაოდენობა საქონლის მიღების დღიდან (ცხრილი m_შემოსავლები) მიმდინარე თარიღამდე გამოითვლება 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"Сладкое"");. !}

ლაბორატორია #1

SQL: RETRIEVE DATA - ბრძანებააირჩიეთ

სამუშაოს მიზანი:

გაეცანით SQL განცხადებებს
ისწავლეთ როგორ შექმნათ მარტივი SQL მოთხოვნები Access-ში SELECT ბრძანების გამოყენებით;

· ოპერატორების გამოყენება IN, BETWEEN, LIKE, IS NULL.

ვარჯიში№1. შექმენით მოთხოვნა SQL რეჟიმში შესარჩევად STUDENTS ცხრილიდან FIRST NAME და LAST NAME ველების ყველა მნიშვნელობის შესარჩევად.

აირჩიეთ სახელი, გვარი

სტუდენტებისგან;

ვარჯიში№2 . შექმენით შერჩეული მოთხოვნა SQL რეჟიმში STUDENTS ცხრილის ყველა სვეტისთვის.

აირჩიეთ *

სტუდენტებისგან;

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

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

[პერსონალური მონაცემებიდან];

დავალება ნომერი 4.შექმენით შერჩევის მოთხოვნა SQL რეჟიმში, რომელიც ირჩევს ყველა სტუდენტის სახელს გვარით ივანოვი, რომლის ინფორმაციაც არის STUDENTS ცხრილში.

აირჩიეთ გვარი, სახელი

სტუდენტებისგან

WHERE გვარი = "ივანოვი";

დავალება ნომერი 5. შექმენით მოთხოვნა შერჩევისთვის SQL რეჟიმში, რათა მიიღოთ სტუდენტების სახელები და გვარები, რომლებიც სწავლობენ UIT-22 ჯგუფში განათლების ბიუჯეტით დაფინანსებულ ფორმაზე.

აირჩიეთ გვარი, სახელი

სტუდენტებისგან

WHERE GROUP="HIT-22" და BUDGET=true;

დავალება ნომერი 6. შექმენით მოთხოვნა SQL რეჟიმში. გამოცდის ჩაბარების ცხრილის ნიმუშისთვის, ინფორმაცია მხოლოდ 4 და 5 კლასების სტუდენტების შესახებ.

აირჩიეთ *

FROM[შეცვლაგამოცდები]

სადკლასიIN (4.5);

დავალება ნომერი 7.შექმენით zanpoc და SQL რეჟიმი იმ სტუდენტების შესახებ ინფორმაციის ნიმუშისთვის, რომლებსაც აქვთ საგამოცდო ნიშანი IOSU საგანში.

აირჩიეთ *

FROM[შეცვლაგამოცდები]

სადITEM=" ISSU"დაკლასიარ არის (4.5);

დავალება ნომერი 8.შექმენით მოთხოვნა SQL რეჟიმში, რათა აირჩიოთ ჩანაწერები იმ ნივთებისთვის, რომელთა საათებია 100-დან 130-მდე.

აირჩიეთ *

FROMITEMS

სადᲣᲧᲣᲠᲔᲑᲡ100-დან 130-მდე;

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

აირჩიეთ *

FROMსტუდენტები

სადგვარიმოწონება"თან*";

დასკვნა:ლაბორატორიული მუშაობის დროს გავეცანით SQL განცხადებებს, ვისწავლეთ მარტივი SQL მოთხოვნების შექმნა Access-ში SELECT ბრძანების გამოყენებით IN, BETWEEN, LIKE ოპერატორების გამოყენებით.

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

აირჩიეთ *
FROM m_product
WHERE id IN (SELECT product_id FROM m_income);

აირჩიეთ *
FROM m_product
WHERE id NOT IN (SELECT product_id FROM 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);

აირჩიეთ განსხვავებული სათაური
FROM m_product
WHERE სათაური LIKE "M*";

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

SELECT dt, product_id, თანხა, ფასი, თანხა*ფასი AS outcome_sum,
შედეგი_ჯამ *0.07 AS მოგება
FROM m_შედეგი;

აირჩიეთ 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;