მარტივი მოთხოვნები. მარტივი მოთხოვნები 1-იანი სერიული მოთხოვნა

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

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

მოთხოვნის ტექსტში პაკეტის მოთხოვნები გამოყოფილია სიმბოლოთი ";" (წერტილი). არსებობს მხოლოდ ერთი ვირტუალური ცხრილის სახელთა სივრცე თითო ჯგუფური შეკითხვაზე. დროებითი ცხრილის მენეჯერის გამოყენება არ არის საჭირო, მაგრამ შესაძლებელია, თუ გსურთ დროებითი ცხრილების გადატანა ერთი ჯგუფის მოთხოვნაზე მეორეზე.
კოდი 1C v 8.x გამოქვეყნების პროცედურების დამუშავება (მარცხი, გამოქვეყნების რეჟიმი)

მოთხოვნა = ახალი მოთხოვნა;
მოთხოვნა. ტექსტი = "
|აირჩიე
| ნომენკლატურა, SUM(Quantity) AS რაოდენობა
|PUT DocTCH
| საიდან
|სად
| ბმული = &ბმული
|ჯგუფი ნომენკლატურის მიხედვით
|;
|აირჩიე განსხვავებული
| ნომენკლატურა
|PUT ProductList
| საიდან
| დოკუმენტი.სახარჯო.საქონელი
|სად
| ბმული = &ბმული
|;
|აირჩიე
| დოქტორი ნომენკლატურა,
| Doc.Quantity AS Doc_Quantity,
| ISNULL(Reg.NumberRemainder,0) AS Reg_Number
| საიდან
| Doc HOW Doc
| LEFT შეერთება
| დაგროვების რეესტრი.საქონლის ნაშთები.ნარჩენები(,
| ნომენკლატურა B(აირჩიე განსხვავებული
| ნომენკლატურა
| FROM
| საქონლის ნუსხა AS საქონლის სია)) AS რეგ
| ჩართულია
| Doc.Nomenclature = Reg.Nomenclature";

ხოლო Selection.Next() ციკლი
//უარყოფითი ნაშთების შემოწმება
// რეესტრის გავლა
საბოლოო ციკლი;
დასრულების პროცედურა

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

ცვლადზე მოთხოვნის შესრულების შემდეგ ArrayResultsგვაქვს 3 ელემენტი. პირველი ორი შეიცავს რიცხვს, რომელიც ახასიათებს დროებით ცხრილებში განთავსებული ჩანაწერების რაოდენობას DocPM და საქონლის სიაში, ხოლო მესამე შეიცავს არჩევანს ნომენკლატურა, დოკუმენტის_რაოდენობა და Reg_Quantity ველებით.

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

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

ინფორმაცია აღებულია საიტიდან

1C Enterprise პლატფორმა საშუალებას გაძლევთ შეასრულოთ რამდენიმე მოთხოვნა თანმიმდევრულად ერთდროულად. 1C-ში ამას მოთხოვნის პარტიას უწოდებენ. ერთი პაკეტის ფარგლებში თითოეული მოთხოვნა გამოყოფილია „მძიმე წერტით“.

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

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

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

1C ენაზე მოთხოვნების ნაკრების შექმნის მაგალითი

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

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

მიიღეთ 267 1C ვიდეო გაკვეთილები უფასოდ:

თვითმხარდაჭერა.ლინკი,
თვითმმართველობის უზრუნველყოფა. მშობელი,
თვითმხარდამჭერი.კოდი,
თვითმმართველობის მხარდაჭერა. QuickChoice კოდი,
თვითმმართველობის უზრუნველყოფა. სახელი,
თვითმხარდაჭერა.ხედვა,
თვითმმართველობა.
თვითდახმარება რაოდენობრივი,
FROM
ანგარიშთა სქემა.თვითმხარდამჭერი AS თვითმხარდამჭერი
სად
თვითმხარდაჭერა.ბმული = &ანგარიში
;
////////////////////////////////////////////////////////////////////////////////

