როგორ შევქმნათ მონაცემთა ბაზა SQL Server გარემოში. SQL - რა არის ეს, რატომ არის საჭირო ენა, ასევე ძირითადი ფუნქციები დამწყებთათვის

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

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

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

ცხრილის_სახელის შექმნა (სვეტის_სახელი1 მონაცემთა_ტიპი სვეტი_ატრიბუტები1, სვეტის_სახელი2 მონაცემთა_ტიპი სვეტი_ატრიბუტები2, ..................................... . ......... სვეტი_სახელიN მონაცემები_ტიპი სვეტი_ატრიბუტებიN, ცხრილი_ატრიბუტები)

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

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

სწორი იდენტიფიკატორების მაგალითები:

მომხმარებლები ტეგს $345 users_accounts "მომხმარებელთა ანგარიშები"

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

უმარტივესი ფორმით, CREATE TABLE ბრძანება უნდა შეიცავდეს მინიმუმ ცხრილის სახელს და სვეტების სახელებსა და ტიპებს.

ცხრილი შეიძლება შეიცავდეს 1-დან 1024 სვეტამდე. თითოეულ სვეტს უნდა ჰქონდეს უნიკალური სახელი მიმდინარე ცხრილში და მინიჭებული იყოს მონაცემთა ტიპი.

მაგალითად, მომხმარებელთა უმარტივესი ცხრილის განსაზღვრა:

CREATE TABLE კლიენტები (ID INT, Age INT, სახელი NVARCHAR(20), გვარი NVARCHAR(20), ელფოსტა VARCHAR(30), ტელეფონი VARCHAR(20))

ამ შემთხვევაში კლიენტების ცხრილში ექვსი სვეტია განსაზღვრული: Id, FirstName, LastName, Age, Email, Phone. პირველი ორი სვეტი წარმოადგენს კლიენტის ID-ს და ასაკს და არის INT ტიპის, რაც ნიშნავს, რომ ისინი შეინახავენ ციფრულ მნიშვნელობებს. შემდეგი ორი სვეტი წარმოადგენს კლიენტის სახელსა და გვარს და არის NVARCHAR(20) ტიპის, რაც ნიშნავს, რომ ისინი წარმოადგენენ UNICODE სტრიქონს არაუმეტეს 20 სიმბოლოსგან. ბოლო ორი სვეტი Email და Phone წარმოადგენს მომხმარებლის ელფოსტას და ტელეფონს და არის VARCHAR(30/20) ტიპის - ისინი ასევე ინახავს სტრიქონს, მაგრამ არა UNICODE კოდირებით.

ცხრილის შექმნა SQL Management Studio-ში

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

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

USE usersdb; CREATE TABLE კლიენტები (Id INT, Age INT, FirstName NVARCHAR(20), LastName NVARCHAR(20), Email VARCHAR(30), Phone VARCHAR(20));

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

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

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

ცხრილების ამოღება

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

ჩამოაგდეს TABLE table1 [, table2, ...]

მაგალითად, მომხმარებელთა ცხრილის წაშლა:

DROP TABLE მომხმარებლები

მაგიდის სახელის გადარქმევა

ცხრილების გადარქმევისთვის გამოიყენეთ სისტემაში შენახული პროცედურა "sp_rename". მაგალითად, Users ცხრილის გადარქმევა UserAccounts-ად usersdb მონაცემთა ბაზაში:

USE usersdb; EXEC sp_rename "Users", "UserAccounts";

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

ძირითადი ცნებები

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

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

ER დიაგრამიდან ტაბულურ მოდელზე გადასვლა

ცხრილის მოდელზე გადასვლის წესები:

1. გადაიყვანეთ ყველა ერთეული ცხრილებად.
2. გადაიყვანეთ ყველა ატრიბუტი სვეტებად, ანუ, თითოეული ერთეულის ატრიბუტი უნდა გამოჩნდეს ცხრილის სვეტის სახელში.
3. გადააკეთეთ უნიკალური იდენტიფიკატორები ძირითად გასაღებებად.
4. გადაიყვანეთ ყველა ურთიერთობა უცხო გასაღებად.
5. შექმენით SQL ცხრილი.

მონაცემთა ბაზის შექმნა

