ჩადგმული მოთხოვნები კონსტრუქტორში. შეკითხვის კონსტრუქტორები 1c შეკითხვის კონსტრუქტორის პირობები
ასე რომ, დავიწყოთ რაღაც მარტივით: შექმენით ახალი დამუშავება კონფიგურატორში, დაარქვით მას Query Console ან Query Builder, როგორც გსურთ.
ჩვენ შეგვიძლია დაუყოვნებლივ დავამატოთ ცხრილი "მონაცემებში" მომავალი პარამეტრებისთვის, რომელიც ჩვენ გვჭირდება, ასე რომ ჩვენს კონსოლში ჩვენ შევასრულოთ არა ყველაზე პრიმიტიული მოთხოვნა, არამედ პარამეტრებით და ბმულებით, მაგალითად, ჩვენი სამუშაოსთვის ჩვენ შევქმნით მოთხოვნას პერიოდულ რეგისტრებზე. , მაგრამ აქ პარამეტრის ინსტრუქციის გარეშე=&თარიღი არსად.
ჩვენი პარამეტრების ცხრილის შესაქმნელად, "მონაცემების" ჩანართზე მის "ტაბულურ ნაწილში" დავამატებთ ახალ ცხრილს, დავარქვათ მას Query Parameters, აქ დავამატებთ ამ ცხრილის სვეტებს: 1) ParameterName, ტიპი string = 25 სიმბოლო. ; ParameterValue, აქ არის მონაცემთა შედგენილი ტიპი, იხილეთ ნახ.
ამიტომ, როგორც სურათზეა ნაჩვენები, პარამეტრის მნიშვნელობის სვეტისთვის ვირჩევთ კომპოზიტურ ტიპს: ტიპის მენიუში, რომელიც იხსნება, მონიშნეთ ჩამრთველი „კომპოზიტური ტიპი“, აირჩიეთ ნომერი, სტრიქონი (მიუთითეთ 20 სიმბოლო), თარიღი, ლოგიკური და შეამოწმეთ. ქვედა ჩამრთველი – AnyLink – ნიშნავს იმას, რაც შემდეგშია, ჩვენი მოთხოვნის პარამეტრების მითითებისას შეგვიძლია მივმართოთ ჩვენი კონფიგურაციის ნებისმიერ ობიექტს, მაგალითად, დირექტორიას ან დოკუმენტს.
ახლა ჩვენ უნდა შევქმნათ ჩვენი მომავალი Query Console-ის ფორმა. დამუშავებისას გადავიდეთ ჩანართზე „ფორმები“ და დავამატოთ ახალი. შევდივართ ამ ფორმაში და უკვე არის შეუზღუდავი ველი კრეატიულობისთვის - თქვენ შეგიძლიათ დაალაგოთ თქვენ მიერ შექმნილი ორი დეტალი და თეფში პარამეტრებით, როგორც გსურთ! ამისათვის შეგიძლიათ გამოიყენოთ სტანდარტული ფორმის ელემენტები, როგორიცაა ჯგუფი ან გვერდი გვერდებით (თუ გსურთ გვერდების ამობრუნება.
აქ მთავარი ერთია: ფორმის რედაქტირების მარცხენა ველში „TextValues“ ატრიბუტის გადატანის შემდეგ, აუცილებლად დააყენეთ „View“=Text Document Field მის თვისებებში.იხილეთ ნახ.
"Query Table" ატრიბუტის თვისებებში შეგიძლიათ სურვილისამებრ მიუთითოთ "Display Grid" და "Display Headers".
შემდეგი, ფორმის რედაქტირებისთვის მარჯვენა ფანჯარაში გადადით "ბრძანებების" ჩანართზე და დაამატეთ ახალი ღილაკი, როდესაც დააწკაპუნებთ, ჩვენი კონსოლი შეასრულებს გარკვეულ მოქმედებას. შევქმნათ "Query Designer" ღილაკი, სურვილის შემთხვევაში შეგიძლიათ ღილაკს დაუმატოთ ხატი, მთავარია თავად ღილაკი მოათავსოთ ფორმის მარცხენა ფორმის რედაქტირების ფანჯარაში - რომ დავინახოთ. შემდეგ სწორი ფორმით. რედაქტირების ფანჯარა, დააწკაპუნეთ მაუსის მარჯვენა ღილაკით ჩვენს ღილაკზე და აირჩიეთ თვისებები – თვისებებში დააწკაპუნეთ „მოქმედების“ პუნქტზე, გამოჩნდება მოდალური ფანჯარა, სადაც იკითხება ზუსტად სად შესრულდება ჩვენი პროგრამის კოდი, რომელსაც მივანიჭებთ ღილაკს – აირჩიეთ „ კლიენტზე“.
ფორმის მოდული გაიხსნება მზა ცარიელი პროცედურით „პროცედურების შეკითხვის კონსტრუქტორი (ბრძანება)“. ამ პროცედურის შიგნით ჩვენ აღვწერთ ზარს სტანდარტული 1c8 Query Builder-თან. ძალიან ადვილია: კონსტრუქტორი = ახალი მოთხოვნის კონსტრუქტორი;მაგრამ აქ არის ხარვეზები - პლატფორმაში ჩაშენებული Query Constructor მუშაობს მომხმარებლის რეჟიმში მხოლოდ სქელი კლიენტის ქვეშ! ამიტომ, ჩვენ ჩავსვამთ წინაპროცესორის ინსტრუქციის მდგომარეობას #If, მაგრამ აქ თქვენ თავად გადაწყვიტეთ, თქვენი პლატფორმიდან გამომდინარე, ან გაქვთ ჩვეულებრივი ფორმები, შემდეგ აირჩიეთ ” FatClientRegular App” ან გაქვთ პლატფორმა მართულ ფორმებზე დაფუძნებული, შემდეგ ” ThickClientManagedApplication„.იხ.
ახლა რჩება ამ პროცედურას დავამატოთ მოთხოვნის ტექსტის ჩაწერის პირობა, რომელსაც შეკითხვის შემქმნელი გამოიმუშავებს ჩვენთვის ჩვენი „მოთხოვნის ტექსტის“ ფორმის დეტალებში:
If Constructor.OpenModal()=True მაშინ Object.RequestText=Constructor.Text; დაასრულე თუ;
მაგრამ ჩვენ შეგვიძლია ხელით შევცვალოთ რაღაც მოთხოვნის ტექსტში (მომხმარებლის რეჟიმში - "მოთხოვნის ტექსტის" ატრიბუტის ფანჯარაში) ისე, რომ ჩვენი ცვლილებები შევიდეს შეკითხვის კონსტრუქტორში, როდესაც ის კვლავ გამოიძახება - აქ დავამატებთ მარტივ პირობას:
თუ არა EmptyString(Object.QueryText) მაშინ Constructor.Text = Object.QueryText; დაასრულე თუ;
ესე იგი, ჩვენ დავაკავშირეთ Query Constructor ჩაშენებული 1c8 პლატფორმაზე, მოდით გადავხედოთ ჩვენს მუშაობას. ამისათვის გაუშვით 1C:Enterprise სქელი კლიენტის რეჟიმში, ერთ-ერთი შემდეგი მეთოდის გამოყენებით: 1) კონფიგურატორის მთავარი მენიუ – გამართვა – გამართვის დაწყება – სქელი კლიენტი; 2) ან თუ თქვენ გაქვთ ეს კლავიშები კონფიგურატორში მართვის პანელზე - უბრალოდ დააჭირეთ ღილაკს ყვითელი წრით სქელი წერტილით, იხილეთ ფიგურა:
1cEnterprise8-ის მომხმარებლის რეჟიმი იწყება, ჩვენ ვპოულობთ ჩვენს დამუშავებას, გავუშვით, ვაწკაპუნებთ ჩვენს ღილაკს „Query Designer“ და ვნახოთ, როგორ იხსნება პლატფორმაში ჩაშენებული დიზაინერი. იხილეთ ნახ.
ასე რომ, ჩვენ გვაქვს Query Constructor გაშვებული, შეგვიძლია დავიწყოთ მასში ჩვენი მომავალი შეკითხვის შეკრება, მაგრამ ჩვენ გვაინტერესებს ვნახოთ, როგორ იმუშავებს ჩვენს მიერ შექმნილი მოთხოვნა! ამისათვის ჩვენ უნდა შევქმნათ კიდევ ერთი ღილაკი კონფიგურატორში ჩვენი კონსოლის ფორმის რედაქტირებისას, მოდით ვუწოდოთ მას "Run Query". ღილაკის "Run Query" თვისებებში დააჭირეთ "მოქმედებას", კვლავ გამოჩნდება მენიუ, რომელშიც გვეკითხებიან, სად დამუშავდება ჩვენი პროგრამის კოდი, ამ შემთხვევაში ვირჩევთ "როგორც კლიენტზე, ასევე სერვერზე". კვლავ აღმოვჩნდებით ფორმების მოდულში.
Execute Query() პროცედურაში, რომელიც გვაქვს კლიენტზე, დავწერთ პირობას, თუ მომხმარებელმა არ შეიყვანა მოთხოვნის ტექსტი, მაგრამ ითხოვს მის შესრულებას:
If EmptyString(Object.QueryText) then report("Enter the query text!"); დაასრულე თუ;
სისტემამ უკვე ავტომატურად შექმნა ბმული Execute RequestOnServer() პროცედურაზე; – კარგია, გადავიდეთ ამ პროცედურაზე, რომელიც შესრულებულია სერვერზე და აქ დავწეროთ ჩვენი შეყვანილი მოთხოვნის შესრულების კოდი.
აქ არის ვარიანტები: თქვენ შეგიძლიათ დაწეროთ ყველა გამონათქვამი, რომელიც დაკავშირებულია queries-ის შექმნასთან, ე.ი. ხელით, მაგრამ არის კიდევ უფრო მარტივი ვარიანტი - პროცედურის შიგნით, დააწკაპუნეთ მაუსის მარჯვენა ღილაკით და ჩამოსაშლელ მენიუში აირჩიეთ "შეკითხვის შემქმნელი შედეგების დამუშავებით, იხილეთ ფიგურა":
თუ დააწკაპუნეთ პუნქტზე „შეკითხვის შემქმნელი შედეგების დამუშავებით“, გამოჩნდება მოდალური ფანჯარა „შეკითხვის ტექსტი ვერ მოიძებნა. შექმნა ახალი?“, დააწკაპუნეთ დიახ. გაიხსნება ჩაშენებული შეკითხვის დიზაინერი, რომელშიც მის პირველ ჩანართზე. "შედეგის დამუშავება" - აირჩიეთ პირველი პუნქტი "შედეგის გვერდის ავლით". ეს ასეა, ამ კონსტრუქტორისგან სხვა არაფერი გვჭირდება, დააჭირეთ ღილაკს "Ok" - გამოჩნდება მოდალური ფანჯარა "მოთხოვნაში ველები არ არის არჩეული, დააჭირეთ "Ok".
ამის შემდეგ, შემდეგი მზა შაბლონი გამოჩნდება ჩვენი ExecuteRequestOnServer() პროცედურის შიგნით:
მოდით გადავიდეთ კონსტრუქტორის მიერ შექმნილ გამონათქვამზე:
Request.Text = "";
Request.Text = Object.RequestText;
ეს რა მარტივია, დამუშავების ფორმაზე ჩვენი ღილაკი „შეასრულე მოთხოვნა“ უკვე პრაქტიკულად ფუნქციონირებს, ჯერჯერობით მას შეუძლია მხოლოდ მარტივი მოთხოვნების დამუშავება პარამეტრების გარეშე, მაგრამ მთავარია ის მუშაობს! რჩება მხოლოდ ჩვენი მოთხოვნის შედეგების ვიზუალურად ჩვენება დამუშავების ფორმაზე „ღირებულებების ცხრილის“ ატრიბუტში. შეგახსენებთ, რომ ჩვენი ატრიბუტი „Value Table“ არის „Tabular Document“ ტიპის, რადგან წინააღმდეგ შემთხვევაში ჩვენ ვერ ვიხილავთ ჩვენს შედეგებს მომხმარებლის რეჟიმში. ტაბულური მონაცემების ჩვენება მომხმარებლისთვის ყოველთვის ხდება ტაბულური დოკუმენტის ან განლაგების საშუალებით. ძალიან მინდა, რომ შესაძლებელი იყოს მონაცემების ჩვენება მნიშვნელობების ცხრილის საშუალებით - რადგან ის ძალიან მარტივი გამოსაყენებელი და ნაცნობია, მაგრამ სამწუხაროდ, მნიშვნელობების ცხრილი არის მხოლოდ ინსტრუმენტი, რომელიც სჭირდება დეველოპერს, თქვენ არ შეგიძლიათ მონაცემების ჩვენება ეკრანზე მისი გამოყენებით...
მოდით უფრო ახლოს მივხედოთ რა არის ცხრილების დოკუმენტი - ეს ჰგავს Excel ფურცელს - შეგიძლიათ მიიღოთ ჩანაწერი კონკრეტულ უჯრედში მხოლოდ ცხრილის უჯრედების გამოყენებით, აქ ჩვენ მათ ვუწოდებთ არეალს, მაგრამ ჩვენ თვითონ შეგვიძლია შევარჩიოთ ამ არეალის დიაპაზონი. ერთ კონკრეტულ უჯრედში:
ასე რომ, ჩვენ გავარკვიეთ, რა არის ცხრილების დოკუმენტი და ჩვენ თვითონ განვსაზღვრეთ, რომ დაგვჭირდება ჩვენი მოთხოვნის მონაცემების განსაზღვრა ამ ცხრილის დოკუმენტის კონკრეტულ უჯრედში. მაგრამ მოდით დავფიქრდეთ: რა არის "შეკითხვის შედეგი", რომელიც დიზაინერმა ასე სწრაფად შექმნა ჩვენთვის? გახსენით დახმარება - შეკითხვის შედეგი არის ცხრილი, რომელსაც აქვს შესაბამისი თვისებები! იხილეთ ნახ.
და თუ ახლა დავწერთ გამოთქმის შემდეგ Query Result = Query.Execute(); (შექმნილია კონსტრუქტორის მიერ), აქ არის ასეთი მარტივი ციკლი კოლექციებისთვის:
თითოეული ColumnName-სთვის შეკითხვის შედეგიდან.Columns Loop report(ColumnName.Name); საბოლოო ციკლი;
ამ ციკლის შემდეგ, ჩაწერეთ კონსტრუქტორის მიერ ავტომატურად აგებული ყველა გამონათქვამი. და გაუშვით 1C:Enterprise8 სქელი კლიენტის ქვეშ. შექმენით ნებისმიერი მარტივი შეკითხვა (შეგიძლიათ გამოიყენოთ Query Builder - ის უკვე მუშაობს ჩვენთან) და დააწკაპუნეთ ღილაკზე “Run Query”:
შეტყობინებების ფანჯრის ბოლოში ნახავთ, რომ შეკითხვის შედეგების ცხრილი ინახავს იმ ველების სახელებს, რომლებიც ახლახან შევარჩიეთ მარტივი მოთხოვნის შექმნით.
ახლა მოდით გამოვავლინოთ ჩვენი ტანჯვის ველების ეს სახელები ცხრილების დოკუმენტში:
თითოეული ColumnName-სთვის Query Result-დან.Columns Loop Cell=Object.QueryTable.Area(1,QueryResult.Columns.Index(ColumnName)+1); Cell.Text=ColumnName.Name; საბოლოო ციკლი;
მოთხოვნის მონაცემების დეტალების საჩვენებლად, მოდით გავაანალიზოთ დიზაინერის მიერ ავტომატურად შექმნილი გამონათქვამები და ჩავსვათ თავად მოთხოვნის დახარისხების ციკლში „SelectionDetailedRecords“ ზუსტად იგივე ციკლში, რომელსაც ვიყენებდით სვეტების სახელების საჩვენებლად, მხოლოდ ახლა გვჭირდება გადატანა. არა "შეკითხვის შედეგი" ცხრილის მონაცემები უჯრედის ტექსტში. და თავად შერჩევის მონაცემები, მოდი ვნახოთ დახმარებაში, როგორ შეგიძლიათ შეხვიდეთ მოთხოვნის დეტალური შერჩევის ველში:
SelectionDetailRecords = QueryResult.Select(); ხოლო SelectionDetailedRecords.Next() Loop //პირველ სტრიქონში უკვე გვაქვს ჩაწერილი ცხრილის სვეტების სახელები, ამიტომ ვტვირთავთ მონაცემებს პირველი lineDocRowNumber=Object.QueryTable.TableHeight+1 ქვემოთ; თითოეული ColumnName-სთვის Query Result.Columns Cycle Cell=Object.QueryTable.Area(DocRowNumber,QueryResult.Columns.Index(ColumnName)+1); Cell.Text = SelectionDetailedRecords[ColumnName.Name]; საბოლოო ციკლი; საბოლოო ციკლი;
ეს ყველაფერია, ჩვენ შეგვიძლია შევამოწმოთ, ჩავტვირთოთ საწარმო სქელი კლიენტის ქვეშ, შევიყვანოთ მარტივი მოთხოვნა პარამეტრების გარეშე, დააწკაპუნოთ ღილაკზე „Run Query“, იხილეთ სურათი:
ჩქარა, ყველაფერი მუშაობს!!!
ძალიან მოსახერხებელია, როდესაც ჩვენი Query Console-ის გახსნის/დახურვისას, ჩვენი მოთხოვნის ტექსტი, რომლითაც ვმუშაობდით კონსოლის დახურვამდე, კვლავ იწერება ველში „Query Text“. ამისათვის თქვენ უბრალოდ უნდა ჩართოთ ფორმის თვისება = Autosave, იხილეთ ნახ:
ესე იგი, ჩვენი კონსოლი მუშაობს. იმისათვის, რომ ჩვენ შეგვიძლია დავწეროთ უფრო რთული მოთხოვნები მათში მითითებული პარამეტრებით, უნდა შევქმნათ კიდევ ერთი ღილაკი "Find Parameters", ისევე როგორც კოდი "Run Query" ღილაკისთვის - შესრულდება ღილაკის "Find Parameters" კოდი. კლიენტზე და სერვერზე. შემდეგ სერვერის პროცედურებში ჩვენ ვაყენებთ მოთხოვნას იმავე გზით მასში გადაცემული ტექსტით "Request Text" ფანჯრიდან, გამოთქმის "Request.FindParameters()" გამოყენებით ვპოულობთ გავლილ პარამეტრებს და უბრალოდ შევიყვანთ მათ ჩაწერეთ "მოთხოვნის პარამეტრების" ფორმის ცხრილის ნაწილში. არ დაგავიწყდეთ, შემდეგ გადაიტანოთ ისინი პარამეტრების შევსებული ცხრილიდან "Run Query" პროცედურაზე.
თქვენ ასევე შეგიძლიათ დაამატოთ რამდენიმე ღილაკი ჩვენს კონსოლში, რომლებიც გაასუფთავებენ პარამეტრების ფანჯარას და მოთხოვნის ტექსტის ფანჯარას მომხმარებლის რეჟიმში.
ჩვენი Query Console მზად არის გამოსაყენებლად, გისურვებთ წარმატებულ კრეატიულ გადაწყვეტილებებს ისეთი მარტივი და ძლიერი ხელსაწყოს გამოყენებით, როგორიცაა Query Console!
ეს დამუშავება იწერება 1c8.3 პლატფორმაზე (მართული ფორმები) და მუშაობს სქელი კლიენტის ქვეშ. ის ასევე შეიძლება დაიწეროს 1c8.2 პლატფორმაზე, როგორც ჩვეულებრივი, ასევე მართული ფორმების ქვეშ.
ჩამოტვირთვა შეიცავს Query Console-ის ნიმუშს, რომელიც ჩვენ ახლახან შევქმენით.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Query Console განახლება:
1) ახლა ჩვენი ხელნაკეთი Query Console ჩაშენებული Query Builder-ით იმუშავებს ნებისმიერი კლიენტის ქვეშ: რეგულარული და მართული ფორმების სქელი კლიენტის ქვეშ და თხელი და ვებ კლიენტის ქვეშ.
p.s. ჩაშენებული Query Builder-ის ფორმა და გარეგნობა განსხვავებულია - იმისდა მიხედვით, თუ რომელ კლიენტზე გავუშვით ჩვენი კონსოლი. (მე პირადად უფრო კარგად ვიცნობ და მოხერხებულს Query Builder-ის ფორმას სქელი კლიენტის ქვეშ)
&კლიენტის პროცედურის შესახებ შეკითხვის კონსტრუქტორი (ბრძანება) //სტანდარტული შეკითხვის კონსტრუქტორის გამოძახება შესაძლებელია მხოლოდ სქელი კლიენტის ქვეშ #If ThickClientManagedApplication ან ThickClientNormalApplication then Constructor=New Query Constructor; თუ არა EmptyString(Object.QueryText) მაშინ Constructor.Text = Object.QueryText; დაასრულე თუ; If Constructor.OpenModal()=True მაშინ Object.RequestText=Constructor.Text; დაასრულე თუ; // #Else // Report("Query Builder-ის გამოძახება შესაძლებელია მხოლოდ სქელი კლიენტის პირობებში"); // Დაბრუნების; //# EndIf #Else Report("თქვენ აწარმოებთ Query Builder-ს თხელი კლიენტის ქვეშ - ის ოდნავ განსხვავდება მისი ფორმითა და შესრულების სიჩქარით!"); კონსტრუქტორი = New QueryConstructor(); თუ არა EmptyString(Object.QueryText) მაშინ Constructor.Text = Object.QueryText; დაასრულე თუ; Constructor Alert = New AlertDescription("RunAfterClosingConstructor", ThisForm); Constructor.Show(Constructor Alert); # EndIf დასრულების პროცედურა &კლიენტის პროცედურაზე ExecuteAfterClosingConstructor(Result, ConstructorParameters) Export //Result=text, თუ კონსტრუქტორი დაიხურა ok ღილაკის გამოყენებით Object.RequestText = AbbreviatedLP(Result); //მუშაობს!!! პროცედურის დასასრული
2) დაემატა ჩვენს მარტივ შეკითხვის კონსოლს რთული მოთხოვნების შეყვანის შესაძლებლობა პარამეტრებზე გადაცემული დროებითი ცხრილით!!! მექანიზმი აღმოჩნდა ძალიან მარტივი და ელეგანტური - XML კოდის გამოყენების გარეშე, როგორც ეს კეთდება პროფესიონალურ კონსოლებში.
თავად კოდი და დროებითი ცხრილების პარამეტრებზე გადაცემის მექანიზმის პროცედურები შეგიძლიათ იხილოთ მეორე თანდართულ ფაილში. როგორ დავიწყე პარამეტრებში დროებითი ცხრილების საკუთარი ვერსიის შემუშავება, შეგიძლიათ იხილოთ ამ ბმულზე https://forum.infostart.ru/forum9/topic183700/
ახლა როგორ გამოვიყენოთ კონსოლი რთული მოთხოვნისთვის, როდესაც დროებითი ცხრილი გადაეცემა მის პარამეტრებს. მაგალითად, შეგიძლიათ აიღოთ ამ მოთხოვნის კოდი;
SELECT ExternalData.Product, ExternalData.Quantity PLACE ExternalData FROM &ExternalData AS ExternalData; //////////////////////////////////////////// ////////////////////////// აირჩიეთ ExternalData.Product, ExternalData.Quantity, ISNULL(RemainingProductRemaining.QuantityRemaining, 0) AS ველი1, ISNULL(დარჩენილი ProductsRemainings.QuantityRemainings, 0) - ExternalData.Quantity AS Remaining FROM ExternalData AS ExternalData LEFT JOIN რეგისტრაცია აკუმულაციები.დარჩენილი პროდუქტები.ნარჩენები(&თარიღი, პროდუქტი შეყვანილია (SELECT ExternalData.Product FROMASsReternalDatain) სადინარი = RemainingProductRemaining პროდუქტი
ზემოთ მოყვანილი მოთხოვნის კოდის მაგალითზე და მსგავსებაზე დაყრდნობით, თქვენ შეგიძლიათ შექმნათ თქვენი საკუთარი რთული მოთხოვნა, თქვენი მონაცემთა ობიექტების გათვალისწინებით.
ასე რომ, შეკითხვის დიზაინერში ჩვენ შევქმენით ზემოაღნიშნული მოთხოვნა, ვხურავთ კონსტრუქტორს - შეკითხვის ტექსტი შევა ჩვენი კონსოლის ველში "Query Text", დააჭირეთ ღილაკს "პარამეტრების ძებნა", ჩვენ ვხედავთ, რომ პარამეტრების ცხრილში გამოჩნდა ხაზი. = „გარე მონაცემები“, მნიშვნელობის ტიპი = „მნიშვნელობების ცხრილი“ იხილეთ ნახ.
პარამეტრების ამ ცხრილში - შეიყვანეთ თარიღის პარამეტრი, მაგალითად, დღევანდელი თარიღი, შემდეგ დააწკაპუნეთ, რომ შეეცადოთ შეცვალოთ ჩვენი ცხრილის დროებითი პარამეტრი "გარე მონაცემები", დააწკაპუნეთ ველზე "მნიშვნელობების ცხრილი" სამ წერტილზე - ტიპების შერჩევა მოხდება. გამოჩნდება, დააწკაპუნეთ Row, ჩვენი მექანიზმი გვიბრუნებს გვერდს ფორმაში, სადაც ხელით უნდა შევიტანოთ ეს ძალიან დროებითი ცხრილი.
აქვე გაითვალისწინეთ, რომ ამ შემთხვევაში, ბოლოში „TimeTables“ გვერდზე „დროებითი ცხრილის სახელი პარამეტრებში“ ველში გამოჩნდება ჩვენი დროებითი ცხრილის სახელი (ის დაკოპირებულია პარამეტრების ცხრილიდან).
ჯერჯერობით „დროის ცხრილების“ გვერდზე მხოლოდ ერთ ცარიელ ცხრილს ვხედავთ - ეს არის ჩვენი მომავალი დროებითი ცხრილის ტიპების ცხრილი. ღილაკის „დამატების“ გამოყენებით დავამატებთ დეტალების სახელს და მომავალი ცხრილის ტიპს. . იყავით ფრთხილად - სახელი და ტიპი უნდა ემთხვეოდეს იმას, რაც ჩვენ მითითებულია მოთხოვნაში &ExternalData:
ახლა ჩვენ ვაჭერთ ღილაკს "დროებითი ცხრილის განახლება" - და აქ გვექნება მეორე ცხრილი - ჩვენ პირდაპირ შევავსებთ მას ცხრილის დროებითი მონაცემებით ღილაკის "დამატების" საშუალებით.
ესე იგი, შეგვიძლია კიდევ ერთხელ გადავამოწმოთ, შევიყვანეთ თუ არა შეკითხვის პარამეტრების პრიმიტიული მონაცემები დამუშავების პირველ გვერდზე პარამეტრთა ცხრილში და დააწკაპუნეთ ღილაკზე “Run Query” - ყველაფერი გამოითვლება და შესაბამისად შეირჩევა ჩვენი დროებითი ცხრილის პარამეტრში გადაცემული მონაცემების შეზღუდვა
p.s. თუ შეცდომა დაუშვით დეტალების სახელის და მათი ტიპების აკრეფისას (პირველ ცხრილში) - უბრალოდ დახურეთ კონსოლი და კვლავ გახსენით - დროებითი მონაცემების ცხრილი წაიშლება - და ტიპების ცხრილი შეიძლება კვლავ რედაქტირდეს და ახალი მონაცემთა ცხრილი შეიძლება ხელახლა შეიქმნას.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
სულ ეს არის, ჩვენ შეგვიძლია შევქმნათ ძალიან ძლიერი სამუშაო ინსტრუმენტი ჩვენი ხელით, გარდა ამისა, ჩვენი კონსოლი ჯერ კიდევ ძალიან სწრაფია პროფესიონალებთან შედარებით - და ეს ძალიან დიდი პლუსია დეველოპერებისთვის! და, რა თქმა უნდა, ახლა ჩვენი კონსოლი მუშაობს ნებისმიერი კლიენტის ქვეშ! წარმატებებს გისურვებთ შემოქმედებით განვითარებაში!!!
ვნახოთ, როგორ შეგვიძლია გავაერთიანოთ ეს ორი ცხრილი ველების მიხედვით Პროდუქტის კოდიგამოყენებით
შეკითხვის კონსტრუქტორი (მაგალითად მოცემულია დროებითი ცხრილების შექმნის კოდი
მე არ გავაკეთებ. შეგიძლიათ აიღოთ ზემოთ მოცემული ბმულიდან).
გახსენით დიზაინერის ფანჯარა, გადადით ჩანართზე "ცხრილები და ველები", განყოფილებამდე
"მაგიდები"აირჩიეთ ჩვენი ორივე ცხრილი და განყოფილებაში "ველები" -
ის ველები ორივე ცხრილიდან, რომელთა ნახვა გვინდა მოთხოვნის შედეგად.
გადადით სანიშნეზე "კავშირები". დაამატეთ ახალი ხაზი. მინდორში ცხრილი 1
ჩამოსაშლელი სიიდან აირჩიეთ ცხრილი პროდუქტებით და ველში ცხრილი 2მაგიდა
ქვეყნებთან.
ამისთვის ცხრილები 1შეამოწმეთ ყუთი ყველა. ამისთვის
ცხრილები 2ჩვენ არ ვამოწმებთ ამ ველს. ეს ნიშნავს, რომ დან ცხრილები 1
ყველა ჩანაწერი შეირჩევა და დან ცხრილები 2მხოლოდ მათთვის, რისთვისაც იგი შესრულებულია
კავშირის მდგომარეობა, ანუ დროშების ასეთი კომბინაციით ვიღებთ
მარცხენა კავშირი. შემდეგი თქვენ უნდა შეავსოთ კომუნიკაციის მდგომარეობა.
აქ ჩვენ ვირჩევთ ცხრილის ველებს ჩამოსაშლელი სიებიდან და შედარების ნიშანს ასევე ჩამოსაშლელი სიიდან
სია. 
ამ კავშირის შედეგად, ჩვენ ვიღებთ მოთხოვნის შემდეგ ტექსტს:
აირჩიეთ VT_Product.Product Code, VT_Product.Name, VT_Country.Country FROM VT_Product AS VT_Product LEFT JOIN VT_Country AS VT_Country VT_Product.პროდუქტის კოდი = VT_Country.Product
ახლა მოდით უფრო ახლოს მივხედოთ ზოგიერთ პუნქტს.
შევეცადოთ შევცვალოთ ჩამრთველი ყველა.
როგორც ჩანს, საბოლოოდ ეს უნდა გამოვიდეს მარჯვენა შეერთება, მაგრამ თუ ჩვენ
მოდით შევხედოთ კონსტრუქტორის მიერ გამომუშავებულ შეკითხვის ტექსტს, დავინახავთ, რომ ცხრილები
ადგილები გავცვალე, მაგრამ კავშირი მაინც დარჩა:
აირჩიეთ VT_Product.Product Code, VT_Product.Name, VT_Country.Country FROM VT_Country AS VT_Country LEFT JOIN VT_Product AS VT_Product VT_Product.პროდუქტის კოდი = VT_Country.Product
ვნახოთ, რა მოხდება, თუ მოვხსნით ორივე ველს 
შედეგად, ჩვენ ვიღებთ შიდა კავშირს.
აირჩიეთ VT_Product.Product Code, VT_Product.Name, VT_Country.Country FROM VT_Product AS VT_Product INTERNAL JOIN VT_Country AS VT_Country VT_Product.პროდუქტის კოდი = VT_Country.Product.
და ბოლოს, თუ ორივე ველი მონიშნულია 
ჩვენ ვიღებთ სრულ კავშირს
აირჩიეთ VT_Product.Product Code, VT_Product.Name, VT_Country.Country FROM VT_Product AS VT_Product FULL CONNECTION VT_Country AS VT_Country BY VT_Product.პროდუქტის კოდი = VT_Country.Product
თქვენ შეგიძლიათ მიუთითოთ რამდენიმე ხაზი სანიშნეზე კავშირები. ამ შემთხვევაში რამდენიმე
რიგები დაკავშირებულია პირობით და. უფრო მეტიც, ხაზები არ არის საჭირო
ყოველ ჯერზე ხელახლა შედით. მათი კოპირება შესაძლებელია გასაღების გამოყენებით F9.
ხოლო ახალ ხაზში შეცვალეთ მხოლოდ კავშირის მდგომარეობა. ეს მნიშვნელოვნად აჩქარებს განვითარებას.
ასევე, ბმულის მდგომარეობაში არ არის საჭირო მხოლოდ წინასწარ განსაზღვრული ველების გამოყენება
ჩამოსაშლელი სიები. თქვენ შეგიძლიათ გამოიყენოთ თვითნებური გამოხატულება, რომელიც აკმაყოფილებს
1C შეკითხვის ენა. ამისათვის თქვენ უნდა შეამოწმოთ ყუთი უფასო
და შეიყვანეთ პირობა პირდაპირ ველში, ან გახსენით დამხმარე ფანჯარა
სადაც შეგიძლიათ გამოიყენოთ შაბლონები შეკითხვის ენის ფუნქციებით. 
რა თქმა უნდა, პრაქტიკაში არის ბევრად უფრო რთული კითხვები სად
რამდენიმე მაგიდა ერთმანეთთან სხვადასხვა კავშირებით. მაგრამ შეკითხვის შემქმნელში
ნებისმიერი სირთულის კავშირების რეპროდუცირება შესაძლებელია.
შეკითხვის დიზაინერი შედგება შემდეგი ჩანართებისგან:
1. "ცხრილები და ველები" - ჩანართზე არის სამი იერარქიული სია:
ა. "მონაცემთა ბაზა" - ჩამოთვლის ყველა ხელმისაწვდომ ობიექტს, რომლებზეც შეიძლება შეკითხვის გაკეთება. ასევე ღილაკი "გაცვლის ცხრილების ჩვენება", რომლითაც შეგიძლიათ მიიღოთ ინფორმაციული უსაფრთხოების ობიექტების ცვლილებების ცხრილები, თუ ისინი დარეგისტრირებულნი არიან რაიმე გაცვლის გეგმაზე.
ბ. "ცხრილები" - შერჩეული ცხრილების სია, რომლებზეც შესრულდება მოთხოვნა. ასევე ამ ფანჯარაში შეგიძლიათ წაშალოთ ცხრილი, გადაარქვათ ან შეცვალოთ ცხრილი და დაამატოთ შიდა მოთხოვნა.
ვირტუალური ცხრილებისთვის პარამეტრების მინიჭება შეგიძლიათ ღილაკზე „ვირტუალური ცხრილების პარამეტრები“ დაწკაპუნებით:
მიზანშეწონილია ვირტუალური ცხრილების პარამეტრების აქტიური გამოყენება გარკვეული განზომილებებით შერჩევისთვის, რადგან ეს ზრდის შეკითხვის შესრულების სიჩქარეს. პარამეტრებში შეგიძლიათ გამოიყენოთ გარე ცვლადები, რომელთა სახელებს წინ უძღვის "&" ნიშანი.
გ. "ველები" - ველების სია, რომლებიც არჩეულია ცხრილებიდან. თქვენ ასევე შეგიძლიათ დაამატოთ გამოთვლილი ველები; ამისათვის ღილაკზე „დამატება“ დაწკაპუნებით იხსნება პერსონალური გამოხატვის კონსტრუქტორი:
მარცხნივ არის ფანჯარა გამონათქვამში არსებული ველებით. მარჯვნივ არის გამოყენებული ფუნქციების მინიშნება. ქვემოთ არის კონსტრუქციული თვითნებური გამოხატულება. თქვენ შეგიძლიათ გამოიყენოთ გარე პარამეტრები გამონათქვამებში; ისინი აღინიშნება "&" ნიშნით, მაგალითად: &პერიოდი, &დაწყების თარიღი
ფრთხილად უნდა იყოთ, თუ ფანჯარაში აკრეფილია გრძელი და რთული გამოთქმა, რომელიც შეიცავს მცირე სინტაქსურ შეცდომას, მაშინ ღილაკზე „OK“ დაჭერის შემდეგ სისტემა გამოსცემს გაფრთხილებას და დახურავს ფანჯარას. ყველა აკრეფილი კოდი დაიკარგება, ამიტომ გირჩევთ, თუ არ ხართ დარწმუნებული გამოხატვის სისწორეში, ყოველთვის შეინახოთ შიგთავსი ბუფერში (Ctrl-C) კონსტრუქტორის დახურვამდე.
2. „ურთიერთობები“ - ჩანართზე მითითებულია კავშირები ცხრილებს შორის.
ცხრილი მიუთითებს დასაკავშირებელ ცხრილებს, დასაკავშირებელ ცხრილებს შორის ურთიერთობას და კავშირის მდგომარეობას. თუ კავშირის პირობა რთულია, მაშინ შეგიძლიათ მიუთითოთ გარკვეული გამოთვლილი გამოხატულება და გაიხსნება მორგებული ველის კონსტრუქტორი.
3. „დაჯგუფება“ - ჩანართი მიუთითებს რომელი ველებია დაჯგუფებული და რომელია აგრეგირებული (ჯამდება).
4. ჩანართი „პირობები“ - ჩამოთვლილია მოთხოვნები, რომლებიც დაწესებულია მოთხოვნაზე.
პირობებში, თქვენ ასევე შეგიძლიათ დაწეროთ რთული გამონათქვამები მარტივი გამოხატვის კონსტრუქტორის გამოყენებით და გარე ცვლადების გამოყენებით:
5. "მოწინავე"
მოთხოვნაზე დაწესებული დამატებითი პარამეტრები
6. „ასოციაციები და ფსევდონიმები“
ამ ჩანართზე შეგიძლიათ მივანიჭოთ ფსევდონიმები ველებისთვის, ასევე მართოთ მოთხოვნები, რომლებიც დაკავშირებულია „UNITE“ ან „UNITE ALL“ კონსტრუქციებით.
7. "შეკვეთა"
რა თანმიმდევრობით გამოჩნდება შეკითხვის შედეგები?
ყურადღება! სანიშნეის ბოლოში შეგიძლიათ იხილოთ გამშვები ნიშანი "ავტომატური შეკვეთა"- ACS-ში 1C 8.1-ის მიმდინარე ვერსიაში, ეს უსარგებლოა; უფრო მეტიც, როდესაც ჩამრთველი არის მონიშნული, ჩაწერისას, ACS იძლევა შეცდომას, ასე რომ თქვენ არ უნდა გამოიყენოთ იგი.
8. "მონაცემთა შემადგენლობა"
ჩანართი, რომელშიც განსაზღვრულია წვდომის კონტროლის სისტემის მომსახურების ველები. ის დაახლოებით იგივე როლს ასრულებს, როგორც "ანგარიშის შემქმნელი" ჩანართი რეგულარული მოხსენების დიზაინერში.
ა. ჩანართზე „ცხრილები“ - მითითებულია მოთხოვნაში გამოყენებული ცხრილები, თქვენ შეგიძლიათ მიუთითოთ, უნდა იყოს თუ არა ცხრილი შეტანილი მოთხოვნაში „საჭირო“ ველის მონიშვნით. იმათ. თუ არ არის შერჩეული ველი, მაშინ ეს ცხრილი საერთოდ არ მონაწილეობს მოთხოვნაში. თქვენ ასევე შეგიძლიათ მიუთითოთ ცხრილების პარამეტრები.
წვდომის კონტროლის სისტემის დაყენების პროცესში ჩვენ ვაზუსტებთ ნებისმიერ არჩევანს, შემდეგ ყველა შერჩევის მნიშვნელობა შეიცვლება ვირტუალური ცხრილების პარამეტრებში, რაც კვლავ დაგვეხმარება მოთხოვნის ოპტიმიზაციაში და დაჩქარებაში.
ბ. "ველების" ჩანართზე ჩამოთვლილია ველები და მათი მეტსახელები, რომლებიც დაემატება ACS ველების სიას.
გ. "პირობები" - თუ არჩევანი მითითებულია ACS პარამეტრებში, შერჩევის ყველა მნიშვნელობა დაემატება როგორც დამატებითი პირობები; რთული გამონათქვამები ასევე შეიძლება დაემატოს პირობებს.
9. „მახასიათებელი“
სანიშნე, რომელსაც არ აქვს ანალოგი ჩვეულებრივი გამომავალი ფორმის კონსტრუქტორში.
ეს ჩანართი საშუალებას გაძლევთ გააფართოვოთ მოთხოვნების მუშაობა მახასიათებლებით. ცხრილი ჩანართზე შედგება რამდენიმე ველისაგან:
ა. "ღირებულების ტიპი" - ტიპი, რომლისთვისაც შეირჩევა მახასიათებლები. მაგალითად, თუ მიუთითებთ "Directory Link.Nomenclature", მაშინ მოთხოვნაში შეირჩევა ნომენკლატურის ყველა მახასიათებელი.
ბ. "წყარო" - დამახასიათებელი ტიპების თვისებების წყარო შეიძლება იყოს მოთხოვნა ან ცხრილი. ამ ველში შეგვიძლია დავწეროთ მოთხოვნა, რომ შევარჩიოთ მხოლოდ ის თვისებები, რომლებიც გვჭირდება.
გ. "მახასიათებლების სია" - ველი, რომელშიც მითითებულია მახასიათებლების თვისებების წყარო. ყველაზე ხშირად ეს არის დამახასიათებელი ტიპების გეგმა ან მოთხოვნა. თქვენ ასევე უნდა მიუთითოთ ველები, რომლებიც პასუხისმგებელია ქონების „იდენტიფიკატორზე“, „სახელზე“ და „ტიპზე“.
დ. "წყარო" არის შემდეგი ველი, რომელშიც ჩვენ მივუთითებთ დამახასიათებელი მნიშვნელობების წყაროს, რომელიც ასევე შეიძლება იყოს ცხრილი ან მოთხოვნა.
ე. „მახასიათებელი მნიშვნელობა“ არის ცხრილი ან მოთხოვნა, რომელიც იღებს დამახასიათებელ მნიშვნელობებს. მაგალითად, საინფორმაციო რეესტრი "ObjectPropertyValues" შეიძლება იყოს მახასიათებლების მნიშვნელობების ცხრილი. ჩვენ ასევე უნდა მივუთითოთ ცხრილიდან (ან მოთხოვნით) ის ველები, რომლებიც პასუხისმგებელნი არიან მახასიათებლის „ობიექტზე“, „საკუთრებაში“ და „მნიშვნელობაზე“.
მოთხოვნის რედაქტირების შემდეგ, მოთხოვნის ტექსტის ნახვა შესაძლებელია ველების სიის ქვეშ არსებულ ფანჯარაში. ქვემოთ, „ავტომატური შევსების“ ჩამრთველით, შეგვიძლია დავარეგულიროთ დამატებითი პარამეტრების შევსება მოთხოვნაში მითითებული ველებისთვის. გთხოვთ გაითვალისწინოთ, რომ ველების შემადგენლობა განისაზღვრება მხოლოდ თავად მოთხოვნაში.
ინფორმაცია აღებულია საიტიდან
დღეს ჩვენ ვისაუბრებთ იმაზე, თუ როგორ უნდა გავაკეთოთ ჩადგმული კითხვებიგამოყენებით შეკითხვის შემქმნელი. პირდაპირ მაგალითზე გადავიდეთ.
ვთქვათ, გვაქვს ინფორმაციის ეს მარტივი რეესტრი, სადაც ფასები ინახება საქონლისა და მომწოდებლების მიერ:
ჩვენ გვინდა მოვითხოვოთ ყველა პროდუქტის მიღება, რომელსაც ჰყავს ერთზე მეტი მიმწოდებელი. ეს შეიძლება განხორციელდეს შემდეგი შეკითხვის გამოყენებით:
SELECT Number of Suppliers.Product AS Product FROM (SELECT Price.Product AS Product, QUANTITY(DIFFERENT Price.Supplier) AS Suppliers FROM RegisterInformation.Price AS Price GROUP By Price.Product) AS მომწოდებლების რაოდენობა WHERE 1 მომწოდებლების რაოდენობა.
კონსტრუქტორში ჩადგმული შეკითხვის ფორმირება
მოდით შევქმნათ ზემოაღნიშნული მოთხოვნა კონსტრუქტორის გამოყენებით.
ამისათვის, ველის ზემოთ ბრძანების პანელში მაგიდებიდააჭირეთ ღილაკს შექმენით ქვემოთხოვნა:
რის შემდეგაც გაიხსნება ფანჯარა შეკითხვის კონსტრუქტორის სხვა ეგზემპლარით: 
და ამ ახალ ფანჯარაში ჩვენ ვაშენებთ ჩადგმულ შეკითხვას: 
ღილაკზე დაჭერით მოთხოვნაქვედა მარცხენა კუთხეში ჩვენ ვხედავთ ქვემოთხოვნის ტექსტს: 
დამხმარე კონსტრუქტორში OK ღილაკზე დაჭერის შემდეგ მთავარ ფანჯარაში ვიღებთ შემდეგ სურათს: 
ფრაზიდან გამომდინარე NestedQueryარც თუ ისე მოსახერხებელი აღქმისთვის, მოდით გამოვიყენოთ მაუსის მარჯვენა ღილაკი ცხრილის სახელის გადარქმევისთვის მომწოდებლების რაოდენობააირჩიეთ ველი მისგან პროდუქტიდა სანიშნეზე პირობებიჩამოვწეროთ აუცილებელი პირობა: 
და ყველა ამ მანიპულაციის შემდეგ ვიღებთ სასურველ მოთხოვნას. საჭიროების შემთხვევაში, შეგიძლიათ შექმნათ მოთხოვნები ბუდეების რამდენიმე დონის გამოყენებით.
როგორ გავაკეთოთ წყობილი მოთხოვნა კონსტრუქტორში ჩვეულებრივი მოთხოვნიდან
ძალიან ხშირად ჩნდება სიტუაცია, როდესაც იწყებ მოთხოვნის გაკეთებას კონსტრუქტორში და რაღაც მომენტში ხვდები, რომ ის უნდა იყოს წყობილი. რა თქმა უნდა, ჩვენს მაგალითში პრობლემა არ არის - შეგიძლიათ უბრალოდ წაშალოთ ყველაფერი და ხელახლა გასცეთ მოთხოვნა. მაგრამ პრაქტიკაში, არსებობს ბევრად უფრო რთული მაგალითები, მაგალითად, რამდენიმე დონის ბუდე, როდესაც რამდენიმე საათი დაიხარჯა მოთხოვნის გაკეთებაზე. და ამ შემთხვევაში არის საკმაოდ მარტივი გამოსავალი. თქვენ შეგიძლიათ გამოიყენოთ შეკითხვის ტექსტის რედაქტორი, რომელიც ჩაშენებულია დიზაინერში. საჭიროა ღილაკის გამოყენება მოთხოვნამიიღეთ მოთხოვნის ტექსტი (იხილეთ სურათი ზემოთ) და დააკოპირეთ იგი ბუფერში. შემდეგი, შექმენით ახალი ჩასმული მოთხოვნა და კვლავ დააჭირეთ ღილაკს მოთხოვნა, ჩასვით ტექსტი ბუფერიდან, დააწკაპუნეთ OK. შესაბამისად, ჩვენ ვასუფთავებთ ძველ მოთხოვნას უმაღლეს დონეზე. ამ გზით, საჭიროების შემთხვევაში, ჩვენ შეგვიძლია მარტივად შევქმნათ მრავალდონიანი წყობილი მოთხოვნები.
შეკითხვის ტექსტის „ხელით“ დაწერის შესაძლებლობა არასოდეს ყოფილა „ზედმეტი“, მაგრამ უფრო მოსახერხებელია შეკითხვის დიზაინერის გამოყენება.
კომენტარი.
სამწუხაროდ, მართულ აპლიკაციაში, თქვენ არ შეგიძლიათ გამოიყენოთ შეკითხვის დიზაინერი "გაცნობა შეკითხვით" დამუშავებაში. თქვენ შეგიძლიათ გამოიყენოთ იგი ამ დამუშავებისას ნორმალურ რეჟიმში გადასვლით, მაგრამ ჩვენ ამას არ გავაკეთებთ.
შევქმნათ „მოთხოვნის კონსტრუქტორი“ დამუშავება და განვსაზღვროთ „ანგარიშები და დამუშავება“ ქვესისტემაში.
შევქმნათ დამუშავების ფორმა და მასში დავამატოთ "Tabular Document" ტიპის "TabDoc" ფორმის ატრიბუტი, ასევე ბრძანება "Run Query" მოქმედებით "Run Query". შემდეგი, გადაიტანეთ ისინი ფორმაზე.
ფორმის მოდულში, ბრძანების მუშაობისთვის, ჩვენ ვწერთ პროცედურას:
&OnClient
შეკითხვის შესრულების პროცედურა (ბრძანება)
ExecuteRequestServer();
პროცედურის დასასრული
&სერვერზე
პროცედურის დასასრული
ჩვენ ვხდებით სერვერზე გამოძახებულ პროცედურაში და კონტექსტური მენიუდან მოვუწოდებთ „Query კონსტრუქტორის შედეგების დამუშავებით“ (სურათი 2.65).
სურათი 2.65 შეკითხვის კონსტრუქტორი შედეგების დამუშავებით
დააყენეთ დამუშავების ტიპი „გამომავალი ელცხრილის დოკუმენტში“ და დააჭირეთ ღილაკს „შემდეგი“ ან „ცხრილები და ველები“ ჩანართზე.
დიზაინერის ჩანართზე „ცხრილები და ველები“ შეგიძლიათ იხილოთ სისტემაში ამჟამად არსებული ცხრილები (მარცხენა ნაწილი სახელწოდებით „მონაცემთა ბაზა“) (სურათი 2.66).
სურათი 2.67 შეკითხვის კონსტრუქტორი
ცხრილები, საიდანაც მოთხოვნა მიიღებს მონაცემებს, გადადის "ცხრილების" ზონაში, მოთხოვნისთვის საჭირო ველები გადადის "ველების" ზონაში. მოდით გავაკეთოთ ისე, როგორც სურათზე 2.68.
ნახ 2.68 შეკითხვის კონსტრუქტორი
აქ ჩვენ წავშალეთ შექმნილი ნაგულისხმევი ხედის ველი - “PRERESENTATION (პროდუქტის მიღებაპროდუქტები.ნომენკლატურა)”
დიზაინერთან მუშაობისას ნებისმიერ დროს შეგიძლიათ ნახოთ მიღებული მოთხოვნის ტექსტი. ამ ამოცანის შესასრულებლად, თქვენ უნდა დააჭიროთ ღილაკს „მოთხოვნა“, რომელიც მდებარეობს დიზაინერის ფორმის ქვედა მარცხენა კუთხეში (სურათი 2.69).
თქვენ შეგიძლიათ ხელით შეცვალოთ მოთხოვნის ტექსტი ღილაკზე „რედაქტირება“ დაწკაპუნებით.
ივარჯიშე. დააჭირეთ ღილაკს "OK" და შეამოწმეთ ჩვენი დამუშავება მომხმარებლის რეჟიმში. თუ თქვენ გააანალიზებთ მოთხოვნის შესრულებისას მიღებულ მონაცემებს, შეგიძლიათ წააწყდეთ ნივთების ერთეულების „გამეორებას“ (თუ ეს არ გამოგადგებათ, მაშინ შეგიძლიათ დააკოპიროთ და განათავსოთ ნებისმიერი „საქონლის მიღება“ დოკუმენტი).
ჩვენ ვუბრუნდებით ExecuteRequestServer() პროცედურას "Request Constructor" დამუშავებაში და კონტექსტური მენიუდან კვლავ მოვუწოდებთ "Query Constructor შედეგების დამუშავებით".
თუ გსურთ მოთხოვნის შედეგის „დაშლა“, მაშინ ამ მიზნით შეგიძლიათ გამოიყენოთ შეკითხვის დიზაინერის ჩანართი „დაჯგუფება“.
დაჯგუფების განსაზღვრისას უნდა დაიცვან შემდეგი წესი: შეკითხვის შერჩევის ყველა ველი იყოფა ველებად, რომლებითაც ხდება დაჯგუფება (კონვოლუცია), ჩადგმული ცხრილების ველებად (ველები, რომლებიც შეჯამებულია იმ ველებთან, რომლებითაც ხორციელდება დაჯგუფება) და აგრეგაცია. ფუნქციები. განვსაზღვროთ დაჯგუფებები (სურათი 2.70).
სურათი 2.70 შეკითხვის შემქმნელი
თუ მოთხოვნით მიღებული მონაცემები უნდა შეირჩეს რაიმე პირობის მიხედვით, მაშინ ამ შემთხვევაში შესაძლოა საჭირო გახდეს ჩანართის „პირობების“ გამოყენება. ავირჩიოთ Goods ReceiptGoods.Quantity=10 (სურათი 2.71).
სურათი 2.71 შეკითხვის კონსტრუქტორის მდგომარეობა.
გთხოვთ გაითვალისწინოთ, რომ თუ პირობა განისაზღვრა ისე, როგორც ფიგურაში, მოთხოვნა არ შესრულდება.
სიტუაციის გამოსწორების ორი გზა არსებობს:
პირობის ხელახალი განსაზღვრით „P...“ დროშის შემოწმებით;
თავად მოთხოვნის ტექსტის შეცვლის შესაძლებლობის გამოყენებით (მიღებულია ღილაკზე „მოთხოვნის რედაქტირების“ დაწკაპუნებით).
თავად სახელმძღვანელო ცვლილება შედგება იმაში, რომ აუცილებელია "&" სიმბოლოს ამოღება ნომრამდე "10". მოთხოვნის ტექსტში ეს სიმბოლო განსაზღვრავს მოთხოვნის პარამეტრებს, რომლებშიც გარკვეული მნიშვნელობები უნდა ჩაიწეროს მოგვიანებით (მაგრამ მოთხოვნის შესრულებამდე). დააწკაპუნეთ ღილაკზე „შეკითხვის რედაქტირება“ და შეცვალეთ (სურათი 2.72).
სურათი 2.73 შეკითხვის რედაქტირება
"Advanced" ჩანართზე შეგიძლიათ შეამოწმოთ რამდენიმე დროშა (დაკავშირებული შეკითხვის ენის საკვანძო სიტყვასთან "Select") და განსაზღვროთ მოთხოვნის შესაცვლელად განკუთვნილი ცხრილების შემადგენლობა (სურათი 2.74).
სურათი 2.74 დამატებითი მოთხოვნის ფუნქციები
ჩანართზე „შეერთება/ცალსახადები“ შეგიძლიათ შეცვალოთ ველების სახელები „ალიასების“ დაყენებით, მაგრამ ჩვენ ამას არ გავაკეთებთ.
ჩანართზე „Order“ შეგიძლიათ განსაზღვროთ ჩანაწერების დახარისხების თანმიმდევრობა შეკითხვის შედეგად (სურათი 2.75).
სურათი 2.75 ჩანაწერების დალაგების თანმიმდევრობა
ყურადღება მიაქციეთ "ავტომატური შეკვეთის" დროშას, მისი გამოყენება შესაძლებელია საცნობარო ტიპის ველების შეკვეთისთვის.
განყოფილების „სულების“ განსაზღვრისას, მზად უნდა იყოთ იმისთვის, რომ მოთხოვნის შედეგად გამოჩნდება „დამატებითი“ ჯამური ჩანაწერები. ამ ჩანაწერებთან ერთად, შეკითხვის შედეგი ხდება იერარქიული (სურათი 2.76).
სურათი 2.76.შეკითხვის კონსტრუქტორის შედეგები.
შესაძლებელია რამდენიმე ტიპის ჯამების დაზუსტება:
ელემენტები (შეკითხვის შედეგების შერჩევა შეიცავს დაჯგუფების ჯამებსა და დეტალურ ჩანაწერებს);
იერარქია (შეკითხვის შედეგის შერჩევისას, ზოგად შემთხვევაში, არის შემაჯამებელი ჩანაწერები იერარქიის მიხედვით, შემაჯამებელი ჩანაწერები დაჯგუფების მიხედვით და დეტალური ჩანაწერები);
მხოლოდ იერარქია (შეკითხვის შედეგების შერჩევისას, ზოგადად, არის შემაჯამებელი ჩანაწერები იერარქიის მიხედვით).
კონსტრუქტორის ღილაკზე „Ok“ დაწკაპუნების შემდეგ წარმოიქმნება „Layout“ და ExecuteRequestServer() პროცედურის კოდი ჩაიწერება ფორმის მოდულში:
&სერვერზე
პროცედურა ExecuteRequestServer()
//((QUERY_CONSTRUCTOR_WITH_RESULT_PROCESSING
// ეს ფრაგმენტი აგებულია კონსტრუქტორის მიერ.
// კონსტრუქტორის ხელახლა გამოყენებისას ხელით შესრულებული ცვლილებები დაიკარგება!!!
Layout = Processing.QueryConstructor.GetLayout("Layout");
მოთხოვნა = ახალი მოთხოვნა;
მოთხოვნა.ტექსტი =
| საქონლის მიღება საქონლის ნომენკლატურა AS ნომენკლატურა,
| SUM (საქონლის საქონლის მიღება. რაოდენობა) AS რაოდენობა,
| SUM (საქონლის საქონლის მიღება. თანხა) AS Amount
| დოკუმენტი.საქონლის მიღება.საქონელი
| როგორ მივიღოთ პროდუქტები
| საქონლის მიღება საქონლის რაოდენობა > 1
|ჯგუფი
| საქონლის მიღება საქონელი.ნომენკლატურა
|შეკვეთა
| რაოდენობა,
| თანხა კლება
| SUM (რაოდენობა),
| ჯამი (ჯამობა)
| ნომენკლატურა იერარქია“;
შედეგი = Query.Run();
HeaderArea = Layout.GetArea("Header");
AreaFooter = Layout.GetArea("Footer");
TableHeadArea = Layout.GetArea("TableHeader");
TableFooterArea = Layout.GetArea("TableFooter");
AreaNomenclatureHierarchy = Layout.GetArea("NomenclatureHierarchy");
AreaNomenclature = Layout.GetArea("ნომენკლატურა");
TabDoc.Clear();
TabDoc.Output(AreaHeader);
TabDoc.Output(TableHeadArea);
TabDoc.StartAutoGroupingRows();
SelectionNomenclature = Result.Select(BypassQueryResult.ByGrouping);
ხოლო SelectionNomenclature.Next() ციკლი
თუ SelectionNomenclature.RecordType() = RequestRecordType.TotalByHierarchy მაშინ
ფართობი = AreaNomenclatureHierarchy;
რეგიონი = რეგიონის ნომენკლატურა;
დაასრულე თუ;
Area.Parameters.Fill(SelectionNomenclature);
TabDoc.Output(Area, SelectionNomenclature.Level());
საბოლოო ციკლი;
TabDoc.FinishAutoGroupingRows();
TabDoc.Output(TableFooterArea);
TabDoc.Output(AreaFooter);
//))CONSTRUCTOR_QUERY_WITH_RESULT_PROCESSING