აირჩიეთ
Self-supportingTypesSubconto.LineNumber AS LineNumber,
თვითმმართველი Subconto ტიპები. Subconto ტიპის AS Subconto type,
თვითმმართველი ქვეკონტოს ტიპები. ქვეკონტოს ტიპი. აღწერა AS სახელი,
Self-supportingSubconto Types.Subconto Type.ValueType AS ValueType,
თვითმხარდაჭერის ტიპები Subconto.Only ბრუნვები AS OnlyTurnovers,
Self-supportingTypesSubconto.Sum AS Sum
FROM
ანგარიშთა სქემა თვითმმართველი. Subconto AS თვითმხარდაჭერის სახეები
სად
Self-supportingTypesSubconto.Reference = &ანგარიში
ᲓᲐᲚᲐᲒᲔᲑᲐ
Self-supportingTypesSubconto.LineNumber

ჩემთვის ეს ასე გამოიყურება:

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

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

მოდით დავაჭიროთ ღილაკს "OK" და ვცადოთ სერიული მოთხოვნის შედეგის ნახვა.

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

მეთოდები Execute() და ExecutePackage()

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

კონფიგურაციის სტრუქტურა ნაჩვენებია ფიგურაში.

(16.22 კილობაიტი) ჩამოტვირთვების რაოდენობა: 64

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

მოთხოვნა = ახალი მოთხოვნა;
მოთხოვნა. ტექსტი = "
|აირჩიე
| დოქტორი ნომენკლატურა,
| SUM (დოკუმენტ. რაოდენობა) AS დოკუმენტის_რაოდენობა,
| MINIMUM(ISNULL(Reg.NumberRemainder,0)) AS Reg_Number
| საიდან
| Document.Consumable.Goods AS Doc
| LEFT შეერთება
| დაგროვების რეგისტრაცია.საქონელი რჩება.რემაინს() AS Reg
| ჩართულია
| Doc.Nomenclature = Reg.Nomenclature
|სად
| ბმული = &ბმული
|GROUP BY Doc.Nomenclature“;

// გაიარეთ რეესტრი

საბოლოო ციკლი;

დასრულების პროცედურა

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

|აირჩიე
| დოქტორი ნომენკლატურა,

| საიდან
| (აირჩიეთ

| FROM
| დოკუმენტი.სახარჯო.საქონელი
| სად
| ბმული = &ბმული
| ჯგუფი ნომენკლატურის მიხედვით) AS დოკ
| LEFT შეერთება
ნომენკლატურა ბ
| (აირჩიეთ განსხვავებული
| ნომენკლატურა
| FROM
| დოკუმენტი.სახარჯო.საქონელი
| სად
| ბმული = &ბმული)) AS რეგ
| ჩართულია

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

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

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

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

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

გამოქვეყნების პროცედურების მართვა (მარცხი, გამოქვეყნების რეჟიმი)

MBT = New TemporaryTable Manager;

მოთხოვნა = ახალი მოთხოვნა;
მოთხოვნა. ტექსტი = "
|აირჩიე
| ნომენკლატურა, SUM(Quantity) AS რაოდენობა
|PUT DocTCH
| საიდან
| დოკუმენტი.სახარჯო.საქონელი
|სად
| ბმული = &ბმული
|GROUP BY ნომენკლატურის მიხედვით“;

მოთხოვნა = ახალი მოთხოვნა;
Query.TemporaryTable Manager = MBT;
Query.Text = "აირჩიე განსხვავებული
| ნომენკლატურა
|PUT ProductList
| საიდან
| დოკუმენტი.სახარჯო.საქონელი
|სად
| ბმული = &ბმული";