ჯერ უნდა გაუშვათ MySQL სერვერი. მის გასაშვებად გადადით Start მენიუში, შემდეგ პროგრამები, შემდეგ MySQL და MySQL Server, აირჩიეთ MySQL-Command-Line-Client.

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

მონაცემთა ბაზის შექმნა მონაცემთა ბაზის_სახელი.

მონაცემთა ბაზის სახელზე შეზღუდვები შემდეგია:

• სიგრძე 64 სიმბოლომდეა და შეიძლება შეიცავდეს ასოებს, ციფრებს, "" და "" სიმბოლოებს;
• სახელი შეიძლება დაიწყოს რიცხვით, მაგრამ ის უნდა შეიცავდეს ასოებს.

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

სერვერმა უნდა მიუთითოს, რომელ მონაცემთა ბაზასთან დასჭირდება მუშაობა. ამისათვის არის USE განცხადება. ამ ოპერატორს აქვს მარტივი სინტაქსი: USE n მონაცემთა ბაზის_სახელი.

SQL ცხრილის შექმნა

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

SQL Server ცხრილის შექმნა

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

შექმენი ზღაპარი ცხრილის_სახელი,(სვეტის_სახელი1 სახელი _სვეტი2მონაცემთა ტიპი [სვეტის_შეზღუდვა], [ცხრილის_შეზღუდვები]).

ამ ბრძანების სინტაქსი უფრო დეტალურად უნდა იყოს აღწერილი:

• ცხრილის სახელი უნდა იყოს 30 სიმბოლომდე და იწყება ასოთი. დასაშვებია მხოლოდ ანბანური სიმბოლოები, ასოები და სიმბოლოები "_", "$" და "#". ნებადართულია კირიული ანბანის გამოყენება. მნიშვნელოვანია აღინიშნოს, რომ ცხრილების სახელები არ უნდა იყოს იგივე, რაც სხვა ობიექტების სახელები ან მონაცემთა ბაზის სერვერის რეზერვირებული სიტყვები, როგორიცაა სვეტი, ცხრილი, ინდექსი და ა.შ.
• თქვენ უნდა მიუთითოთ მონაცემთა ტიპი თითოეული სვეტისთვის. არსებობს სტანდარტული ნაკრები, რომელსაც უმეტესობა იყენებს. მაგალითად, Char, Varchar, Number, Date, Null type და ა.შ.

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

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

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

• SHOW DATBASES - აჩვენებს ყველა შექმნილ SQL მონაცემთა ბაზას ეკრანზე;
• SHOW TABLES - აჩვენებს ყველა ცხრილის სიას მიმდინარე მონაცემთა ბაზისთვის, რომლებიც არჩეულია USE ბრძანებით;
• აღწერე ცხრილის_სახელი- აჩვენებს ცხრილის ყველა სვეტის აღწერას.
• ALTER TABLE - გაძლევთ საშუალებას შეცვალოთ ცხრილის სტრუქტურა.

ბოლო ბრძანება საშუალებას იძლევა:

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

ამ ბრძანების სინტაქსია: ALTER TABLE ცხრილის_სახელი( | | | | [(ჩართვა | გამორთვა) მუდმივი შეზღუდვის_სახელი ] | }.

არის სხვა ბრძანებები:

• გადარქმევა - ცხრილის სახელის შეცვლა.
• TRUNCATE TABLE - ამოიღებს ცხრილიდან ყველა მწკრივს. ეს ფუნქცია შეიძლება საჭირო გახდეს ცხრილის ხელახლა შევსების აუცილებლობისას, მაგრამ არ არის საჭირო წინა მონაცემების შენახვა.

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

ბრძანების სინტაქსი საკმაოდ მარტივია: DROP TABLE სახელი_მაგიდები.

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

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

სინტაქსი ძალიან მარტივია:

• მაგიდის შექმნა სახელი_მაგიდები[(სვეტის_განმარტება)] AS subquery;
• სვეტის_განმარტება -სვეტების სახელები, მთლიანობის წესები ახლად შექმნილი ცხრილის სვეტებისთვის და ნაგულისხმევი მნიშვნელობები;
• subquery - აბრუნებს სტრიქონებს, რომლებიც უნდა დაემატოს ახალ ცხრილს.

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

დროებითი მაგიდები

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

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

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

