მთლიანობის შეზღუდვების განმარტება. ელემენტის გამოყენების მაგალითები. როგორ შეიძლება რეალურმა მონაცემებმა დაგაყენონ მარცხისთვის
მონაცემთა ბაზის დიზაინის პროცესში მიიღება გადაწყვეტილებები იმის შესახებ, თუ რომელი ცხრილები უნდა იყოს შეტანილი მონაცემთა ბაზაში, რა სახელები ექნებათ მათ (იდენტიფიკატორები), რა ტიპის მონაცემები იქნება საჭირო ცხრილების ასაგებად და რომელ მომხმარებლებს ექნებათ წვდომა თითოეულ მათგანზე. . გარდა ამისა, ცხრილების ეფექტურად შესაქმნელად, თქვენ უნდა უპასუხოთ შემდეგ კითხვებს:
- რა ტიპის და ზომის სვეტები შეადგენენ თითოეულ ცხრილს და რა სახელები უნდა აირჩიოთ ცხრილის სვეტებისთვის?
- რომელი სვეტები შეიძლება შეიცავდეს NULL მნიშვნელობას?
- გამოყენებული იქნება ისინი? მთლიანობის შეზღუდვები, ნაგულისხმევი მნიშვნელობები და წესები სვეტებისთვის?
- აუცილებელია თუ არა სვეტების ინდექსირება, რა ტიპის ინდექსები იქნება გამოყენებული კონკრეტულ სვეტებზე?
- რომელი სვეტები შედის ძირითად და უცხო კლავიშებში.
MS SQL Server-ის გარემოში ცხრილების შესაქმნელად გამოიყენეთ ბრძანება:
<определение_таблицы>::= ცხრილის შექმნა [ბაზის_სახელი.[მფლობელი].<элемент_таблицы>| მფლობელი. ]მაგიდის_სახელი (
<элемент_таблицы> ::= {<определение_столбца>} | <имя_столбца>[,...n])<выражение> | <ограничение_таблицы>
ას
<Выражение>როგორც წესი, ცხრილის (dbo) მფლობელი არის ის, ვინც შექმნა იგი. ადგენს მნიშვნელობას. გამოთვლილი სვეტიგამოთვლილი სვეტები ადგენს მნიშვნელობას- ეს არის ვირტუალური სვეტები, ანუ ისინი ფიზიკურად არ ინახება ცხრილში და გამოითვლება იმავე ცხრილის სვეტების მნიშვნელობების გამოყენებით. გამოთქმაში გამოთვლილი სვეტიშეიძლება იყოს რეგულარული სვეტების სახელები, მუდმივები და ფუნქციები, რომლებიც შეკრულია ერთი ან მეტი ოპერატორით. ქვემოთხოვნებს არ შეუძლიათ მონაწილეობა მიიღონ ასეთ გამოხატვაში. გამოთვლილი სვეტიშეიძლება შევიდეს SELECT პუნქტში, როდესაც მითითებულია სვეტების სია, რომლებიც უნდა დაბრუნდეს მოთხოვნის შედეგად. არ შეიძლება ჩაერთოს უცხოურ გასაღებში, მათთვის ნაგულისხმევი მნიშვნელობები არ გამოიყენება. გარდა ამისა,გამოთვლილი სვეტები
<определение_столбца>ვერ მიიღებს მონაწილეობას INSERT და DELETE ოპერაციებში.<тип_данных>::= (სვეტის_სახელი<выражение>) [ [ ნაგულისხმევი<ограничение_столбца>] | [ IDENTITY (დაწყება, ნაბიჯი) ]]] [
][...n]] სვეტის განმარტებაში ყურადღება მიაქციეთ IDENTITY პარამეტრს, რომელიც მიუთითებს, რომ შესაბამისი სვეტი იქნება. ამ თვისებით მხოლოდ ერთი სვეტი შეიძლება განისაზღვროს თითო ცხრილზე. თქვენ შეგიძლიათ დამატებით მიუთითოთ საწყისი მნიშვნელობა და გაზრდის ნაბიჯი. თუ ეს მნიშვნელობები არ არის მითითებული, ორივე ნაგულისხმევად არის 1. თუ NOT FOR REPLICATION მითითებულია IDENTITY საკვანძო სიტყვით, სერვერი ავტომატურად არ გამოიმუშავებს მნიშვნელობებს ამ სვეტისთვის, მაგრამ დაუშვებს თვითნებური მნიშვნელობების ჩასმას. სვეტი.
გამოყენებული შეზღუდვები არის სვეტის შეზღუდვებიდა მაგიდის შეზღუდვები. განსხვავება მათ შორის არის ის სვეტის შეზღუდვავრცელდება მხოლოდ კონკრეტულ სფეროზე და მაგიდის შეზღუდვა- ერთი ან მეტი ველის ჯგუფებში.
<ограничение_столбца>::= [ შეზღუდვის შეზღუდვის სახელი ] ( [ NULL | NOT NULL ] | [ (პირველადი გასაღები | უნიკალური ) [ დაჯგუფებული | არაკლასტერირებული ] [ FILLFACTOR=fillfactor ] [ ჩართულია (ფაილის ჯგუფის სახელი | ნაგულისხმევი ) [REFE ]] FORE NCES | ცხრილის_სახელი [(სვეტის_სახელი_ცხრილის_გენი) ] [ ჩართულია წაშლაზე ( კასკადის გარეშე | მოქმედების გარეშე ) ] [ განახლებისას ( კასკადი<лог_выражение>) } <ограничение_таблицы>::= ( [ (პირველადი გასაღები | უნიკალური ) [ დაჯგუფებული | არაკლასტერირებული ] ((სვეტის_სახელი [,...n])) ] |უცხო გასაღები[(სვეტის_სახელი [,...n])] წყაროები ცხრილის_სახელი [(სვეტის_სახელი ცხრილის_გენი [ ,...n]] [წაშლაზე (კასკადის გარეშე | მოქმედების გარეშე) ] [განახლების შესახებ (CASCADE | NO ACTION)] |
განვიხილოთ წარმოდგენილი სტრუქტურების ინდივიდუალური პარამეტრები, რომლებიც დაკავშირებულია შეზღუდვებთან მონაცემთა მთლიანობა. მთლიანობის შეზღუდვებიუპირატესობა ენიჭება ტრიგერებს, წესებსა და ნაგულისხმევს. TO მთლიანობის შეზღუდვებიმოიცავს ძირითადი გასაღების შეზღუდვაძირითადი გასაღები საგარეო გასაღების შეზღუდვაუცხო გასაღები, უნიკალური შეზღუდვა, NULL შეზღუდვა, CHECK შეზღუდვა.
ძირითადი გასაღების შეზღუდვა (PRIMARY KEY)
ცხრილს, როგორც წესი, აქვს სვეტი ან სვეტების კომბინაცია, რომელთა მნიშვნელობები ცალსახად იდენტიფიცირებს ცხრილის თითოეულ მწკრივს. ამ სვეტს (ან სვეტებს) ე.წ პირველადი გასაღებიმაგიდა და საჭიროა მისი მთლიანობის უზრუნველსაყოფად. თუ პირველადი გასაღები შეიცავს ერთზე მეტ სვეტს, მაშინ ერთი სვეტის მნიშვნელობები შეიძლება იყოს დუბლირებული, მაგრამ ყველა სვეტის მნიშვნელობების ნებისმიერი კომბინაცია. პირველადი გასაღებიუნდა იყოს უნიკალური.
შექმნისას პირველადი გასაღები SQL Server ავტომატურად ქმნის უნიკალურ ინდექსს სვეტებზე, რომლებიც ძირითადი გასაღების ნაწილია. ის აჩქარებს ამ სვეტების მონაცემებზე წვდომას გამოყენებისას პირველადი გასაღებიმოთხოვნებში.
ცხრილს შეიძლება ჰქონდეს მხოლოდ ერთი PRIMARY KEY შეზღუდვა და არცერთი სვეტი, რომელიც შედის ძირითად გასაღებში, არ შეიძლება იყოს NULL. როდესაც ცდილობთ მის გამოყენებას როგორც პირველადი გასაღებისვეტი (ან სვეტების ჯგუფი), რომლისთვისაც ძირითადი გასაღების შეზღუდვებიარ არის შესრულებული, პირველადი გასაღები არ შეიქმნება და სისტემა აჩვენებს შეცდომის შეტყობინებას.
იმის გამო, რომ PRIMARY KEY შეზღუდვა უზრუნველყოფს მონაცემთა უნიკალურობას, ის ხშირად განისაზღვრება მრიცხველის სვეტები. შემოქმედება მთლიანობის შეზღუდვები PRIMARY KEY შესაძლებელია როგორც შექმნისას, ასევე როდის მაგიდის შეცვლა. ერთ-ერთი დანიშვნა პირველადი გასაღებიარის დებულება რეფერენციული მთლიანობამონაცემები რამდენიმე ცხრილიდან. ბუნებრივია, ამის განხორციელება შესაძლებელია მხოლოდ სხვა ცხრილებში შესაბამისი უცხოური გასაღებების განსაზღვრით.
საგარეო საკვანძო შეზღუდვა
საგარეო გასაღების შეზღუდვაშენარჩუნების მთავარი მექანიზმია რეფერენციული მთლიანობაცხრილებს შორის ურთიერთობით მონაცემთა ბაზაში. FOREIGN KEY პარამეტრში უცხო გასაღების სახით მითითებული შვილობილი ცხრილის სვეტი გამოიყენება მასში არსებული ცხრილის მშობელი სვეტის მითითებისთვის. პირველადი გასაღები. მშობელი ცხრილის სახელი და მისი სვეტები პირველადი გასაღებიმითითებულია REFERENCES პუნქტში. უცხო გასაღების სახით განსაზღვრულ სვეტებში მონაცემებს შეიძლება ჰქონდეს მხოლოდ იგივე მნიშვნელობები, რაც მასთან დაკავშირებულ სვეტებში პირველადი გასაღებიმშობლის მაგიდა. არ არის აუცილებელი, რომ სვეტების სახელები ემთხვეოდეს ბავშვისა და მშობლის ცხრილების დასაკავშირებლად. პირველადი გასაღები შეიძლება განისაზღვროს ერთი სახელის მქონე სვეტზე, ხოლო სვეტს, რომელიც ექვემდებარება FOREIGN KEY შეზღუდვას, შეიძლება ჰქონდეს სრულიად განსხვავებული სახელი. ერთადერთი მოთხოვნაა, რომ სვეტები შეესაბამებოდეს მონაცემთა ტიპს და ზომას.
პირველადი გასაღების მითითება შესაძლებელია არა მხოლოდ სხვა ცხრილების სვეტებით, არამედ იმავე ცხრილში განთავსებული სვეტებით, როგორც თავად პირველადი გასაღები; ეს საშუალებას გაძლევთ შექმნათ რეკურსიული სტრუქტურები.
უცხო გასაღები შეიძლება იყოს დაკავშირებული არა მხოლოდ პირველადი გასაღებისხვა მაგიდა. ის შეიძლება განისაზღვროს მეორე ცხრილის ან ნებისმიერი სხვა სვეტისთვის UNIQUE სვეტებისთვის, მაგრამ ცხრილები უნდა იყოს იმავე მონაცემთა ბაზაში.
უცხო გასაღების სვეტები შეიძლება შეიცავდეს NULL მნიშვნელობას, მაგრამ FOREIGN KEY შეზღუდვის შემოწმება იგნორირებულია. უცხოური გასაღების ინდექსირება შესაძლებელია, შემდეგ სერვერი უფრო სწრაფად იპოვის საჭირო მონაცემებს. უცხოური გასაღები განისაზღვრება როგორც შექმნისას, ასევე დროს მაგიდების შეცვლა.
შეზღუდვა რეფერენციული მთლიანობაგანსაზღვრავს მოთხოვნას, რომ ბავშვის ცხრილის ყველა ჩანაწერისთვის უნდა იყოს ჩანაწერი მშობლის ცხრილში. ამ შემთხვევაში, დაბლოკილია ურთიერთობის სვეტის მნიშვნელობის შეცვლა მშობლის ცხრილის ჩანაწერში ბავშვის ჩანაწერის თანდასწრებით, ასევე მშობლის ჩანაწერის წაშლა (კასკადური ცვლილებებისა და წაშლის აკრძალვა), რაც გარანტირებულია ნაგულისხმევად. ON DELETE NO ACTION და ON UPDATE NO ACTION პარამეტრები. კასკადური ეფექტების ჩასართავად გამოიყენეთ ON DELETE CASCADE და ON UPDATE CASCADE პარამეტრები.
(? ნიშანი მიუთითებს, რომ ელემენტი შეიძლება გამოჩნდეს ნულოვანი ან ერთხელ, * ნიშანი მიუთითებს, რომ ელემენტი შეიძლება გამოჩნდეს ნულამდე, ერთ ან მეტჯერ ელემენტში. ელემენტი.)
ატრიბუტები
| ატრიბუტი | აღწერა |
|---|---|
| id | არ არის საჭირო. განსაზღვრავს ელემენტის უნიკალურ იდენტიფიკატორს |
| სახელი | არ არის საჭირო. განსაზღვრავს ელემენტის სახელს. ეს ატრიბუტი საჭიროა, თუ მშობელი ელემენტი არის სქემის ელემენტი |
| ref | არ არის საჭირო. ეხება სხვა ელემენტის სახელს. ref ატრიბუტი შეიძლება შეიცავდეს სახელთა სივრცის პრეფიქსს. ამ ატრიბუტის გამოყენება შეუძლებელია, თუ მშობელი ელემენტი სქემის ელემენტია |
| ტიპი | არ არის საჭირო. განსაზღვრავს ან ჩაშენებული მონაცემთა ტიპის სახელს, ან simpleType ან complexType ელემენტის სახელს |
| ჩანაცვლების ჯგუფი | არ არის საჭირო. განსაზღვრავს ელემენტის სახელს, რომელიც შეიძლება შეიცვალოს ამ ელემენტით. ამ ატრიბუტის გამოყენება შეუძლებელია, თუ მშობელი ელემენტი არ არის სქემის ელემენტი |
| ნაგულისხმევი | არ არის საჭირო. განსაზღვრავს ელემენტის ნაგულისხმევ მნიშვნელობას (გამოყენება შესაძლებელია მხოლოდ იმ შემთხვევაში, თუ ელემენტის შინაარსი მარტივი ტიპის ან ტექსტია) |
| დაფიქსირდა | არ არის საჭირო. განსაზღვრავს ელემენტის ფიქსირებულ მნიშვნელობას (გამოყენება შესაძლებელია მხოლოდ იმ შემთხვევაში, თუ ელემენტის შინაარსი მარტივი ტიპის ან ტექსტია) |
| ფორმა | არ არის საჭირო. განსაზღვრავს ელემენტის ფორმას. მნიშვნელობა "კვალიფიცირებული" მიუთითებს, რომ ეს ელემენტი უნდა იყოს კვალიფიცირებული სახელთა სივრცის პრეფიქსით. მნიშვნელობა "არაკვალიფიციური" მიუთითებს, რომ ეს ელემენტი არ საჭიროებს კვალიფიკაციას სახელთა სივრცის პრეფიქსით. ნაგულისხმევი მნიშვნელობა არის სქემის ელემენტის ატრიბუტის elementFormDefault ატრიბუტის მნიშვნელობა. ამ ატრიბუტის გამოყენება შეუძლებელია, თუ მშობელი ელემენტი არის სქემის ელემენტი |
| maxOccurs | არ არის საჭირო. განსაზღვრავს რამდენჯერ შეიძლება ელემენტი გამოჩნდეს მშობელ ელემენტში. მნიშვნელობა შეიძლება იყოს ნებისმიერი მთელი რიცხვი >= 0, მაგრამ თუ თქვენ გჭირდებათ მოხმარების ლიმიტის მოხსნა, უნდა მიუთითოთ საკვანძო სიტყვა "უსაზღვრო". ნაგულისხმევი მნიშვნელობა არის 1. ამ ატრიბუტის გამოყენება შეუძლებელია, თუ მთავარი ელემენტი არის სქემის ელემენტი |
| მცირე ხდება | არ არის საჭირო. განსაზღვრავს რამდენჯერაც ელემენტი შეიძლება გამოჩნდეს მშობელ ელემენტში. მნიშვნელობა შეიძლება იყოს ნებისმიერი მთელი რიცხვი >= 0. ნაგულისხმევი მნიშვნელობა არის 1. ამ ატრიბუტის გამოყენება შეუძლებელია, თუ მშობელი ელემენტი არის სქემის ელემენტი. |
| გაცამტვერებადი | არ არის საჭირო. ადგენს, შეიძლება თუ არა ელემენტს მიენიჭოს გამოკვეთილი ნულოვანი მნიშვნელობა ნული. მნიშვნელობა true საშუალებას აძლევს ელემენტს დააყენოს nil ატრიბუტი true. nil ატრიბუტი განისაზღვრება, როგორც XML სქემის სახელთა სივრცის ნაწილი. ნაგულისხმევი მნიშვნელობა მცდარია |
| აბსტრაქტული | არ არის საჭირო. ადგენს შესაძლებელია თუ არა ამ ელემენტის გამოყენება დოკუმენტში. მნიშვნელობა true მიუთითებს, რომ ელემენტის გამოყენება შეუძლებელია დოკუმენტში. ამის ნაცვლად, ამ ელემენტის ნაცვლად სხვა ელემენტი უნდა გამოჩნდეს, რომლის substitutionGroup ატრიბუტი შეიცავს ამ ელემენტის პრეფიქსის სახელს (QName). ნაგულისხმევი მნიშვნელობა მცდარია |
| ბლოკი | არ არის საჭირო. ხელს უშლის ელემენტს, რომელსაც აქვს მითითებული მემკვიდრეობის ტიპი მოცემული ელემენტის ნაცვლად. შეუძლია მიიღოს მნიშვნელობა #ყველა ან გაფართოებების/შეზღუდვების/ჩანაცვლების სია:
|
| საბოლოო | არ არის საჭირო. გამორთავს მითითებული ელემენტების მემკვიდრეობის მეთოდს. შეუძლია მიიღოს მნიშვნელობა #all ან გაფართოებების/შეზღუდვების ჩამონათვალი:
|
| ნებისმიერი ატრიბუტი | არ არის საჭირო. ნებისმიერი სხვა ატრიბუტი სქემის სახელთა სივრცის გარეთ |
ელემენტის გამოყენების მაგალითები
მაგალითი No1
შემდეგი მაგალითი აცხადებს XML სქემას ოთხი მარტივი ელემენტით "fname", "lname", "age" და "dateborn":
მაგალითი No2
შემდეგი მაგალითი აცხადებს XML სქემას რთული ტიპის "note" ელემენტით. "შენიშვნა" ელემენტი შეიცავს ოთხ მარტივ ელემენტს - "to", "from", "head" და "body":
მაგალითი No3
შემდეგი მაგალითი მსგავსია მაგალითი No2. ერთადერთი განსხვავება ისაა, რომ ref ატრიბუტი გამოიყენება ელემენტების სახელების მითითებისთვის:
ელემენტი გასაღებიგანსაზღვრავს ატრიბუტის ან ელემენტის მნიშვნელობას, როგორც გასაღების (არანულო, უნიკალური და ყოველთვის არსებული) გენერირებული დოკუმენტის შემცველ ელემენტში. ელემენტს აქვს შემდეგი ფორმატი:
< პრეფიქსი: გასაღები
id = ID
სახელი = NCName
(ანოტაცია?, (სელექტორი, ველი+ ))
პრეფიქსი: გასაღები>
ატრიბუტები idდა სახელიუნიკალური.
გასაღები, სელექტორიდაველი:
xs: გასაღები>
ამ მაგალითში ველები " გვარი" და " გვარი" გამოიყენება როგორც გასაღები სახელით სრული სახელი.
ელემენტი გასაღებიგანსაზღვრავს, რომ ატრიბუტის ან ელემენტის მნიშვნელობა ემთხვევა მითითებული გასაღების ან უნიკალური ელემენტის მნიშვნელობებს და აქვს შემდეგი ფორმატი:
< პრეფიქსი: გასაღები
id = ID
სახელი = NCName
მიმართეთ = QName
(ანოტაცია?, (სელექტორი, ველი+))
პრეფიქსი:გასაღები>
ატრიბუტები idდა სახელიაქვს იგივე მნიშვნელობა, რაც ელემენტს უნიკალურიდა საჭირო ატრიბუტი მიმართეთგანსაზღვრავს ამა თუ სხვა სქემაში განსაზღვრული გასაღების ან უნიკალური ელემენტის სახელს.
ელემენტების გამოყენების მაგალითიგასაღები, სელექტორიდაველი:
ამ მაგალითში ველები "@ პირველი" და "@ ბოლო" შეესაბამება ზემოთ დასახელებული ელემენტის საკვანძო მნიშვნელობებს სრული სახელი.
4.2.9. რთული ტიპის განსაზღვრა Xml სქემაში
რთული ელემენტის ტიპი კომპლექსური ტიპიარის XML ელემენტი, რომელიც შეიცავს სხვა ელემენტებს და/ან ატრიბუტებს. არსებობს ოთხი ტიპის რთული ელემენტები:
ცარიელი ელემენტები;
4.2.9.1. complexType ელემენტის განსაზღვრის ფორმატი
რთული ტიპის განმარტებას აქვს შემდეგი ფორმატი:
< პრეფიქსი: კომპლექსური ტიპი
სახელი = NCName
id = ID
აბსტრაქტული = ლოგიკური : ყალბი
შერეული = ლოგიკური : ყალბი
ბლოკი =(#ყველა| სია(გაფართოება| შეზღუდვა))
საბოლოო =(#ყველა|სია(გაფართოება|შეზღუდვა))
(ანოტაცია?, (მარტივი შინაარსი | კომპლექსური შინაარსი |
((თანმიმდევრობა | ჯგუფი | ყველა | არჩევანი)?,
((ატრიბუტი | ატრიბუტის ჯგუფი)*, ნებისმიერი ატრიბუტი?))))
პრეფიქსი: complexType>
ატრიბუტები სახელიდა idელემენტში კომპლექსური ტიპიაქვთ იგივე მნიშვნელობა, რაც ელემენტში ატრიბუტიდა ატრიბუტები აბსტრაქტული, ბლოკიდა საბოლოო- იგივე მნიშვნელობა, რაც ელემენტში ელემენტი. ატრიბუტი შერეულიგანსაზღვრავს, შეიძლება თუ არა გამოჩნდეს სიმბოლოების მონაცემები რთული ტიპის განსაზღვრის ბავშვებს შორის.
როგორც ხედავთ რთული ტიპის განსაზღვრებიდან, ამ ელემენტს შეიძლება ჰქონდეს შინაარსის ერთ-ერთი შემდეგი ვარიანტი:
ელემენტი მარტივი შინაარსი;
ელემენტი კომპლექსური შინაარსი;
ერთ-ერთი ელემენტი ჯგუფი, ყველა, არჩევანიან თანმიმდევრობა(0 ან 1 ჯერ), ერთ-ერთი ელემენტი ატრიბუტი ან ატრიბუტის ჯგუფი(0 ან მეტჯერ) და ელემენტი ნებისმიერი ატრიბუტი(0 ან 1 ჯერ).
განვიხილოთ ელემენტის შვილები კომპლექსური ტიპი.
4.2.9.2. თანმიმდევრობა, ნებისმიერი, არჩევანი, ყველა და ჯგუფის ელემენტები
ელემენტი თანმიმდევრობაგანსაზღვრავს, რომ მოცემული ელემენტის შვილობილი ელემენტები უნდა გამოჩნდეს მითითებული თანმიმდევრობით და აქვს შემდეგი ფორმატი:
< პრეფიქსი: თანმიმდევრობა
id = ID
maxOccurs = (არაუარყოფითი მთელი რიცხვი | შეუზღუდავი) : 1
მცირე ხდება = არაუარყოფითი მთელი რიცხვი : 1
(ანოტაცია?, (ელემენტი | ჯგუფი | არჩევანი | თანმიმდევრობა | ნებისმიერი)*)
პრეფიქსი: თანმიმდევრობა>
არჩევითი ატრიბუტი idmaxOccursდა მცირე ხდებადააყენეთ მაქსიმალური და მინიმალური მნიშვნელობები, რამდენჯერაც მოცემული თანმიმდევრობა შედის მშობელ ელემენტში.
მაგალითიგამოყენებაელემენტითანმიმდევრობა:
xs: ელემენტი>
მაგალითი განსაზღვრავს ელემენტს სახელად personinfo(თანამშრომლის დეტალები). ეს ელემენტი შეიცავს საბავშვო ელემენტებს სახელიდა გვარი, ისევე როგორც ელემენტების თანმიმდევრობა ბავშვი(ბავშვი) - ეს თანმიმდევრობა შეიძლება არ იყოს ან შეიცავდეს შეუზღუდავი რაოდენობის ელემენტებს ბავშვი.
როგორც ელემენტის დეკლარაციადან ჩანს თანმიმდევრობა, ამ ელემენტის შიგთავსი შეიძლება დაყენდეს ბავშვურ ელემენტად ნებისმიერი.
< პრეფიქსი: ნებისმიერი
id = ID
maxOccurs = (არაუარყოფითი მთელი რიცხვი | შეუზღუდავი) : 1
მცირე ხდება = არაუარყოფითი მთელი რიცხვი : 1
ეს ელემენტი საშუალებას გაძლევთ გააფართოვოთ XML დოკუმენტი ელემენტებით, რომლებიც არ არის განსაზღვრული სქემაში და აქვს შემდეგი ფორმატი: ((სახელთა სივრცე =| ##ნებისმიერი) | სია (##სხვა |
(ნებისმიერი URI| ##targetNamespace))) : სახელთა სივრცე =
##ადგილობრივი (პროცესის შინაარსი =| მკაცრი| მოდუნებული) : პროცესის შინაარსი =
(ანოტაცია?)
პრეფიქსი: ნებისმიერი>
არჩევითი ატრიბუტი idგამოტოვება maxOccursდა მცირე ხდებაგანსაზღვრავს ელემენტის უნიკალურ იდენტიფიკატორს და არჩევით ატრიბუტებს ნებისმიერიდააყენეთ მაქსიმალური და მინიმალური მნიშვნელობები ელემენტების ჩართვის რაოდენობისთვის მშობელ ელემენტს. არჩევითი ატრიბუტისახელთა სივრცე
## ნებისმიერიგანსაზღვრავს სახელთა სივრცეებს, რომლებიც შეიცავს ელემენტებს, რომლებიც შეიძლება გამოყენებულ იქნას მშობელ ელემენტში და შეიძლება ჰქონდეს ერთ-ერთი შემდეგი მნიშვნელობა:
## – ელემენტები ნებისმიერი სახელების სივრციდან დაშვებულია;სხვა
## – შეიძლება იყოს ელემენტები ნებისმიერი სახელთა სივრციდან, გარდა ძირითადი ელემენტისთვის მითითებული სახელთა სივრცისა;ადგილობრივი
## - ელემენტები უნდა იყოს მითითებული არა სახელთა სივრციდან;სამიზნესახელთა სივრცე
სია(##სხვა| (## – შეიძლება იყოს ელემენტები მშობელი ელემენტისთვის მითითებული სახელთა სივრციდან;|## – შეიძლება იყოს ელემენტები ნებისმიერი სახელთა სივრციდან, გარდა ძირითადი ელემენტისთვის მითითებული სახელთა სივრცისა;სამიზნე სახელების სივრცე
არჩევითი ატრიბუტი ))) – შეიძლება იყოს ელემენტები მოცემული სიიდან.პროცესის შინაარსი ნებისმიერიგანსაზღვრავს, თუ როგორ უნდა გაუმკლავდეს XML პროცესორს ამ ელემენტით განსაზღვრულ ელემენტებს
პროცესის შინაარსი =და შეიძლება ჰქონდეს ერთ-ერთი შემდეგი მნიშვნელობა:
მკაცრი– XML პროცესორმა უნდა მიიღოს საჭირო სახელთა სივრცის სქემა და შეამოწმოს ელემენტების ვალიდობა; პროცესის შინაარსი =- მსგავსი
მოდუნებული, მაგრამ თუ სქემის მიღება შეუძლებელია, შეცდომის შეტყობინება არ გენერირებულია;
ნებისმიერი:
< xs: ელემენტისახელი=" – XML პროცესორი გამოტოვებს ელემენტის მოქმედების შემოწმებას.">
xs: კომპლექსური ტიპი>
xs: ელემენტი>
პირი ნებისმიერიელემენტის გამოყენებით – XML პროცესორი გამოტოვებს ელემენტის მოქმედების შემოწმებას.შეგიძლიათ გააფართოვოთ ელემენტის შინაარსი გვარი(ელემენტის შემდეგ
ელემენტი არჩევანი) ნებისმიერი სხვა ელემენტი.
< პრეფიქსი: არჩევანი
id = ID
maxOccurs = (არაუარყოფითი მთელი რიცხვი | შეუზღუდავი) : 1
მცირე ხდება = არაუარყოფითი მთელი რიცხვი : 1
(ანოტაცია?, (ელემენტი | ჯგუფი | არჩევანი | თანმიმდევრობა | ნებისმიერი)*)
პრეფიქსი: არჩევანი>
არჩევითი ატრიბუტი idგამოტოვება maxOccursდა მცირე ხდებასაშუალებას აძლევს სიაში არსებული მხოლოდ ერთი ელემენტის მითითებას მშობელ ელემენტში და აქვს შემდეგი ფორმატი:
მაგალითიგამოყენებაელემენტიდააყენეთ მაქსიმალური და მინიმალური მნიშვნელობები რამდენჯერაც არჩეული ელემენტი შედის მის მთავარ ელემენტში.
< / არჩევანი:
ელემენტი – XML პროცესორი გამოტოვებს ელემენტის მოქმედების შემოწმებას. xs:element> უნდა შეიცავდეს ერთ-ერთ ადრე აღწერილი ელემენტს:თანამშრომელი (მუდმივი თანამშრომელი) ანთავისუფალი
ელემენტი ყველა(კონტრაქტორი).
< პრეფიქსი: ყველა
id = ID
maxOccurs = 1 : 1
მცირე ხდება = (0 | 1 ) : 1
(ანოტაცია?, ელემენტი*)
პრეფიქსი: ყველა>
არჩევითი ატრიბუტი idმიუთითებს, რომ მასში შემავალი ელემენტები შეიძლება გამოჩნდეს მშობელ ელემენტში ნებისმიერი თანმიმდევრობით და თითოეული ელემენტი შეიძლება გამოჩნდეს 0 ან 1 ჯერ. ელემენტს აქვს შემდეგი ფორმატი: maxOccursგანსაზღვრავს ელემენტის უნიკალურ იდენტიფიკატორს. არჩევითი ატრიბუტი მცირე ხდებაადგენს მინიმალურ მნიშვნელობას რამდენჯერაც არჩეული ელემენტი შედის მის მთავარ ელემენტში ( 0 ან 1 ).
ელემენტის გამოყენების მაგალითიყველა:
< xs: ელემენტისახელი=" – XML პროცესორი გამოტოვებს ელემენტის მოქმედების შემოწმებას.">
ელემენტები სახელიდა გვარიშეიძლება გამოჩნდეს ელემენტში ელემენტში – XML პროცესორი გამოტოვებს ელემენტის მოქმედების შემოწმებას.ნებისმიერი თანმიმდევრობით და შეიძლება აკლდეს ერთი ან ორივე ელემენტი.
ელემენტი ჯგუფიგამოიყენება ელემენტების ჯგუფის დასადგენად რთული ტიპის განსაზღვრაში და აქვს შემდეგი ფორმატი:
< პრეფიქსი: ჯგუფი
id = ID
სახელი = NCName
ref = QName
maxOccurs = არაუარყოფითი მთელი რიცხვი | შეუზღუდავი : 1
მცირე ხდება = არაუარყოფითი მთელი რიცხვი : 1
(ანოტაცია?, (ყველა | არჩევანი | თანმიმდევრობა))
პრეფიქსი: ჯგუფი>
ატრიბუტი სახელიგანსაზღვრავს ელემენტის სახელს. ის საჭიროა მხოლოდ იმ შემთხვევაში, თუ ელემენტის მშობელი ელემენტია სქემაან ელემენტი ხელახლა განსაზღვრა. ატრიბუტი refგანსაზღვრავს ბმულს სხვა ჯგუფის სახელთან (ატრიბუტები სახელიდა refურთიერთგამომრიცხავია). არჩევითი ატრიბუტები maxOccursდა მცირე ხდებადააყენეთ მაქსიმალური და მინიმალური მნიშვნელობები რამდენჯერ შეიძლება შეიტანოთ ჯგუფის ელემენტები მშობელ ელემენტში.
ელემენტის გამოყენების მაგალითიჯგუფი:
< xs: ჯგუფისახელი=" custGroup">
xs: კომპლექსური ტიპი>
ეს მაგალითი განსაზღვრავს ჯგუფს custGroup, რომელიც შედგება ორი ელემენტისგან: მომხმარებელს(მყიდველი) და შეკვეთის დეტალები(შეკვეთის დეტალები) და შემდეგ ეს ჯგუფი გამოიყენება (მინიშნებით) კომპლექსური ტიპის განსაზღვრაში შეკვეთის ტიპი.
უცხოური გასაღებიგამოიყენება ბმულის შეზღუდვისთვის.
როდესაც ერთი ცხრილის ველში ყველა მნიშვნელობა წარმოდგენილია სხვა ცხრილის ველში, ამბობენ, რომ პირველი ველი ეხება მეორეს. ეს მიუთითებს პირდაპირ ურთიერთობაზე ორი ველის მნიშვნელობებს შორის.
როდესაც ცხრილში ერთი სქესი ეხება მეორეს, მას უწოდებენ უცხო გასაღები; და ველი, რომელსაც ის ეხება, ეწოდება მშობლის გასაღები. უცხო გასაღებისა და მშობლის გასაღების სახელები არ უნდა იყოს იგივე. უცხო კლავიშს შეიძლება ჰქონდეს ნებისმიერი რაოდენობის ველი, რომელიც დამუშავებულია როგორც ერთი ერთეული. უცხო კლავიშს და მშობლის გასაღებს, რომელსაც ის მიუთითებს, უნდა ჰქონდეთ ერთი და იგივე ველის ნომერი და ველის ტიპი და იყოს იგივე თანმიმდევრობით. როდესაც ველი არის უცხო გასაღები, ის გარკვეულწილად დაკავშირებულია იმ ცხრილთან, რომელსაც ის მიუთითებს. უცხო გასაღების თითოეული მნიშვნელობა (თითოეული მწკრივი) ცალსახად უნდა ეხებოდეს მშობელი გასაღების ერთ და მხოლოდ ამ მნიშვნელობას (რიგს). თუ ეს პირობა დაკმაყოფილებულია, მაშინ მონაცემთა ბაზა არის მდგომარეობაში რეფერენციული მთლიანობა.
SQLინარჩუნებს რეფერენციულ მთლიანობას შეზღუდვით უცხოური გასაღები. ამ ფუნქციამ უნდა შეზღუდოს მნიშვნელობები, რომლებიც შეიძლება შეიტანოს მონაცემთა ბაზაში, რათა აიძულოს უცხო გასაღები და მშობელი გასაღები შეესაბამებოდეს რეფერენციულ მთლიანობას. შეზღუდვის ერთ-ერთი ქმედება უცხოური გასაღებიარის მნიშვნელობების ჩაშვება ველებისთვის, რომლებიც შემოიფარგლება როგორც უცხო გასაღები, რომელიც ჯერ არ არის წარმოდგენილი მშობლის გასაღებში. ეს შეზღუდვა ასევე მოქმედებს მშობელი გასაღების მნიშვნელობების შეცვლის ან წაშლის უნარზე
შეზღუდვა უცხოური გასაღებიგამოიყენება ბრძანებაში CREATE TABLE (ან ALTER TABLE (განზრახულია შეცვალოს ცხრილის სტრუქტურა)), რომელიც შეიცავს ველს, რომელიც გამოცხადებულია უცხო კლავიშად უცხოური გასაღები.
შეზღუდვების უმეტესობის მსგავსად, ეს შეიძლება იყოს ცხრილის ან სვეტის შეზღუდვა, ცხრილის სახით, რომელიც საშუალებას გაძლევთ გამოიყენოთ მრავალი ველი, როგორც ერთი უცხო გასაღები.
ცხრილის შეზღუდვის სინტაქსი უცხოური გასაღები:
უცხოური გასაღები
პირველი სვეტის სია არის მძიმით გამოყოფილი სია ცხრილის ერთი ან მეტი სვეტისა, რომელიც შეიქმნება ან შეიცვლება ამ ბრძანებით.
Pktable- ეს არის ცხრილი, რომელიც შეიცავს მშობლის გასაღებს. ეს შეიძლება იყოს ცხრილი, რომელიც შექმნილია ან შეცვლილია მიმდინარე ბრძანებით.
მეორე სვეტის სია არის სვეტების სია, რომლებიც შეადგენენ მშობლის გასაღებს. ორი სვეტის სია უნდა იყოს თავსებადი, ე.ი.
- აქვს იგივე რაოდენობის სვეტები
- მოცემული თანმიმდევრობით, უცხო გასაღების სვეტების სიის პირველ, მეორე, მესამე და ა.შ. სვეტებს უნდა ჰქონდეთ მონაცემთა იგივე ტიპები და ზომები, როგორც პირველი, მეორე, მესამე და ა.შ., მშობელი გასაღების სვეტების სიის სვეტები.
- ორივე სვეტის სიებში სვეტებს არ უნდა ჰქონდეს იგივე სახელები.
უცხო გასაღები მაგალითი 1
მაგიდის შექმნა სტუდენტი
(Kod_stud მთელი რიცხვი NOT NULL PRIMARY გასაღები,
Kod_spec მთელი რიცხვი NOT NULL,
მისამართები char(50),
ბურთი ათობითი),
უცხოური გასაღები(Kod_spec) ლიტერატურასპეციფიკაცია (Kod_spec)
);
შეზღუდვის გამოსაყენებლად CREATE TABLE-ის ნაცვლად ALTER TABLE-ის გამოყენებისას უცხოური გასაღებიუცხო გასაღებისა და მშობლის გასაღებში მითითებული მნიშვნელობები უნდა იყოს რეფერენციული მთლიანობის მდგომარეობაში. წინააღმდეგ შემთხვევაში ბრძანება უარყოფილი იქნება.
შეზღუდვის გამოყენება უცხოური გასაღებიცხრილი ან სვეტი, შეგიძლიათ გამოტოვოთ მშობელი გასაღების სვეტების სია, თუ მშობლის გასაღებს აქვს PRIMARY შეზღუდვა გასაღები. ბუნებრივია, მრავალი ველის მქონე კლავიშების შემთხვევაში, უცხო და პირველადი კლავიშების სვეტების თანმიმდევრობა უნდა ემთხვეოდეს და, ნებისმიერ შემთხვევაში, კვლავ მოქმედებს ორ კლავიშს შორის თავსებადობის პრინციპი.
საგარეო გასაღები მაგალითი 2
მაგიდის შექმნა სტუდენტი (
Kod_stud მთელი რიცხვი NOT NULL PRIMARY გასაღები,
ცნობილი სიმბოლო (30) NOT NULL UNIQUE,
მისამართები char(50),
ბურთი ათობითი),
Kod_spec მთელი რიცხვი REFERENCES Spec
);
რეფერენტული მთლიანობის შესანარჩუნებლად საჭიროა გარკვეული შეზღუდვები იმ მნიშვნელობებზე, რომლებიც შეიძლება იყოს წარმოდგენილი ველებში, რომლებიც გამოცხადებულია როგორც უცხო გასაღები და მშობელი გასაღები. მთავარი გასაღები უნდა იყოს სტრუქტურირებული ისე, რომ თითოეული უცხო გასაღების მნიშვნელობა შეესაბამება ერთ მითითებულ მწკრივს. ეს ნიშნავს, რომ ის (გასაღები) უნდა იყოს უნიკალური და არ შეიცავდეს ცარიელ მნიშვნელობებს (NULL).
ეს არ არის საკმარისი იმისათვის, რომ ძირითადი გასაღები დააკმაყოფილოს იგივე მოთხოვნა, რაც უცხო გასაღების გამოცხადებისას. SQLდარწმუნებული უნდა იყოს, რომ ორმაგი მნიშვნელობები ან ნულოვანი მნიშვნელობები არ არის შეყვანილი მშობლის გასაღებში. ამიტომ, თქვენ უნდა დარწმუნდეთ, რომ ყველა ველს, რომელიც გამოიყენება როგორც მშობლის გასაღებები, აქვს ან PRIMARY შეზღუდვა გასაღებიან UNIQUE შეზღუდვა, როგორიცაა NOT NULL შეზღუდვა.
უცხო გასაღების მხოლოდ პირველადი გასაღების მითითება კარგი სტრატეგიაა. როდესაც გამოიყენება უცხოური გასაღებები, ისინი უბრალოდ არ ასოცირდება მშობელ გასაღებებთან, რომლებსაც ისინი მიმართავენ; ისინი ასოცირდება ცხრილის კონკრეტულ მწკრივთან, სადაც მოიძებნება ეს მშობელი გასაღები. თავად მშობელი გასაღები არ იძლევა ინფორმაციას, რომელიც უკვე არ არის უცხოურ გასაღებში.
ვინაიდან პირველადი გასაღების დანიშნულებაა მწკრივის უნიკალურობის იდენტიფიცირება, ეს უფრო ლოგიკური და ნაკლებად ორაზროვანი არჩევანია უცხო გასაღებისთვის. ნებისმიერი უცხო გასაღებისთვის, რომელიც იყენებს უნიკალურ გასაღებს, როგორც მის მთავარ გასაღებს, თქვენ უნდა შექმნათ უცხო გასაღები, რომელიც იყენებს იმავე ცხრილის ძირითად გასაღებს იმავე ეფექტისთვის. უცხო გასაღები, რომელსაც სხვა დანიშნულება არ აქვს, გარდა რიგების დაკავშირებისა, არის პირველადი გასაღების მსგავსი, რომელიც გამოიყენება მხოლოდ რიგების იდენტიფიცირებისთვის და არის კარგი საშუალება მონაცემთა ბაზის სტრუქტურის მკაფიო და მარტივი შესანარჩუნებლად. უცხო გასაღები შეიძლება შეიცავდეს მხოლოდ მნიშვნელობებს, რომლებიც რეალურად არის მშობლის გასაღებში ან ცარიელი (NULL). ამ კლავიშში სხვა მნიშვნელობების შეყვანის ნებისმიერი მცდელობა უარყოფილი იქნება.
უცხოური გასაღები მაგალითი 3
შექმენით მაგიდასთან გადახდა (
sh_payout მთელი რიცხვი,
sh_eml მთელი რიცხვი,
date_გადახდის თარიღი,
sum_payout რეალური,
უცხოური გასაღები(sh_eml) ლიტერატურა k_sotr2 (eid)
);
ამ მაგალითში უცხოური გასაღები sh_eml სვეტი ასოცირდება eid სვეტთან k_sotr2 ცხრილიდან.
ელემენტი xsl: გასაღებიგანსაზღვრავს დასახელებულ გასაღებს ტრანსფორმაციაში.
ზედა დონის xsl:key ელემენტი განსაზღვრავს კლავიშს ტრანსფორმაციისას სახელით მითითებული სახელის საჭირო ატრიბუტის მნიშვნელობაში, რომლის მნიშვნელობა თითოეული დოკუმენტის კვანძისთვის, რომელიც შეესაბამება საჭირო შესატყვის შაბლონს, იქნება გამოხატვის შეფასების შედეგი. მითითებულია საჭირო გამოყენების ატრიბუტში. არც გამოყენების ატრიბუტი და არც მატჩის ატრიბუტი არ შეიძლება შეიცავდეს ცვლადებს.
სინტაქსი
XSLT 1.0
ატრიბუტები
- სახელი - საჭირო
- მატჩი - საჭირო
- გამოყენება - საჭიროატრიბუტი, XPath გამოხატულება, რომელიც განსაზღვრავს ინდექსირებული კვანძების თვისებას, რომელიც გამოიყენება ინდექსიდან კვანძების შესარჩევად.
სპეციფიკაცია
XSLT 2.0
ატრიბუტები
- სახელი - საჭიროატრიბუტი, განსაზღვრავს გასაღების სახელს.
- მატჩი - საჭიროატრიბუტი, XPath გამოხატულება, რომელიც განსაზღვრავს მოცემული გასაღებით ინდექსირებულ კვანძებს.
- გამოყენება - სურვილისამებრატრიბუტი, XPath გამოხატულება, რომელიც განსაზღვრავს ინდექსირებული კვანძების თვისებას, რომელიც გამოიყენება ინდექსიდან კვანძების შესარჩევად. XSLT 2.0-ში ეს ატრიბუტი არჩევითია. ელემენტი
- შედარება - სურვილისამებრატრიბუტი, განსაზღვრავს შეჯამების თანმიმდევრობას, რომელიც გამოიყენება იმის შესამოწმებლად, არის თუ არა ორი ძირითადი მნიშვნელობის ტოლი.
XSLT 3.0
აღწერა და მაგალითები
სანამ კლავიშებს შევეხებით, რომლებიც ერთ-ერთი ყველაზე ძლიერი კონცეფციაა XSLT ენაში, შევეცადოთ გადავჭრათ ერთი მარტივი პრობლემა.
ჩამონათვალი 8.19. შემომავალი დოკუმენტი
მოდით, შემომავალი დოკუმენტი იყოს ობიექტების სია (საგნის ელემენტები), რომელთაგან თითოეულს აქვს სახელი (სახელის ატრიბუტი) და წყარო (წყაროს ატრიბუტი). საჭიროა ობიექტების დაჯგუფება მათი წყაროების მიხედვით და დოკუმენტის მიღება დაახლოებით შემდეგნაირად.
ჩამონათვალი 8.20. საჭირო შედეგი
პირველი ნაბიჯი ამ პრობლემის გადასაჭრელად არის XSLT ტერმინების ფორმულირება წინადადება „დაჯგუფება ობიექტები მათი წყაროების მიხედვით“. თითოეული ობიექტის წყარო განისაზღვრება მისი წყაროს ატრიბუტით, რაც ნიშნავს, რომ იმავე წყაროს "a"-ს კუთვნილი ობიექტების ნაკრები განისაზღვრება შერჩევით.
/items/item[@source="a"]
შემდეგ თითოეული ელემენტის ელემენტისთვის მისი ჯგუფი მოიცავს ელემენტებს, რომლებიც შეირჩევა გამოსახულებით
/items/item[@source=current()/@source]
შევეცადოთ გამოვიყენოთ ეს ფაქტი შემდეგ შაბლონში:
როგორც მოსალოდნელი იყო, ელემენტის ელემენტებზე ამ წესის გამოყენებისას, თითოეული მათგანისთვის შეიქმნება ერთი და იგივე წყაროს კუთვნილი ჯგუფი - ეს უკვე კარგი შედეგია, მაგრამ პირობა მოითხოვს ჯგუფის შექმნას არა თითოეული ობიექტისთვის, არამედ თითოეული წყაროსთვის. ამის მისაღწევად, თქვენ შეგიძლიათ შექმნათ ჯგუფი მხოლოდ პირველი ობიექტისთვის, რომელიც მას ეკუთვნის. ისევ და ისევ, ასეთი შემოწმება არ არის რთული: ობიექტი იქნება პირველი ჯგუფში, თუ და მხოლოდ იმ შემთხვევაში, თუ მას წინ არ უძღვის სხვა ელემენტის ელემენტები, რომლებიც მიეკუთვნება იმავე წყაროს. სხვა სიტყვებით რომ ვთქვათ, ჩვენ ვქმნით ჯგუფებს მხოლოდ იმ ელემენტებისთვის, რისთვისაც გამოხატულია
წინამორბედი-ძმა::item[@source=current()/@source]
დააბრუნებს ცარიელ კომპლექტს.
მცირე დამატებებით, მთელი საჭირო ტრანსფორმაცია ასე გამოიყურება:
ჩამონათვალი 8.21. კონვერტაცია
უდავოდ, გამოსავალი იყო მარტივი, მაგრამ საკმაოდ რთული. ამ ტრანსფორმაციის ყველაზე დიდი შეფერხება არის მიმდინარე ელემენტის წყაროს ელემენტის ელემენტებზე წვდომა წყაროს ატრიბუტების შედარებით.
პრობლემა სრულიად სტანდარტულია მრავალი ტრანსფორმაციისთვის: თქვენ უნდა აირჩიოთ კვანძები გარკვეული მახასიათებლების საფუძველზე და ეს უნდა გააკეთოთ რაც შეიძლება ეფექტურად. კარგია, რომ ჩვენს დოკუმენტში მხოლოდ რვა ელემენტი იყო, მაგრამ წარმოიდგინეთ სიტუაცია, სადაც რეალურად ბევრი ელემენტია.
პრობლემა, რომელიც ჩვენ დავაყენეთ, საკმაოდ სერიოზულია. იგი შედგება ხის მსგავს სტრუქტურაში გარკვეული თვისებების მქონე კვანძების ძიების ოპტიმიზაციისგან.
შევეცადოთ გავიგოთ ფრაზის მნიშვნელობა "კვანძს აქვს გარკვეული თვისებები". ცხადია, ეს ნიშნავს, რომ გარკვეული ლოგიკური პირობა დაკმაყოფილებულია ამ კვანძისთვის, სხვა სიტყვებით რომ ვთქვათ, გარკვეული პრედიკატი ხდება "ჭეშმარიტი".
თუმცა, რა ტიპის პირობებს ვამოწმებთ ყველაზე ხშირად? პრობლემების სხვადასხვა კლასის გაანალიზებით, შეგვიძლია მივიდეთ დასკვნამდე, რომ უმეტეს შემთხვევაში პრედიკატები არის თანასწორობა - გამონათქვამები, რომლებიც ხდებიან "ჭეშმარიტი", თუ და მხოლოდ იმ შემთხვევაში, თუ კვანძის რომელიმე პარამეტრი, არსებული კონტექსტისგან დამოუკიდებელი, უდრის გარკვეულ მნიშვნელობას. ჩვენს მაგალითში, პრედიკატის მიზანი ნამდვილად არ არის იმის შემოწმება, არის თუ არა @source=current()/@source სიმართლე, არამედ იმის შემოწმება, არის თუ არა @source და current()/@source თანაბარი.
ზოგადი შემთხვევის გადასატანად, ჩვენ არ გვჭირდება ავირჩიოთ ის კვანძები, რომლებშიც A=B არის ჭეშმარიტი, არამედ უნდა ავირჩიოთ ის კვანძები, რომლებისთვისაც A-ს მნიშვნელობა B-ის მნიშვნელობის ტოლია. სხვა სიტყვებით რომ ვთქვათ, კვანძი იდენტიფიცირებული იქნება მისი A თვისების B მნიშვნელობით. და თუ წინასწარ გამოვთვლით A თვისებების მნიშვნელობებს, ხეში კვანძების პოვნის პრობლემა დაიყვანება ნაკრების ელემენტების (ჩვენს შემთხვევაში, ხის კვანძების) ძიების კლასიკურ პრობლემამდე გარკვეული საკვანძო მნიშვნელობებით. (ჩვენს შემთხვევაში, A თვისებების მნიშვნელობები).
ამის გასარკვევად დავუბრუნდეთ ჩვენს მაგალითს: ჩვენ ვეძებთ ელემენტის ელემენტებს წყაროს ატრიბუტის მნიშვნელობით მოცემულის ტოლი. თვისება, რომელიც განსაზღვრავს ამ ელემენტებს, ამ შემთხვევაში, იქნება მათი წყაროს ატრიბუტების მნიშვნელობები, რომლებიც შეგვიძლია წინასწარ გამოვთვალოთ და შევიყვანოთ ცხრილში. 8.2.
ცხრილი 8.2. ელემენტის ელემენტების წყაროს ატრიბუტების მნიშვნელობები
| იდენტიფიკატორი (წყაროს ატრიბუტის მნიშვნელობა) | ელემენტის ელემენტი |
|---|---|
| ა | |
| ა | |
| ა | |
| ბ | |
| ბ | |
| ბ | |
| გ | |
| გ |
ამგვარად, მნიშვნელობა „c“ განსაზღვრავს ობიექტებს სახელად D და G, ხოლო მნიშვნელობა „a“ განსაზღვრავს ობიექტებს სახელად A, C და H და არ არის რთული ცხრილში შესაბამისი ელემენტების პოვნა მათი ძირითადი თვისებით.
იმისდა მიუხედავად, რომ ჩვენ მიერ შესრულებული მანიპულაციები უკიდურესად მარტივია (და თანაბრად ეფექტური), პროცესორს, როგორც წესი, ნაკლებად სავარაუდოა, რომ შეეძლოს მსგავსი რამის გაკეთება და, შესაბამისად, XSLT ტრანსფორმაციების კვანძების ნაკრების ძირითადი თვისებების ცალსახად ხაზგასმის შესაძლებლობა არის ძალიან მნიშვნელოვანი.
ამ განყოფილებაში ჩვენ განვიხილავთ ორ კონსტრუქციას, რომელიც საშუალებას გაძლევთ მანიპულიროთ კვანძების სიმრავლით გასაღებების გამოყენებით: xsl:key ელემენტი, რომელიც განსაზღვრავს დასახელებულ კლავიშს ტრანსფორმაციაში და გასაღების ფუნქცია, რომელიც აბრუნებს კვანძების კომპლექტს, რომლებიც იდენტიფიცირებულია. მოცემული ძირითადი მნიშვნელობები.
მაგალითი 1
ჩვენს მაგალითში, ელემენტის ელემენტები იდენტიფიცირებულია მათი წყაროს ატრიბუტების მნიშვნელობებით. მათი იდენტიფიცირებისთვის, ჩვენ შეგვიძლია განვსაზღვროთ გასაღები სახელად src ასე:
ენის სპეციფიკაციაში მოცემული მკაცრი განსაზღვრების შემდეგ, გასაღები არის ფორმის სამმაგი (კვანძი, სახელი, მნიშვნელობა), სადაც კვანძი არის კვანძი, სახელი არის სახელი და მნიშვნელობა არის გასაღების სიმებიანი მნიშვნელობა. შემდეგ ტრანსფორმაციაში შემავალი xsl:key ელემენტები განსაზღვრავენ დამუშავებული დოკუმენტის ყველა შესაძლო გასაღების კომპლექტს. თუ ეს ნაკრები შეიცავს გასაღებს, რომელიც შედგება x კვანძისგან, სახელი y და z მნიშვნელობა, კვანძს x აქვს გასაღები სახელით y და მნიშვნელობით z, ან რომ x კვანძის გასაღები y არის z.
მაგალითი 2
წინა მაგალითიდან src კლავიში განსაზღვრავს კომპლექტს, რომელიც შედგება შემდეგი სამეულისგან:
(
ჩვენი განმარტებების მიხედვით შეგვიძლია ვთქვათ, რომ ელემენტი
აქვს გასაღები სახელად "src" და მნიშვნელობა "b" ან ელემენტის გასაღები "src".
უდრის "a".
კვანძების კომპლექტებში მათი საკვანძო მნიშვნელობებით წვდომისთვის, XSLT-ს აქვს საკვანძო ფუნქცია, რომელზეც ახლა ვისაუბრებთ.
საკვანძო ფუნქცია
ქვემოთ მოცემულია ამ ფუნქციის სინტაქსური სტრუქტურა:
კვანძის ნაკრების გასაღები (სტრიქონი, ობიექტი)
ამრიგად, ჩვენი ტრანსფორმაციის xsl: საკვანძო ელემენტებმა განსაზღვრეს სამეულების ნაკრები (კვანძი, სახელი, მნიშვნელობა). ფუნქციის გასაღები (გასაღების სახელი, გასაღები-მნიშვნელობა) ირჩევს ყველა კვანძს x ისე, რომ მათი კლავიშის მნიშვნელობა, სახელად key-name (ფუნქციის პირველი არგუმენტი) ტოლი იყოს გასაღები-მნიშვნელობის (ფუნქციის მეორე არგუმენტი).
მაგალითი 3
გამოხატვის გასაღების მნიშვნელობა ("src", "a") იქნება ელემენტის ელემენტების ისეთი ნაკრები, რომ მათი გასაღების "src" მნიშვნელობა იქნება "a"-ს ტოლი. მარტივად რომ ვთქვათ, ეს იქნება წყაროს ობიექტების "a" ნაკრები.
კლავიშების კონცეფცია საკმაოდ მარტივია და არსებობს მრავალი ანალოგი სხვა პროგრამირების ენებში, ჰეშის ფუნქციებიდან დაწყებული კლავიშებით რელაციური მონაცემთა ბაზის ცხრილებში. დიდი ალბათობით, მკითხველს მსგავსი რამ უკვე შეექმნა.
მაგრამ არ უნდა დაგვავიწყდეს, რომ XSLT ენა საკმაოდ არატრადიციული ენაა როგორც სინტაქსის, ასევე მონაცემთა მოდელის თვალსაზრისით. შედეგად, მასში არსებული გასაღებები საკმაოდ ბევრი ფარული ნიუანსია, რომელთა ცოდნა და გაგება ძალიან სასარგებლოა. ჩვენ შევეცდებით გამოვავლინოთ ყველა ეს თვისება რაც შეიძლება სრულად.
გასაღებების ნაკრების განსაზღვრა
განსაკუთრებით რთული არ არის გასაღებების ნაკრების განსაზღვრა, თუ ისინი იდენტიფიცირებულია განმარტებაში სტრიქონი გამონათქვამებით. მაგალითად, შემდეგ განმარტებაში
გამოყენების ატრიბუტი მიუთითებს, რომ ელემენტის ელემენტის src კლავიშის მნიშვნელობა იქნება წყაროს ატრიბუტის მნიშვნელობა. მაგრამ რაც შეეხება შემდეგ განმარტებას:
ცხადია, ეს ბევრად უფრო რთული, მაგრამ, მიუხედავად ამისა, ძალიან რეალური შემთხვევაა, რომელიც არ ჯდება აქამდე მოცემულ განმარტებებში. ჩვენ მხოლოდ ვთქვით, რომ გასაღებების ნაკრები განისაზღვრება xsl:key ტრანსფორმაციის ელემენტებით, მაგრამ ზუსტად როგორ განისაზღვრება ის დღემდე საიდუმლოდ რჩება. მოდით შევავსოთ ეს ხარვეზი გასაღებების ნაკრების მკაცრი განმარტებით.
x კვანძს აქვს გასაღები სახელად y და სტრიქონის მნიშვნელობა z, თუ და მხოლოდ იმ შემთხვევაში, თუ ტრანსფორმაციაში არის xsl:key ელემენტი ისეთი, რომ ყველა შემდეგი პირობა ერთდროულად იყოს ჭეშმარიტი:
- კვანძი x ემთხვევა მის შესატყვის ატრიბუტში მითითებულ შაბლონს;
- მისი სახელის ატრიბუტის მნიშვნელობა უდრის სახელს y;
- გამოყენების ატრიბუტის მნიშვნელობაში მითითებული გამონათქვამის შეფასების შედეგი მიმდინარე სიმრავლის კონტექსტში, რომელიც შედგება ერთი კვანძისგან x აკმაყოფილებს ერთ-ერთ შემდეგ პირობას:
- u არის კვანძების სიმრავლე და z უდრის მათ ერთ-ერთ სტრიქონის მნიშვნელობას;
- u არ არის კვანძის ნაკრები და z უდრის მის სიმებიანი მნიშვნელობას.
ეჭვგარეშეა, განმარტება მარტივი არ არის. მაგრამ როგორ მოვიქცეთ, თუ ფიზიკურად შევქმენით ბევრი გასაღები მეხსიერებაში? ქვემოთ მოცემულია ერთი შესაძლო ალგორითმი:
- თითოეული xsl:key ელემენტისთვის იპოვეთ დოკუმენტის კვანძების ნაკრები, რომელიც აკმაყოფილებს მის შესატყვის შაბლონს (კომპლექტი X);
- თითოეული ნაპოვნი კვანძისთვის (x ? X) გამოთვალეთ გამოყენების ატრიბუტის გამოხატვის მნიშვნელობა (u(x) მნიშვნელობა);
- თუ u(x) არის კვანძების ერთობლიობა (მოდით დავარქვათ მას Ux), მაშინ თითოეული ux-ისთვის? Ux შექმნის გასაღები (x, n, string(uxi)), სადაც n არის გასაღების სახელი (xsl:key ელემენტის სახელის ატრიბუტის მნიშვნელობა);
- თუ u(x) არის სხვა ტიპის ობიექტი (მოდით დავარქვათ ux), შექმენით გასაღები (x, n, string(ux)) .
მაგალითი 4
მოდი ვიპოვოთ განსაზღვრებით შექმნილი გასაღებების ნაკრები
ყველა გასაღების სახელები იქნება იგივე და ტოლი "src". კვანძების x კომპლექტი, რომელიც აკმაყოფილებს ელემენტის შაბლონს, შეიცავს დამუშავებული დოკუმენტის ყველა ელემენტის ელემენტს. გამოყენების ატრიბუტში მითითებული გამონათქვამის მნიშვნელობა არის თითოეული ელემენტის ელემენტის ყველა ატრიბუტის კვანძების ნაკრები. ამრიგად, კვანძების ნაკრები ასე გამოიყურება:
(
შედეგად, key("src", "a") ფუნქცია დააბრუნებს ობიექტებს სახელად A , C და H , ხოლო key("src", "A") ფუნქცია დააბრუნებს ერთ ობიექტს სახელად A (რადგან სხვა არ არის. ელემენტი არ არის ატრიბუტი მნიშვნელობით "A").
გასათვალისწინებელია ის, რომ არ არის აუცილებელი, რომ პროცესორმა ფიზიკურად შექმნას რამდენიმე კლავიატურა მეხსიერებაში. ეს ნაკრები წმინდა ლოგიკურად არის განსაზღვრული - ისე, რომ ნათელი იყოს, რა დააბრუნებს საკვანძო ფუნქციას. პროცესორებს შეუძლიათ გამოთვალონ საკვანძო მნიშვნელობები და მოძებნონ კვანძები დოკუმენტში და გაშვების დროს წინასწარ რაიმეს გენერირების გარეშე. მაგრამ პროცესორების უმეტესობა, როგორც წესი, მაინც ქმნის მეხსიერებაში გარკვეულ სტრუქტურებს გასაღების მანიპულირებისთვის. ეს შეიძლება იყოს ჰეშის ცხრილები, სიები, მარტივი მასივები ან უფრო რთული არაწრფივი სტრუქტურები, რომლებიც ამარტივებს ძიებას - სხვა რამ არის მნიშვნელოვანი. მთავარია, რომ xsl:key-ში გასაღების მკაფიო განმარტებით, პროცესორს შეუძლია შეასრულოს ასეთი ოპტიმიზაცია.
რამდენიმე კლავიშის გამოყენება ერთ ტრანსფორმაციაში
იმ შემთხვევაში, როდესაც ტრანსფორმაციის კვანძებს სჭირდებათ წვდომა სხვადასხვა თვისებების მნიშვნელობებით, შეგიძლიათ განსაზღვროთ რამდენიმე გასაღები - თითოეულს თავისი სახელი. მაგალითად, თუ ერთ შემთხვევაში გვსურს წვდომა ერთი წყაროს კუთვნილ ობიექტებზე, მეორეში კი კონკრეტული სახელების მქონე ობიექტებზე, შეგვიძლია დოკუმენტში განვსაზღვროთ ორი გასაღები - ერთი სახელად src, მეორეს სახელად:
ამ ორი განსაზღვრებით შექმნილი გასაღებების ნაკრები ასე გამოიყურება:
(
ამ შემთხვევაში, ფუნქციის გასაღები ("src", "a") დააბრუნებს ობიექტებს სახელად A , C და H , ხოლო ფუნქციის გასაღები ("სახელი", "A") დააბრუნებს ობიექტს სახელად A.
გასაღების სახელი არის გაფართოებული სახელი. მას შეიძლება ჰქონდეს სახელის სივრცის დეკლარირებული პრეფიქსი, მაგალითად
ამ შემთხვევაში, ფუნქციის გასაღები (გასაღების სახელი, გასაღები-მნიშვნელობა) დააბრუნებს კვანძებს, რომელთა საკვანძო მნიშვნელობა გაფართოებული სახელით გასაღები-სახელი უდრის გასაღები-მნიშვნელობას. გაფართოებული სახელების შესატყვისი განისაზღვრება ჩვეულებისამებრ - ადგილობრივი ნაწილებისა და სახელთა სივრცის URI-ების შესატყვისით.
ერთი და იგივე გასაღების მრავალი განმარტების გამოყენება
პროცესორმა პატივი უნდა სცეს მოცემული ტრანსფორმაციის ყველა საკვანძო განმარტებას - მაშინაც კი, თუ ზოგიერთი მათგანი შედის ან იმპორტირებულ მოდულშია. xsl:key ელემენტების იმპორტის თანმიმდევრობას არ აქვს მნიშვნელობა: საქმე იმაშია, რომ გასაღების განმარტებები იგივე სახელებით ერთი და იგივე კვანძებისთვის, მაგრამ განსხვავებული ძირითადი მნიშვნელობებით, არ აჭარბებს, არამედ ავსებს ერთმანეთს.
მაგალითი 5
ვთქვათ, გვაქვს რამდენიმე ელემენტის ელემენტი ჩვენს დოკუმენტში, რომლებსაც არ აქვთ მითითებული წყაროს ატრიბუტის მნიშვნელობა, მაგრამ ჩვენ ნაგულისხმევად მივაკუთვნებთ მათ წყაროს a . შესაბამისი გასაღებები განისაზღვრება შემდეგნაირად:
ანუ იმ ელემენტის ელემენტებს, რომლებსაც აქვთ წყაროს ატრიბუტი, საკვანძო მნიშვნელობა იქნება ამ ატრიბუტის მნიშვნელობა, იგივე ელემენტებისთვის, რომლებსაც არ აქვთ წყაროს ატრიბუტი, მისი მნიშვნელობა იქნება "a".
ფორმის შემოსული დოკუმენტისთვის
გასაღებების შესაბამისი ნაკრები განისაზღვრება შემდეგნაირად:
(
ფუნქციის გასაღები ("src", "a") დააბრუნებს ობიექტებს სახელად A , C , H , I , J და K .
ის ფაქტი, რომ ერთსა და იმავე კვანძს შეიძლება ჰქონდეს განსხვავებული მნიშვნელობები ერთი და იგივე გასაღებისთვის, ასევე ძალიან მოსახერხებელი თვისებაა. მაგალითად, ზემოთ მოცემულ ორ ძირითად განმარტებას შეიძლება დაემატოს მესამე:
ეს განსაზღვრება საშუალებას მისცემს "#default" მნიშვნელობას მიმართოს ნაგულისხმევ წყაროს კუთვნილ ობიექტებს.
საკვანძო ფუნქციაში მრავალი კვანძის გამოყენება
გასაღების ფუნქცია შეყვანის სახით იღებს ორ არგუმენტს: პირველი არგუმენტი არის სტრიქონი, რომელიც განსაზღვრავს გასაღების სახელს, ხოლო მეორე არგუმენტი შეიძლება იყოს ნებისმიერი ტიპის ობიექტი. თუ გასაღები-მნიშვნელობის არგუმენტი გასაღების (გასაღების სახელი, გასაღები-მნიშვნელობის) ფუნქციაში არის კვანძების ნაკრები, საკვანძო ფუნქცია დააბრუნებს ყველა კვანძს, რომელსაც აქვს გასაღების სახელი, მნიშვნელობით, რომელიც ტოლია სტრიქონის ერთ-ერთი მნიშვნელობის მაინც. კვანძის ნაკრების გასაღები-მნიშვნელობა.
მაგალითი 6
დავუშვათ, რომ ობიექტის წყაროები დაჯგუფდება შემდეგნაირად:
ამ ჯგუფის რომელიმე წყაროს კუთვნილი ელემენტის ელემენტების ნაკრების გამოსათვლელად, საკმარისი იქნება ფორმის გამოხატვის გამოყენება.
გასაღები ("src", წყაროები/წყარო/@სახელი)
ბილიკის წყაროების/წყაროს/@სახელის მიერ შერჩეული კვანძების ნაკრები შეიცავს წყაროს ელემენტების სახელის ატრიბუტებს. მათი სიმებიანი მნიშვნელობები იქნება a და c, რაც ნიშნავს, რომ ჩვენი გამონათქვამი დააბრუნებს ელემენტის ელემენტების კომპლექტს, რომლის წყაროს ატრიბუტის მნიშვნელობა არის ან a ან c.
გასაღებების გამოყენება მრავალ დოკუმენტში
ტრანსფორმაციაში განსაზღვრული კლავიშები შეიძლება გამოყენებულ იქნას სხვადასხვა დამუშავებულ დოკუმენტებში კვანძების შესარჩევად. გასაღები ფუნქცია აბრუნებს კვანძებს, რომლებიც ეკუთვნის მიმდინარე დოკუმენტს, ანუ დოკუმენტს, რომელიც შეიცავს მიმდინარე კვანძს. ეს ნიშნავს, რომ გარე დოკუმენტიდან კვანძების შესარჩევად, თქვენ უნდა აქციოთ ამ გარე დოკუმენტის ერთ-ერთი კვანძი მიმდინარე კვანძად. კონტექსტური დოკუმენტი ადვილად შეიძლება შეიცვალოს xsl:for-eveach ელემენტით, მაგალითად, მიმდინარე დოკუმენტის გასაკეთებლად a.xml , უბრალოდ ჩაწერეთ
მაგალითი 7
დავუშვათ, უნდა ავირჩიოთ ობიექტები, რომლებიც მიეკუთვნება a წყაროს, სადაც ობიექტების საკუთრება განისაზღვრება ორ გარე დოკუმენტში, a.xml და b.xml.
ჩამონათვალი 8.22. შემომავალი დოკუმენტი
ჩამონათვალი 8.23. დოკუმენტი a.xml
ჩამონათვალი 8.24. დოკუმენტი b.xml
ჩამონათვალი 8.25. კონვერტაცია
ჩამონათვალი 8.26. გამავალი დოკუმენტი
კომპოზიტური გასაღებები
რელაციური მონაცემთა ბაზების თეორიაში არსებობს ისეთი რამ, როგორიცაა კომპოზიტური გასაღები. როგორც განსაზღვრავს K. J. Date [თარიღი 1999], კომპოზიტური გასაღები არის „პოტენციური გასაღები; შედგება ერთზე მეტი ატრიბუტისაგან“.
მიუხედავად იმისა, რომ გასაღებების კონცეფცია XSLT-ში ძალიან განსხვავდება იმისგან, რასაც რელაციურ მონაცემთა ბაზებში კლავიშს უწოდებენ, იდეა ძალიან, ძალიან საინტერესოა: კვანძების კომპლექტებზე წვდომისას გამოიყენეთ არა მხოლოდ ერთი თვისება, არამედ მათი ზოგიერთი კომბინაცია.
მთავარი პრობლემა ის არის, რომ საკვანძო მნიშვნელობა XSLT-ში ყოველთვის არის სტრიქონი, ერთ-ერთი ყველაზე პრიმიტიული ტიპი. და თქვენ შეგიძლიათ აირჩიოთ კვანძების ნაკრები მხოლოდ ერთი სტრიქონის მნიშვნელობის დროს. არაფერი მოსწონს key (key-name, key-value-1, key-value-2, ...) კვანძების შესარჩევად, რომელთა პირველი თვისება არის key-value-1, მეორე თვისება არის key-value-2 და ასე შემდეგ, XSLT არ არის გათვალისწინებული.
გამოსავალი საკმაოდ აშკარაა: თუ საკვანძო მნიშვნელობა არ შეიძლება იყოს რთული სტრუქტურა, მან უნდა გამოხატოს რთული სტრუქტურა. სხვა სიტყვებით რომ ვთქვათ, ვინაიდან კომპოზიციური გასაღების მნიშვნელობა შეიძლება იყოს მხოლოდ სტრიქონი, მაშინ ეს სტრიქონი უნდა შედგებოდეს რამდენიმე ნაწილისგან.
მაგალითი 8
დავუშვათ, რომ ერთი და იგივე სახელწოდების ობიექტები შეიძლება მიეკუთვნებოდეს სხვადასხვა წყაროს. ჩვენ გაჩვენებთ, თუ როგორ შეგიძლიათ კლავიშების გამოყენებით გადაჭრათ შემდეგი პრობლემები:
- იპოვნეთ ობიექტი კონკრეტული სახელითა და წყაროებით;
- იპოვნეთ ობიექტები კონკრეტული სახელით;
- იპოვნეთ ობიექტები კონკრეტული წყაროთი.
ჩამონათვალი 8.27. შემომავალი დოკუმენტი
ელემენტის ელემენტებისთვის, ჩვენ გამოვქმნით გასაღებებს, რომელთა მნიშვნელობები შედგება ორი ნაწილისგან - წყარო და სახელი, გამოყოფილი "-" სიმბოლოთი. სამივე ამოცანის ერთი გასაღებით გადასაჭრელად, მის განსასაზღვრად გამოვიყენებთ სამ xsl:key ელემენტს.
ჩამონათვალი 8.28. შემომავალი დოკუმენტი
ჩამონათვალი 8.29. გამავალი დოკუმენტი
აქ წარმოდგენილ გასაღების გენერირების მეთოდს აქვს გარკვეული შეზღუდვები: აუცილებელია გქონდეთ აპრიორი ინფორმაცია თითოეული თვისების სიმებიანი მნიშვნელობების შესახებ, რომლებიც ქმნიან ჩვენს კომპოზიტურ გასაღებს, რათა სწორად ჩამოყალიბდეს მისი სიმებიანი წარმოდგენები. მაგალითად, თუ ზემოთ მოცემულ დოკუმენტში ობიექტისა და წყაროს სახელები შეიძლება შეიცავდეს „-“ სიმბოლოს, გაუგებარი იქნება, რომელ ობიექტზე მიუთითებს კომპოზიციური გასაღები „a-b-c“: ობიექტი a-b და სახელით c, თუ ობიექტი. წყაროთ a და სახელწოდებით b-c. საბედნიეროდ, უმეტეს შემთხვევაში ეს ინფორმაცია ხელმისაწვდომია და კომპოზიტური გასაღებების გენერირება არც ისე რთულია.
ძირითადი ფუნქცია შაბლონებში
შაბლონების აგების სინტაქსური წესების გაანალიზებისას ჩვენ წავაწყდით ნიმუშის სპეციალურ ფორმას, რომელშიც შეიძლებოდა საკვანძო ფუნქციის გამოყენება. მოდით კიდევ ერთხელ გადავხედოთ ამ პროდუქტებს:
IdKeyPattern::= "id" "(" Literal ")" | "გასაღები" "(" სიტყვასიტყვითი "," ლიტერატურული ")"
ნიმუშში გასაღების (key-name, key-value) ფუნქცია დაემთხვევა კვანძებს, რომელთა საკვანძო სახელის მნიშვნელობა ტოლია ან ეკუთვნის გასაღები-მნიშვნელობის ობიექტს. ეს საშუალებას გაძლევთ გამოიყენოთ კლავიშების ძალა კვანძების ნიმუშის შემოწმებისას.
მაგალითი 9
ვთქვათ, ჩვენ უნდა მოვექცეთ ობიექტებს, რომლებიც მიეკუთვნება a-ს წყაროს. ამისათვის ჩვენ შეგვიძლია შევქმნათ შემდეგი შაბლონი.
ჩამონათვალი 8.30. შაბლონი ნიმუშში გასაღების ფუნქციის გამოყენებით
ეს ნიმუში ვრცელდება ნებისმიერ კვანძზე, რომელსაც აქვს src გასაღები a მნიშვნელობით.