მოთხოვნა = ახალი მოთხოვნა;
Query.TemporaryTable Manager = MBT;
მოთხოვნა. ტექსტი = "
|აირჩიე
| დოქტორი ნომენკლატურა,
| Doc.Quantity AS Doc_Quantity,
| ISNULL(Reg.NumberRemainder,0) AS Reg_Number
| საიდან
| Doc HOW Doc
| LEFT შეერთება
| დაგროვების რეესტრი.საქონლის ნაშთები.ნარჩენები(,
| ნომენკლატურა
| FROM
| ჩართულია
| Doc.Nomenclature = Reg.Nomenclature";

QueryResult = Query.Execute();
Selection = QueryResult.Select();

ხოლო Selection.Next() ციკლი

//უარყოფითი ნაშთების შემოწმება

// გაიარეთ რეესტრი

საბოლოო ციკლი;

დასრულების პროცედურა

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

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

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

პარტიული მოთხოვნები

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

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

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

მოდით გადავიწეროთ სერიული მოთხოვნების გამოყენების პროცედურა:

გამოქვეყნების პროცედურების მართვა (მარცხი, გამოქვეყნების რეჟიმი)

მოთხოვნა = ახალი მოთხოვნა;
მოთხოვნა. ტექსტი = "
|აირჩიე
| ნომენკლატურა, SUM(Quantity) AS რაოდენობა
|PUT DocTCH
| საიდან
| დოკუმენტი.სახარჯო.საქონელი
|სად
| ბმული = &ბმული
|ჯგუფი ნომენკლატურის მიხედვით
|;
|აირჩიე განსხვავებული
| ნომენკლატურა
|PUT ProductList
| საიდან
| დოკუმენტი.სახარჯო.საქონელი
|სად
| ბმული = &ბმული
|;
|აირჩიე
| დოქტორი ნომენკლატურა,
| Doc.Quantity AS Doc_Quantity,
| ISNULL(Reg.NumberRemainder,0) AS Reg_Number
| საიდან
| Doc HOW Doc
| LEFT შეერთება
| დაგროვების რეესტრი.საქონლის ნაშთები.ნარჩენები(,
| ნომენკლატურა B(აირჩიე განსხვავებული
| ნომენკლატურა
| FROM
| საქონლის ნუსხა AS საქონლის სია)) AS რეგ
| ჩართულია
| Doc.Nomenclature = Reg.Nomenclature";

ხოლო Selection.Next() ციკლი

//უარყოფითი ნაშთების შემოწმება

// გაიარეთ რეესტრი

საბოლოო ციკლი;

დასრულების პროცედურა

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

ცვლადზე მოთხოვნის შესრულების შემდეგ ArrayResultsგვაქვს 3 ელემენტი. პირველი ორი შეიცავს რიცხვს, რომელიც ახასიათებს დროებით ცხრილებში განთავსებული ჩანაწერების რაოდენობას DocPMდა Პროდუქტების სიადა მესამე შეიცავს ველებით შერჩევას ნომენკლატურა, Doc_ რაოდენობადა Reg_ რაოდენობა.

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

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

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

მოთხოვნა სრულდება მოცემული ინსტრუქციის მიხედვით − მოთხოვნის ტექსტი. მოთხოვნის ტექსტი შედგენილია სინტაქსისა და წესების შესაბამისად შეკითხვის ენა. 1C: Enterprise 8 შეკითხვის ენა დაფუძნებულია სტანდარტზე SQL, მაგრამ აქვს გარკვეული განსხვავებები და გაფართოებები.

მოთხოვნით მუშაობის სქემა

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

1. Request ობიექტის შექმნა და მოთხოვნის ტექსტის დაყენება;
2. მოთხოვნის პარამეტრების დაყენება;
3. შეასრულეთ მოთხოვნა და მიიღეთ შედეგი;
4. შეკითხვის შედეგის გვერდის ავლით და მიღებული მონაცემების დამუშავება.

1. ობიექტი გამოკითხვააქვს ქონება ტექსტირომელზედაც გსურთ მოთხოვნის ტექსტის მინიჭება.

// ვარიანტი 1
მოთხოვნა = ახალი მოთხოვნა;
გამოკითხვა . ტექსტი =
"აირჩიეთ
| ვალუტის კურსი. პერიოდი,
| ვალუტა, ვალუტა,
| კურსი ვალუტა. კურსი
| საიდან

|სად
;

// ვარიანტი 2
მოთხოვნა = ახალი მოთხოვნა("აირჩიეთ
| ვალუტის კურსი. პერიოდი,
| ვალუტა, ვალუტა,
| კურსი ვალუტა. კურსი
| საიდან
| ინფორმაციის რეესტრი.ვალუტის ტარიფები AS ვალუტის კურსი
|სად
| ვალუტა.ვალუტა = &ვალუტა»);

2. პარამეტრის მნიშვნელობების დაყენება ხორციელდება მეთოდით setParameter (< Имя>, < Значение>) . მოთხოვნის ტექსტში პარამეტრები აღინიშნება სიმბოლოთი " & ”და ჩვეულებრივ გამოიყენება შერჩევის პირობებში (WHERE განყოფილება) და ვირტუალური ცხრილის პარამეტრებში.

გამოკითხვა);

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