დროებითი ცხრილის შექმნის სინტაქსი შეიძლება წარმოდგენილი იყოს შემდეგნაირად: CREATE TABLE სახელი_ მაგიდები,(სახელისვეტი_1მონაცემთა ტიპი [სვეტის_შეზღუდვა], სახელი _სვეტი2მონაცემთა ტიპი [სვეტის_შეზღუდვა], [ცხრილის_შეზღუდვები]).

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

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

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

მაგიდის შექმნის ბრძანება

ცხრილები იქმნება CREATE TABLE ბრძანებით. ეს ბრძანება ქმნის ცარიელ ცხრილს - ცხრილს რიგების გარეშე. მნიშვნელობები შეყვანილია DML INSERT ბრძანების გამოყენებით (იხილეთ თავი 15). CREATE TABLE ბრძანება ძირითადად განსაზღვრავს ცხრილებს კონკრეტული თანმიმდევრობით მითითებული სვეტების სახელების ნაკრების აღწერით. ის ასევე განსაზღვრავს მონაცემთა ტიპებს და სვეტების ზომებს. ყველა ცხრილს უნდა ჰქონდეს მინიმუმ ერთი სვეტი.

CREATE TABLE ბრძანების სინტაქსი: CREATE TABLE ( [()], [()] ...); როგორც მე-2 თავში იყო განხილული, მონაცემთა ტიპები მნიშვნელოვნად განსხვავდება პროგრამის მიხედვით. სტანდარტთან თავსებადობისთვის, მათ ყველამ მაინც უნდა დაუჭიროს მხარი ANSI ტიპის სტანდარტს. იგი აღწერილია დანართ B-ში.

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

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

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

ცხრილები ეკუთვნის მომხმარებელს, რომელმაც შექმნა ისინი და მოცემული მომხმარებლის საკუთრებაში არსებული ყველა ცხრილის სახელები უნდა განსხვავდებოდეს ერთმანეთისგან, ისევე როგორც მოცემული ცხრილის ყველა სვეტის სახელები. ცალკეულ ცხრილებს შეუძლიათ გამოიყენონ იგივე სვეტების სახელები, მაშინაც კი, თუ ისინი ეკუთვნის იმავე მომხმარებელს. ამის მაგალითია ქალაქის სვეტი კლიენტების ცხრილში და გამყიდველების ცხრილში. მომხმარებლებს, რომლებიც არ არიან ცხრილის მფლობელები, შეუძლიათ მიმართონ ამ ცხრილებს ცხრილის მფლობელის სახელის გამოყენებით, რასაც მოჰყვება წერტილი; მაგალითად, სმიტის მიერ შექმნილ Employees ცხრილს დაერქმევა სმიტი. Employees, როდესაც ის მოიხსენიება სხვა მომხმარებლის მიერ (ჩვენ გვესმის, რომ სმიტი არის ნებართვის იდენტიფიკატორი (ID). (ID) მოხსენებული მომხმარებლის მიერ (თქვენი გადაწყვეტილი ID არის თქვენი სახელი SQL-ში ეს გამომავალი განხილულია მე-2 თავში და გაგრძელდება 22-ე თავში.

ეს ბრძანება შექმნის Salespeople ცხრილს: CREATE TABLE Saleepeople (snum integer, sname char (10), city char (10), comm declmal); ცხრილის სვეტების თანმიმდევრობა განისაზღვრება იმ თანმიმდევრობით, რომლითაც ისინი ჩამოთვლილია. სვეტი არ უნდა იყოს გამოყოფილი ხაზის წყვეტით (რაც კეთდება წაკითხვისთვის), არამედ მძიმით.

ინდექსები

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

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

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

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

ინდექსის შექმნის სინტაქსი ჩვეულებრივ შემდეგია (გახსოვდეთ, რომ ეს არ არის ANSI სტანდარტი): CREATE INDEX ჩართულია

( [,]...); ცხრილი, რა თქმა უნდა, უკვე უნდა იყოს შექმნილი და უნდა შეიცავდეს სვეტებს. ინდექსი არ შეიძლება გამოყენებულ იქნას სხვა არაფერი მონაცემთა ბაზაში (ნებისმიერი მომხმარებლის მიერ). შექმნის შემდეგ, ინდექსი მომხმარებლისთვის უხილავი იქნება. SQL თავად წყვეტს, როდის არის საჭირო მასზე მითითება და აკეთებს ამას ავტომატურად. თუ, მაგალითად, მომხმარებელთა ცხრილი იქნება ყველაზე ხშირად მითითებული ცხრილი გამყიდველების მიერ საკუთარი კლიენტების მიმართ შეკითხვებში, მიზანშეწონილი იქნება ასეთი ინდექსის შექმნა კლიენტების ცხრილის snum ველზე.

CREATE INDEX Clientgroup ON კლიენტებზე (snum); ახლა, გამყიდველი, რომელიც ამ მაგიდასთან არის დაკავშირებული, ძალიან სწრაფად შეძლებს საკუთარი კლიენტურის პოვნას.

ინდექსის უნიკალურობა

წინა მაგალითში ინდექსი, საბედნიეროდ, არ არის აუცილებელი იყოს უნიკალური, მიუხედავად ჩვენი დაკვირვებისა, რომ ეს არის ინდექსის ერთ-ერთი მიზანი. მოცემულ გამყიდველს შეიძლება ჰყავდეს ნებისმიერი რაოდენობის მომხმარებელი. თუმცა, ეს არ მოხდება, თუ INDEX საკვანძო სიტყვამდე გამოვიყენებთ UNIQUE საკვანძო სიტყვას. cnum ველი, როგორც პირველადი გასაღები, იქნება პირველი კანდიდატი უნიკალური ინდექსისთვის: CREATE UNIQUE INDEX Custid ON Customers (cnum); შენიშვნა: ეს ბრძანება უარყოფილი იქნება, თუ უკვე არის იდენტური მნიშვნელობები cnum ველში. ინდექსებთან გამკლავების საუკეთესო გზაა მათი შექმნა ცხრილის შექმნისთანავე და რაიმე მნიშვნელობის შეყვანამდე. ასევე გაითვალისწინეთ, რომ ერთზე მეტი სქესის უნიკალური ინდექსისთვის ეს არის მნიშვნელობების კომბინაცია, რომელთაგან თითოეული შეიძლება არ იყოს უნიკალური.

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

ინდექსების წაშლა

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

ALTER TABLE ბრძანება არ არის ANSI სტანდარტის ნაწილი; მაგრამ ეს არის ფართოდ ხელმისაწვდომი და საკმაოდ შინაარსიანი ფორმა, თუმცა მისი შესაძლებლობები გარკვეულწილად შეზღუდულია. იგი გამოიყენება არსებული ცხრილის განმარტების შესაცვლელად. როგორც წესი, ის ამატებს სვეტებს ცხრილს. ზოგჯერ მას შეუძლია წაშალოს ან შეცვალოს სვეტების ზომა, ზოგიერთ პროგრამაში კი შეზღუდვების დამატება ან წაშლა (განხილულია მე-18 თავში). ცხრილის სვეტის დამატების ტიპიური სინტაქსია: ALTER TABLE დამატება ; სვეტს დაემატება NULL მნიშვნელობა ცხრილის ყველა სტრიქონისთვის. ახალი სვეტი გახდება ცხრილის ბოლო სვეტი. ფაქტობრივად, თქვენ შეგიძლიათ დაამატოთ რამდენიმე ახალი სვეტი ერთდროულად, გამოყოფილი მძიმებით, ერთ ბრძანებაში. შესაძლებელია სვეტების წაშლა ან შეცვლა. ყველაზე ხშირად, სვეტის შეცვლა შეიძლება უბრალოდ იყოს მისი ზომის გაზრდა ან შეზღუდვის დამატება/მოხსნა. თქვენმა სისტემამ უნდა უზრუნველყოს, რომ ნებისმიერი ცვლილება არ ეწინააღმდეგებოდეს არსებულ მონაცემებს - მაგალითად, თუ ცდილობთ დაამატოთ შეზღუდვა სვეტში, რომელსაც უკვე ჰქონდა მნიშვნელობა, დარღვევის შემთხვევაში, შეზღუდვა უარყოფილი იქნება. უმჯობესია ეს ორჯერ შეამოწმოთ. ყოველ შემთხვევაში, შეამოწმეთ თქვენი სისტემის დოკუმენტაცია, რათა ნახოთ თუ არა ის გარანტიას, რომ ეს იყო მიზეზი. ALTER TABLE ბრძანების არასტანდარტული ბუნების გამო, თქვენ მაინც უნდა გადახედოთ თქვენი სისტემის დოკუმენტაციის განყოფილებას, რომელიც საუბრობს განსაკუთრებულ შემთხვევებზე.

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

თუ თქვენს სისტემას არ უჭერს მხარს ALTER TABLE-ს, ან თუ გსურთ თავიდან აიცილოთ მისი გამოყენება, შეგიძლიათ უბრალოდ შექმნათ ახალი ცხრილი, შექმნისას აუცილებელი ცვლილებებით და გამოიყენოთ INSERT ბრძანება SELECT * მოთხოვნით, რომ დააკოპიროთ მონაცემები ძველიდან. მაგიდა მასში.

მომხმარებლებს, რომლებსაც მიეცათ წვდომა ძველ ცხრილზე (იხ. თავი 22) უნდა მიეცეთ წვდომა ახალ ცხრილზე.

ცხრილის წაშლა< table name >თქვენ უნდა იყოთ ცხრილის მფლობელი (ანუ შემქმნელი), რომ შეძლოთ მისი წაშლა. ასე რომ, არ ინერვიულოთ თქვენი მონაცემების შემთხვევით განადგურებაზე, SQL ჯერ მოგთხოვთ ცხრილის გასუფთავებას, სანამ ის წაშლის მას მონაცემთა ბაზიდან. ცხრილი მასში რიგებით ვერ წაიშლება. იხილეთ თავი 15 დეტალებისთვის, თუ როგორ უნდა წაშალოთ რიგები ცხრილიდან. თქვენი ცხრილის ჩამოგდების სინტაქსი, თუ რა თქმა უნდა ცარიელია, შემდეგია: DROP TABLE

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

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

რეზიუმე

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

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

SQL-თან მუშაობა

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

3. თუ Order ცხრილი უკვე შექმნილია, როგორ შეიძლება აიძულოთ onum ველი იყოს უნიკალური (თუ ვივარაუდებთ, რომ ყველა მიმდინარე მნიშვნელობა უნიკალურია)?

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

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

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

უპირველეს ყოვლისა!

MS SQL "CREATE TABLE" ბრძანების გამოყენებით ცხრილების შექმნის პროცესის გააზრებამდე, ღირს იმაზე საუბარი, რაც უნდა იცოდეთ ფუნქციის გამოყენებამდე.

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

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

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

სინტაქსი

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

TABLE ცხრილის_სახელის შექმნა
((სვეტის_სახელის მონაცემთა ტიპი …| ცხრილის_შეზღუდვა)
[,(სვეტის_სახელის მონაცემთა ტიპი …| ცხრილის_შეზღუდვა)]…)

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

• table_name - ცხრილის სახელი
• სვეტის_სახელი - სვეტის სახელი
• datatype - ამ ველში გამოყენებული მონაცემთა ტიპი
• DEFAULT არის ნაგულისხმევი გამოხატულება, რომელიც გამოიყენება სვეტში.

ასევე შესაძლებელია კიდევ ორი ​​ფუნქციის არგუმენტის გამოყენება:

• column_constraint - სვეტის პარამეტრები
• table_constraint - ცხრილის პარამეტრები

მათში მომხმარებელს შეუძლია მიუთითოს სამუშაოსთვის საჭირო შეზღუდვები ან ცხრილის შევსების პირობები.

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

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

იმისათვის, რომ დადგინდეს, შეიძლება თუ არა უჯრედი შეიცავდეს ცარიელ მნიშვნელობას, სვეტის სახელისა და ტიპის მითითების შემდეგ უნდა შეიყვანოთ ერთ-ერთი საკვანძო სიტყვა: NULL (შეიძლება იყოს ცარიელი მნიშვნელობები) ან NOT NULL (ველი უნდა იყოს შევსებული).

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

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

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

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

მაგალითები

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

შექმენით მაგიდა მორგებული
(ID CHAR(10) NOT NULL ძირითადი გასაღები,
მორგებული_სახელი CHAR(20),
Custom_address CHAR(30),
Custom_city CHAR(20),
Custom_Country CHAR(20),
ArcDate CHAR(20))

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

რაიმე შეკითხვა?

სახელი

ელფოსტა *

შეტყობინება *

გაგზავნა

შეატყობინეთ შეცდომას

ტექსტი, რომელიც გაეგზავნება ჩვენს რედაქტორებს:

თქვენი კომენტარი (სურვილისამებრ):

გაგზავნა გაუქმება