• მიიღეთ არჩევანი Select მეთოდის გამოყენებით (< ТипОбхода>, < Группировки>, < ГруппировкиДляЗначенийГруппировок>) ;
• გადმოტვირთეთ მნიშვნელობები მნიშვნელობების ცხრილში ან მნიშვნელობების ხეში განტვირთვის მეთოდის გამოყენებით (< ТипОбхода>) .

// მიიღეთ არჩევანი

ნიმუში = შეკითხვის შედეგი. აირჩიეთ();

// მნიშვნელობების ცხრილის მიღება
RequestResult = მოთხოვნა. Execute();
მაგიდა = შეკითხვის შედეგი. განტვირთვა();

4. თქვენ შეგიძლიათ გვერდის ავლით შეკითხვის შედეგების მიღება მარყუჟის გამოყენებით:

Ნახვამდის Fetch .Next() ციკლი
ანგარიში (შერჩევა . კურსი);
საბოლოო ციკლი;

სრული შეკითხვის მაგალითი შეიძლება ასე გამოიყურებოდეს:

// ეტაპი 1. შექმენით მოთხოვნა და დააყენეთ მოთხოვნის ტექსტი
მოთხოვნა = ახალი მოთხოვნა;
გამოკითხვა . ტექსტი =
"აირჩიეთ
| ვალუტის კურსი. პერიოდი,
| ვალუტა, ვალუტა,
| კურსი ვალუტა. კურსი
| საიდან
| ინფორმაციის რეესტრი.ვალუტის ტარიფები AS ვალუტის კურსი
|სად
| ვალუტა.ვალუტა = &ვალუტა»;

// ეტაპი 2. პარამეტრების დაყენება
გამოკითხვა . SetParameter ("ვალუტა", შერჩეული ვალუტა);

// ეტაპი 3. შეასრულეთ მოთხოვნა და მიიღეთ არჩევანი
RequestResult = მოთხოვნა. Execute();
ნიმუში = შეკითხვის შედეგი. აირჩიეთ();

// გადაკვეთა შერჩევა
Ნახვამდის Fetch .Next() ციკლი
ანგარიში (შერჩევა . კურსი);
საბოლოო ციკლი;

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

მოთხოვნის ტექსტი შედგება რამდენიმე განყოფილებისგან:

1. მოითხოვეთ აღწერა— შესარჩევი ველებისა და მონაცემთა წყაროების სია;
2. შეკითხვის გაერთიანება- გამოთქმები "JOIN" და "JOIN ALL";
3. შეკვეთის შედეგები- გამოთქმა "ORDER BY ...";
4. ავტომატური მოწყობა- გამოთქმა "AUTOORDER";
5. შედეგების აღწერა- გამოთქმა "შედეგები ... ON ...".

საჭიროა მხოლოდ პირველი ნაწილი.

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

1C შეკითხვის ენა მხარს უჭერს გამოყენებას დროებითი მაგიდები- მოთხოვნის შესრულების შედეგად მიღებული და დროებით შენახული ცხრილები.

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

VTManager = NewTempTableManager;
მოთხოვნა = ახალი მოთხოვნა;
გამოკითხვა . TempTable Manager = VT მენეჯერი;

გამოკითხვა . ტექსტი =
"აირჩიეთ
| ვალუტა.კოდი,
| ვალუტები.სახელი
|განთავსება WTC ვალუტა
| საიდან
| სახელმძღვანელო. ვალუტები AS ვალუტები»;

RequestResult = მოთხოვნა. გაიქეცი();

სხვა შეკითხვებში VTCcurrency-ის დროებითი ცხრილის გამოსაყენებლად, ამ მოთხოვნებს უნდა მიაკუთვნოთ საერთო დროებითი ცხრილის მენეჯერი, VT Manager.

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

ჯგუფური მოთხოვნებისთვის ხელმისაწვდომია ExecuteBatch() მეთოდი, რომელიც ახორციელებს ყველა მოთხოვნას და აბრუნებს შედეგების მასივს. დროებითი ცხრილები ჯგუფური შეკითხვისას წარმოდგენილი იქნება ცხრილით ერთი მწკრივით და ერთი სვეტით "Count", რომელიც ინახავს ჩანაწერების რაოდენობას. სერიული მოთხოვნების გამართვის მიზნით, შეგიძლიათ გამოიყენოთ მეთოდი ExecutePacketWith IntermediateData() : აბრუნებს დროებითი ცხრილების რეალურ შინაარსს და არა ჩანაწერების რაოდენობას.

// Batch მოთხოვნასთან მუშაობის მაგალითი
მოთხოვნა = ახალი მოთხოვნა;
გამოკითხვა . ტექსტი =
"აირჩიეთ
| ვალუტები.სახელი
| საიდან
| სახელმძღვანელო.ვალუტები AS ვალუტა
|;
|აირჩიე
| ნომენკლატურა.აღწერა
| საიდან
| დირექტორია Nomenclature AS Nomenclature»;

PacketResult = მოთხოვნა. ExecutePackage();

TZ ვალუტა = PackageResult[ 0]. განტვირთვა();
TZNomenclature = PackageResult[ 1]. განტვირთვა();

// დროებითი ცხრილების გამოყენების მაგალითი პარტიულ მოთხოვნაში
მოთხოვნა = ახალი მოთხოვნა;
გამოკითხვა . ტექსტი =
"აირჩიეთ
| პროდუქტები.მინიშნება AS Product
|PUT VTTProducts
| საიდან
| ცნობარი ნომენკლატურა AS საქონელი
|სად
| პროდუქტები.Manufacturer = &Manufacturer
|;
|აირჩიე
| VTTProducts.Product,
| PTU რაოდენობა,
| PTU.ფასი,
| PTU.Reference AS DocumentReceipt
| საიდან
| VTTProducts AS VTTProducts
| LEFT Join Document.Incoming GoodsServices.Goods AS PTU
| პროგრამული უზრუნველყოფა VTTproducts.Product = PTU.Nomenclature ";

გამოკითხვა . setParameter ( "მწარმოებელი", მწარმოებელი);

RequestResult = მოთხოვნა. Execute();
ნიმუში = შეკითხვის შედეგი. აირჩიეთ();

Ნახვამდის Fetch .Next() ციკლი

საბოლოო ციკლი;

ვირტუალური მაგიდები

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

არსებობს შემდეგი ვირტუალური ცხრილები (შესაძლო პარამეტრები მოცემულია ფრჩხილებში):

• ინფორმაციისთვის დარეგისტრირდით:
  • SliceFirst (<Период>, <Условие>) - ყველაზე ადრეული ჩანაწერები მითითებული თარიღისთვის;
  • SliceRecent(<Период>, <Условие>) - უახლესი ჩანაწერები მითითებული თარიღისთვის;
• დაგროვების რეესტრებისთვის:
  • რჩება (<Период>, <Условие>) - ნაშთები მითითებულ თარიღზე;
  • ბრუნვები (<НачалоПериода>, <КонецПериода>, <Периодичность>, <Условие>) - პერიოდის გარიგებები;
  • რჩება და ბრუნვები (<НачалоПериода>, <КонецПериода>, <Периодичность>, <МетодДополненияПериодов>, <Условие>) — ნაშთები და ბრუნვები პერიოდისთვის;
• ბუღალტრული აღრიცხვისთვის:
  • რჩება (<Период>, <УсловиеСчета>, <Субконто>, <Условие>) - ნაშთები მითითებული თარიღისთვის, ანგარიშის, გაზომვების და ქვეკონტოს კონტექსტში;
  • ბრუნვები (<НачалоПериода>, <КонецПериода>, <Периодичность>, <УсловиеСчета>, <Субконто>, <Условие>, <УсловиеКорСчета>, <КорСубконто>) - პერიოდის ბრუნვები ანგარიშების კონტექსტში, გაზომვები, კორ. ანგარიშები, ქვეკონტო, კორ. ქვეკონტო;
  • რჩება და ბრუნვები (<НачалоПериода>, <КонецПериода>, <Периодичность>, <МетодДополненияПериодов>, <УсловиеСчета>, <Субконто>, <Условие>) - ნაშთები და ბრუნვები ანგარიშების, გაზომვებისა და ქვეანგარიშების კონტექსტში;
  • ბრუნვებიDtKt(<НачалоПериода>, <КонецПериода>, <Периодичность>, <УсловиеСчетаДт>, <СубконтоДт>, <УсловиеСчетаКт>, <СубконтоКт>, <Условие>) - ბრუნვები პერიოდისთვის Dt ანგარიშის კონტექსტში, ანგარიში Kt, Subconto Dt, Subconto Kt;
  • MovementsSubconto(<НачалоПериода>, <КонецПериода>, <Условие>, <Порядок>, <Первые>) - მოძრაობები ქვეკონტოს მნიშვნელობებთან ერთად;
• საანგარიშო რეესტრებისთვის:
  • ბაზა (<ИзмеренияОсновногоРегистра>, <ИзмеренияБазовогоРегистра>, <Разрезы>, <Условие>) - საანგარიშო რეესტრის ძირითადი მონაცემები;
  • მონაცემთა გრაფიკა (<Условие>) — გრაფიკის მონაცემები;
  • ActualActionPeriod (<Условие>) არის მოქმედების ფაქტიური პერიოდი.

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

მოითხოვეთ კონსტრუქტორი

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

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

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

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

QuerySchema ობიექტი

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

• მოთხოვნის ტექსტის დაყენება (< Текст>) — ავსებს RequestBatch თვისებას გადაცემული მოთხოვნის ტექსტის საფუძველზე;
• GetTextRequest() - აბრუნებს მოთხოვნის ტექსტს, რომელიც გენერირებულია RequestBag თვისების საფუძველზე;

FindParameters() - აბრუნებს შეკითხვის პარამეტრებს.

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

ᲓᲐᲚᲐᲒᲔᲑᲐ
ვალუტები.კოდი

ჩაშენებულ ენაში კოდი შეიძლება ასე გამოიყურებოდეს:

RequestSchema = New RequestSchema;
პაკეტი 1 = QueryScheme. RequestBatch[ 0];
ოპერატორი 1 = პაკეტი1. ოპერატორები[ 0];
// დაამატეთ წყარო
RegisterTable = Operator1. წყაროები. დამატება( "სახელმძღვანელო. ვალუტები", "ვალუტა" );
// ველების დამატება
FieldLink = ოპერატორი 1. SelectableFields. Add("Currencies.Link" , 0 );
საველე კოდი = ოპერატორი 1. SelectableFields. Add("Currencies.Code" , 1 );
// ველის მეტსახელების მითითება
პაკეტი 1 . სვეტები[ 0]. მეტსახელი = "ვალუტა";
პაკეტი 1 . სვეტები[1]. მეტსახელი = "კოდი";
// პირობის დამატება
ოპერატორი 1 . შერჩევა. დამატება( "არ არის მონიშნული წაშლისთვის");
// შეკვეთის დამატება
პაკეტი 1 . შეკვეთა. დამატება (FieldCode);
QueryText = QueryScheme. GetTextRequest();

ისინი მნიშვნელოვნად ზრდის წაკითხვის შესაძლებლობას, რაც ამცირებს შეცდომების ალბათობას => ეს ჩემთვის საკმარისია.

ჩაშენებულ შეკითხვის ენაში 1C: Enterprise ვერსია 8.0, არ იყო დროებითი ცხრილების გამოყენებისა და სერიული მოთხოვნების დაწერის შესაძლებლობა. ამავდროულად, ხშირად საჭირო იყო რთული გამოთვლების შესრულება ერთი მოთხოვნის ფარგლებში (ანუ ერთი ურთიერთქმედების ციკლის კლიენტი - 1C: Enterprise სერვერი - DBMS სერვერი). ასეთი პრობლემების გადასაჭრელად გამოიყენეს ქვემოთხოვნები - ზარები არა მეტამონაცემების ობიექტებზე, არამედ ამ ობიექტებიდან არჩევისკენ. როგორც წესი, ქვემოკითხვები ხდებოდა დაჯგუფებით და ხშირად იყენებდნენ შეერთებისას.

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

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

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