դրանք մեծապես բարձրացնում են ընթեռնելիությունը, ինչը նվազեցնում է սխալների հավանականությունը => միայն սա ինձ բավական է։

1C:Enterprise տարբերակի 8.0-ի ներկառուցված հարցումների լեզուն չուներ ժամանակավոր աղյուսակներ օգտագործելու և խմբաքանակային հարցումներ գրելու հնարավորություն: Միևնույն ժամանակ, հաճախ անհրաժեշտ էր լինում կատարել բարդ հաշվարկներ մեկ հարցման շրջանակներում (այսինքն՝ հաճախորդի միջև փոխազդեցության մեկ ցիկլ - 1C:Enterprise սերվեր - DBMS սերվեր): Նման խնդիրներ լուծելու համար օգտագործվել են ենթհարցումներ՝ զանգեր ոչ թե մետատվյալների օբյեկտներին, այլ այս օբյեկտներից ընտրվածներին: Սովորաբար, ենթհարցերը կատարվում էին խմբավորման միջոցով և հաճախ օգտագործվում էին միացումներում:

DBMS սերվերի օպտիմիզատորը (անկախ նրանից, թե որ DBMS-ն եք օգտագործում) միշտ չի կարող ճիշտ օպտիմալացնել նման հարցումը: Այս դեպքում օպտիմիզատորի խնդիրը միացման ճիշտ մեթոդի ընտրությունն է: Երկու նմուշների միացման մի քանի ալգորիթմներ կան։ Այս կամ այն ​​ալգորիթմի ընտրությունը կախված է նրանից, թե քանի գրառում կպարունակվի մեկ և մյուս նմուշում: Եթե ​​դուք միանում եք երկու ֆիզիկական աղյուսակներին, ապա DBMS-ը կարող է հեշտությամբ որոշել երկու նմուշների չափերը՝ հիմնվելով առկա վիճակագրության վրա: Եթե ​​միացված ընտրանքներից մեկը ենթահարկ է, ապա շատ դժվար է դառնում հասկանալ, թե քանի գրառում է այն վերադարձնելու: Այս դեպքում DBMS-ը կարող է սխալվել պլանի ընտրության հարցում, ինչը կհանգեցնի հարցումների կատարողականի աղետալի անկման:

Վերը նշված մեթոդով հարցումը վերաշարադրելը նպատակ ունի պարզեցնել DBMS օպտիմիզատորի աշխատանքը: Վերագրված հարցման մեջ միացումներին մասնակցող բոլոր ընտրությունները կլինեն ֆիզիկական աղյուսակներ, և DBMS-ը կկարողանա հեշտությամբ որոշել յուրաքանչյուր ընտրության չափը: Սա թույլ կտա DBMS-ին երաշխավորել բոլոր հնարավոր պլաններից ամենաարագը ընտրելը: Ավելին, DBMS-ը ճիշտ ընտրություն կկատարի անկախ ցանկացած պայմաններից։ Այս կերպ վերագրված հարցումը հավասարապես լավ կաշխատի ցանկացած DBMS-ի վրա, ինչը հատկապես կարևոր է շրջանառության լուծումներ մշակելիս: Բացի այդ, այս ձևով վերագրված հարցումն ավելի ընթեռնելի է, ավելի հեշտ հասկանալի և վրիպազերծել:

Պետք է հասկանալ, որ հարցումն այս կերպ վերաշարադրելով՝ մենք կարող ենք դրա մեջ որոշակի դանդաղում մտցնել՝ լրացուցիչ ծախսերի՝ ժամանակավոր աղյուսակների ստեղծման պատճառով: Եթե ​​DBMS-ը չի սխալվում պլանի ընտրության հարցում, հավանաբար այն կկատարի հին հարցումն ավելի արագ, քան նորը: Այնուամենայնիվ, այս դանդաղումը միշտ չափազանց փոքր կլինի: Դանդաղեցման չափը կախված է օգտագործվող DBMS-ից և ապարատային աշխատանքից: Տիպիկ դեպքում մեկ ժամանակավոր աղյուսակ ստեղծելու համար կարող է պահանջվել մի քանի միլիվայրկյան: Այսինքն՝ այդ դանդաղումները չեն կարող նկատելի ազդեցություն ունենալ համակարգի աշխատանքի վրա և, որպես կանոն, դրանք կարող են անտեսվել։

Այս հոդվածը նախատեսված է ընթերցողների համար, ովքեր ծանոթ են SQL լեզվին:

1C հարցումների լեզուն, որն օգտագործվում է 8-րդ տարբերակից, այսօր դարձել է տվյալների բազաների հետ աշխատելու օգտակար գործիք, որը թույլ է տալիս կարդալ դրանցից, բայց ոչ գրել: Սինտակտիկորեն հարցման լեզուն շատ նման է SQL լեզվին, բայց ռուսերեն:

Ստորև ներկայացված է հարցման հիմնական լեզվի և SQL օպերատորների համապատասխանության աղյուսակը.

1C հարցումների լեզվի օպերատորներ	SQL հայտարարություն
ՏԱՐԲԵՐ
ՄԻԱՑՈՒԹՅՈՒՆ
ԽՈՒՄԲԸ ԸՍՏ
ՄԻԱՎՈՐԵԼ
ԴԱՍԱՎՈՐԵԼ ԸՍՏ

Եվ սա ամբողջական ցանկ չէ։ Հարցման հասանելի լեզուների օպերատորների վերաբերյալ ավելի ամբողջական տեղեկատու տեղեկատվություն կարելի է ստանալ հարցումների դիզայներում, որը կքննարկվի ստորև:

Ծրագրի կոդից 1C հարցման կատարումն իրականացվում է ներկառուցված «Հարցում» լեզվի օբյեկտի միջոցով: Ներկառուցված ծրագրավորման լեզվի միջոցով տվյալների բազայի հարցում գրելու օրինակ.

Request = Նոր հարցում; Query.Text = "SELECT | Synonym.Link AS Link |FROM | Directory.Directory1 AS Synonym"; Ընտրել = Query.Run().Select(); Մինչդեռ Selection.Next() Loop // Տեղադրել ընտրության մշակումը SelectionDetailedRecords EndCycle;

«Run» մեթոդը կատարում է հարցումը, «Select» մեթոդը վերադարձնում է «SelectFromQueryResult» տեսակի արժեք: Կարող եք նաև օգտագործել Unload մեթոդը, որը վերադարձնում է արժեքների աղյուսակ:

Հարցման պարամետրերը պահվում են «Պարամետրեր» հատկությունում (այս դեպքում սա կառույց է, ուստի այստեղ կիրառելի են կառուցվածքի բոլոր մեթոդները՝ տեղադրել, ջնջել և այլն):

«Query.Parameters.Insert» պարամետրը սահմանելու օրինակ («Directory», DirectoryLink): Հարցման մեջ կարող եք մուտք գործել պարամետրեր՝ օգտագործելով «&Directory» նշանը: Ստորև բերված է պարամետրերի օգտագործմամբ հարցման օրինակ.

Request = Նոր հարցում; Query.Text = "SELECT | Users.Link AS Link, | Users.Parent AS Parent, | Users.Name AS անուն |FROM | Directory.Users AS Users |WHERE | Users.Link = &տեղեկատու"; Query.Parameters.Insert("Directory", DirectoryLink); Ընտրել = Query.Run().Select(); Մինչդեռ Selection.Next() Loop // Տեղադրել ընտրության մշակումը SelectionDetailedRecords EndCycle;

Հիշենք, որ հարցման լեզուն նախատեսված է միայն տվյալների բազայից տվյալների ընթերցման համար, ուստի այն չունի SQL հայտարարությունների անալոգներ, ինչպիսիք են INS ERT-ը և UPDATE-ը: Տվյալները կարող են փոփոխվել միայն ներկառուցված 1C ծրագրավորման լեզվի օբյեկտի մոդելի միջոցով: Նաև 1C հարցումների լեզվում կան օպերատորներ, որոնք չունեն անալոգներ SQL-ում, օրինակ.

• ՀԻԵՐԱՐԽԻԱՅՈՒՄ
• ՏԵՂ
• ԻՆԴԵՔՍ ԸՍՏ

ՀԻԵՐԱՐԽԻԱՅՈՒՄ– թույլ է տալիս ընտրել հիերարխիկ գրացուցակի բոլոր տարրերը, որոնք ներառված են փոխանցված հղման հիերարխիայում: Հարցման օրինակ օգտագործելով ՀԻԵՐԱՐԽԻԱՅՈՒՄ:

SELECT Products.Link, Products.Article FROM Directory.Products AS Products WHERE Products.Link IN HIERARCHY(&Citrus)"

Այս դեպքում արդյունքը կվերադարձնի Citrus նոմենկլատուրայի գրացուցակի բոլոր ենթակա տարրերը, անկախ նրանից, թե որքան հիերարխիայի մակարդակ ունի այս գրացուցակը:

Նաև, օրինակ, խնդիրն է գտնել «Գրիչ» անունով ապրանք: Ապրանքը պետք է ներառվի «Գրենային պիտույքներ» հիերարխիայում: Ապրանքներ», այսինքն, մենք չպետք է փնտրենք դռան բռնակը: Անվանակարգի կառուցվածքն այս դեպքում հետևյալն է.

Գրասենյակ

|_ Շատրվանային գրիչներ |_ Կարմիր գրիչ |_ Կապույտ գրիչ |_ Թանաքային գրիչներ |_ Քանոններ

Աքսեսուարներ

|_ Դռների բռնակներ |_ Դռան պարզ բռնակ |_ Դռան շքեղ բռնակ

Մենք գրում ենք հետևյալ խնդրանքը.

SELECT Products.Link, Products.Article FROM Directory.Products AS Products WHERE Products.Name Like "Pen%" AND Products.Link IN HIERARCHY(&Stationery)"

Դիզայնն օգտագործելիս ՀԻԵՐԱՐԽԻԱՅՈՒՄանհրաժեշտ է հաշվի առնել, որ եթե դուք դատարկ հղում եք փոխանցում «Office» պարամետրին, հարցման կատարումը կդանդաղի, քանի որ հարթակը կստուգի յուրաքանչյուր տարր՝ տեսնելու, թե արդյոք այն պատկանում է արմատին:

ՏԵՂ– Այս հայտարարությունը տեղադրում է արդյունքը ժամանակավոր աղյուսակում: Հարցման օրինակ.

SELECT Users.Link AS Link, Users.Parent AS Parent, Users.Name AS Name PLACE SelectedUsers FROM Directory.Users AS Users WHERE Users.Link = &Directory; SELECT SelectedUsers.Link AS Link, SelectedUsers.Parent AS Parent, SelectedUsers.Name AS Name FROM SelectedUsers AS SelectedUsers

Այս SQL հարցումը կկատարվի մի քանի հարցումներով.

• Ժամանակավոր աղյուսակի ստեղծում (պլատֆորմը կարող է «վերօգտագործել» նախկինում ստեղծված ժամանակավոր աղյուսակները, այնպես որ ստեղծումը միշտ չէ, որ տեղի է ունենում);
• Տվյալների տեղադրում ժամանակավոր աղյուսակում;
• Այս ժամանակավոր աղյուսակից հիմնական հարցման կատարումը, այն է՝ SEL ECT;
• Ժամանակավոր սեղանի ոչնչացում/մաքրում.

Ժամանակավոր աղյուսակը կարող է բացահայտորեն ոչնչացվել կառուցվածքի միջոցով ՈՉՆՉԱՑՆԵԼ, կամ անուղղակիորեն - սեղանի ժամանակավոր կառավարիչը փակելիս:

Ներկառուցված ծրագրավորման լեզվի «Query» օբյեկտն ունի «Temporary Table Manager» հատկությունը, որը նախատեսված է ժամանակավոր աղյուսակների հետ աշխատելու համար: Նմուշ կոդ.

MVT = New TemporaryTableManager(); Request = Նոր հարցում; Query.TemporaryTableManager = MVT;

Հարցումը կատարելուց հետո MVT փոփոխականը կարող է երկրորդ անգամ օգտագործվել մեկ այլ հարցում, ինչը, անկասկած, ժամանակավոր աղյուսակների օգտագործման ևս մեկ առավելություն է: Այս դեպքում տվյալների բազայից ժամանակավոր աղյուսակը կջնջվի, երբ «Փակել» մեթոդը կանչվի...

MVT.Close();

...կամ փոփոխականը հիշողությունից մաքրելիս, այսինքն՝ այն մեթոդը կատարելիս, որով փոփոխականը հայտարարվել է։ Ժամանակավոր աղյուսակները մեծացնում են սկավառակի ենթահամակարգի ծանրաբեռնվածությունը, այնպես որ դուք չպետք է ստեղծեք չափազանց շատ ժամանակավոր ենթահամակարգեր (օրինակ, օղակում) կամ մեծ ծավալի ենթահամակարգեր:

ԻՆԴԵՔՍ ԸՍՏ– այս օպերատորն օգտագործվում է օպերատորի հետ համատեղ ՏԵՂ.Ժամանակավոր աղյուսակ ստեղծելիս այս օպերատորը կարող է ինդեքսավորել ստեղծվող աղյուսակը, ինչը զգալիորեն արագացնում է նրա հետ աշխատանքը (բայց միայն այն դեպքում, եթե ինդեքսը համապատասխանում է ձեր հարցմանը):

Անվճար փորձագետի խորհրդատվություն

Շնորհակալություն ձեր խնդրանքի համար:

1C մասնագետը կկապվի ձեզ հետ 15 րոպեի ընթացքում:

Հարցման լեզվի որոշ օպերատորների առանձնահատկությունները

ՓՈՓՈԽՈՒԹՅԱՆ ՀԱՄԱՐ– այս օպերատորը նախատեսված է կողպելու կոնկրետ հարցման աղյուսակը (կամ բոլոր աղյուսակները, որոնք մասնակցում են հարցմանը): Կողպումը կատարվում է սեղանի վրա U կողպեք կիրառելով: SQL-ում դա իրականացվում է UPDLOCK ակնարկի միջոցով: Այս դիզայնը անհրաժեշտ է փակուղիներից խուսափելու համար: Կառուցվածքով հարցման օրինակ ՓՈՓՈԽՈՒԹՅԱՆ ՀԱՄԱՐ.

SELECT Users.Link AS Link, Users.Parent AS Parent, Users.Name AS Name FROM Directory.Users AS Users LEFT Join Directory.RFK AS RFK BY Users.RFK = RFK.Link TO CHANGE Directory.Users

Այս օրինակում U կողպեքը կտեղադրվի Users սեղանի վրա: Եթե ​​դուք կողպեքի համար աղյուսակ չեք նշում, այն կկիրառվի հարցմանը մասնակցող բոլոր աղյուսակների վրա: Կարևոր է նշել, որ այս դիզայնը գործում է միայն այն կոնֆիգուրացիաներում, որոնցում միացված է ավտոմատ կողպեքի կառավարման ռեժիմը:

ՄԻԱՑՈՒԹՅՈՒՆ– հարցումն աջակցում է կապերին ՁԱԽ/ԱՋ, ԼԻՎԱԾ, ՆԵՐՔԻՆ,որը համապատասխանում է SQL-ի միացումներին – LEFT/RIGHT JOIN, OUTER JOIN, NINER JOIN:

Այնուամենայնիվ, հարցման ստեղծողն օգտագործելիս դուք չեք կարողանա դա անել ԱՌԱՋ ՄԻԱՑԵՔ.Կոնստրուկտորը պարզապես կփոխանակի աղյուսակները, բայց օպերատորը միշտ կլինի ձախլիկ: Այդ իսկ պատճառով, դուք երբեք չեք տեսնի 1C-ում աջ միացման օգտագործումը:

Սինտակտիկորեն կապն այսպիսի տեսք ունի.

SELECT Table1.Link AS Link FROM Directory.Directory1 AS Table1 LEFT JOIN Directory.Directory2 AS Table2 BY Table1.Attributes = Table2.Attributes

1C հարցումների լեզուն դեկարտյան արտադրանքին միանալու օպերատոր չունի (CROSS JOIN): Այնուամենայնիվ, օպերատորի բացակայությունը չի նշանակում, որ հարցման լեզուն չի աջակցում նման կապին: Անհրաժեշտության դեպքում կարող եք միանալ հետևյալ աղյուսակներին.

SELECT Table1.Link AS Link FROM Directory.Directory1 AS Table1 LEFT JOIN Directory.Directory2 AS Table2 BY TRUE

Ինչպես երևում է օրինակից, միացման բանալին դրված է ՃԻՇՏ, այսինքն՝ մի աղյուսակի յուրաքանչյուր տող համապատասխանում է մյուսի տողին։ Միացման տեսակը (ՁԱԽ, ԱՋ, ԼԻՎ, ՆԵՐՔԻՆ) կարևոր չէ, եթե երկու աղյուսակներում էլ տողեր կան, բայց եթե աղյուսակներից որևէ մեկում տողեր չկան (ասենք աղյուսակը), արդյունքը տարբեր կլինի: Օրինակ, երբ օգտագործվում է ՆԵՐՔԻՆկապի արդյունքը դատարկ կլինի: Օգտագործելով ՁԱԽ ԱՋՄիացման արդյունքը կլինի կամ չի լինի տվյալ՝ կախված նրանից, թե որ աղյուսակին ենք միանում՝ տվյալներով, թե ոչ։ Օգտագործելով ԼԻՏվյալները միշտ միացված կլինեն (բնականաբար, միայն մեկ աղյուսակից, քանի որ մյուսը դատարկ է); կապի տեսակի ընտրությունը կախված է կիրառման կոնկրետ առաջադրանքից:

Մի փոքր տեսողական հուշում, թե ինչպես են աշխատում կապի տարբեր տեսակները.

Հավանել.Ի տարբերություն նմանատիպ SQL օպերատորի՝ LIKE, կաղապարի համար Հավանելկարելի է նշել՝ օգտագործելով միայն մի քանի հատուկ նիշ.

• % (տոկոս). հաջորդականություն, որը պարունակում է ցանկացած թվով կամայական նշաններ.
• _ (ընդգծում). մեկ կամայական նիշ;
• / - հաջորդ նիշը պետք է մեկնաբանվի որպես կանոնավոր նիշ:

ԾՐԱԳՐԵՐԻ ԱՐԴՅՈՒՆՔՆԵՐԸ SQL անալոգը ROLLUP օպերատորն է: Օպերատորի օգտագործման օրինակ ԱՐԴՅՈՒՆՔՆԵՐԸ:

SELECT Products.Price AS Price, Products.Product AS Product FROM Directory.Nomenclature AS Products ԱՐԴՅՈՒՆՔՆԵՐԸ ՄԻՋԻՆ (Գին) ԸՍՏ ապրանքի

Արդյունքը կլինի այսպիսին.

Մահճակալ	9833,333
Երկաթ
Գրիչ

Այսինքն՝ արդյունքին ավելացվում է լրացուցիչ տող, որը պարունակում է դաշտի արժեքը, որով կատարվում է խմբավորումը և ագրեգացման ֆունկցիայի արժեքը։

Աշխատանք խմբաքանակի հարցումների հետ

1C-ն թույլ է տալիս աշխատել հարցումների խմբաքանակի հետ: Խմբաքանակի հարցումով հարցումների տեքստերն առանձնացված են ստորակետերով (;): 1C խմբաքանակի հարցումը կատարվում է հաջորդաբար: Խմբաքանակի հարցման տեքստի օրինակ.

SELECT Users.Link AS Link, Users.Parent AS Parent, Users.Name AS Name FROM Directory.Users AS Users;
SELECT Work Schedule.User AS User, Work Schedule.Date AS Date, Work Schedule.Աշխատանքային ժամերը ՈՐՊԵՍ աշխատանքային ժամեր Գրանցման տվյալներից.Աշխատանքային ժամանակացույց AS Work Schedule

Փաթեթում ներառված բոլոր հարցումների արդյունքը ստանալու համար դուք պետք է օգտագործեք հարցման օբյեկտի «ExecutePackage» մեթոդը՝ «Run»-ի փոխարեն: Այս մեթոդը կատարում է բոլոր հարցումները հաջորդաբար: Հարցման արդյունքը փաթեթի յուրաքանչյուր հարցման արդյունքների զանգված է, և զանգվածում տեղադրման հաջորդականությունը նույնն է, ինչ փաթեթի տեքստում հարցումների հաջորդականությունը:

Հարցման լեզուն դիտարկելիս արժե նշել այնպիսի առանձնահատկություն, ինչպիսին են վիրտուալ աղյուսակները: Վիրտուալ աղյուսակները տվյալների բազայում բացակայում են, դրանք մի տեսակ փաթաթան են, որոնք կատարվում են DBMS-ի կողմից որպես հարցում՝ օգտագործելով ենթհարցումներ: Վիրտուալ աղյուսակների օգտագործմամբ 1C հարցման օրինակ.

SELECT RegisterLiabilitiesTurnovers.Liability AS Liability FROM RegisterAccumulations.RegisterLiabilities.Turnover() AS RegisterLiabilitiesTurnovers

Նման հարցումը DBMS-ին նման կլինի.

SEL ECT T1.FLD25931RRRRRERF FR OM (Ընտրեք t2._fld25931rref որպես FLD25931RRRRERF, CAST (SUM (T2._FLD25936) AS NUMERIC (38, 8)) Որպես FLD25936 (SUM25, C) ) AS Fld25937Turnover_ FR OM dbo._AccumRgTn25938 T2 WH ERE ((T2._Fld949 = @P1)) AND ((T2._Fld25936 @P2 OR T2._Fld25937 @P3Y)T2. ._Fld25 ) 936 ) ՈՐՊԵՍ ԹՎԱԿԱՆ (38, 8))) 0.0 ԿԱՄ (CAST(SUM(T2._Fld25937) AS NUMERIC(38, 8))) 0.0) T1>>>>

Երևում է, որ այն նման չէ SQL-ին, քանի որ կա ենթահարկ, խմբավորում։ Վիրտուալ աղյուսակները, մեծ հաշվով, «շարահյուսական շաքար» են, այսինքն՝ դրանք ստեղծվել են, ընդհանուր առմամբ, հարցումներ մշակելու հարմարության համար, որպեսզի հարցումներն ավելի կոմպակտ և ընթեռնելի լինեն:

Միայն ռեգիստրներն ունեն վիրտուալ աղյուսակներ, սակայն, թե որ վիրտուալ աղյուսակները հասանելի են ռեգիստրում, կարելի է տեսնել հարցումների դիզայներում:

Վիրտուալ աղյուսակներ օգտագործելիս միշտ պետք է ընտրության պայման տրամադրեք: Հակառակ դեպքում կարող են առաջանալ աշխատանքի հետ կապված խնդիրներ:

Հարցման մարմնում այսպիսի տեսք ունի.

Կուտակային ռեգիստր Պարտավորությունների ռեգիստր Շրջանառություններ (, Գործառնություն = &Շահագործում) ՀԾ Պարտավորությունների ռեգիստր Շրջանառություններ

Հարցումներ գրելու, այսինքն՝ հարցման տեքստեր ստեղծելու հարմարության համար 1C-ում կա կոնստրուկտոր, որը կարելի է կանչել համատեքստի մենյուի միջոցով (մկնիկի աջ կոճակը).

Հարցման դիզայներում դուք կարող եք տեսնել աջակցվող հարցումների լեզվի գործառույթների և օպերատորների ամբողջական ցանկը:

Query Builder-ը շատ ճկուն տեսողական գործիք է ցանկացած բարդության հարցումներ ստեղծելու համար: Այն հասանելի է միայն կոնֆիգուրատորի ռեժիմում: Ձեռնարկությունների ռեժիմում կա այսպես կոչված «Հարցման վահանակ» - սա արտաքին մշակումն է, որը առաքվում է ITS սկավառակի վրա: Կառավարվող հավելվածի համար հարցումների վահանակը կարելի է ներբեռնել its.1c.ru կայքից:

Հարցման դիզայներում աշխատելու նկարագրությունը դուրս է այս հոդվածի շրջանակներից, ուստի այն մանրամասն չի քննարկվի:

Հարցման ոչ օպտիմալ կատարման պատճառները

Ստորև բերված է հիմնական պատճառների ցանկը (բայց ոչ բոլորը), որոնք հանգեցնում են հարցումների դանդաղ կատարմանը:

• Օգտագործելով միացումներ ենթահարցերի հետ

Խորհուրդ չի տրվում միացում կատարել ենթհարցերի հետ, ենթհարցերը պետք է փոխարինվեն ժամանակավոր աղյուսակներով: Ենթհարցերի միացումը կարող է հանգեցնել կատարողականի զգալի կորուստների, և տարբեր DBMS-ներում հարցումների կատարումը կարող է զգալիորեն տարբերվել արագությամբ: Նման հարցումների կատարման արագությունը նույնպես զգայուն է DBMS-ի վիճակագրության նկատմամբ: Այս վարքագծի պատճառն այն է, որ DBMS օպտիմիզատորը միշտ չի կարող ճիշտ որոշել հարցումների կատարման օպտիմալ պլանը, քանի որ օպտիմիզատորը ոչինչ չգիտի, թե քանի տող կվերադառնա ենթահարկը իր կատարումից հետո:

• Վիրտուալ աղյուսակների օգտագործումը հարցումների միացումներում

DBMS մակարդակի վիրտուալ աղյուսակները կատարվում են որպես ենթհարցումներ, ուստի պատճառները նույնն են, ինչ առաջին պարբերությունում:

• Օգտագործելով պայմաններ հարցման մեջ, որոնք չեն համապատասխանում առկա ինդեքսներին

Եթե ​​պահանջի պայմաններում (օպերատորի մեջ ՈՐՏԵՂկամ վիրտուալ աղյուսակի պայմանները) օգտագործում է դաշտեր, որոնք ոչ բոլորն են ներառված ինդեքսի մեջ, այս հարցումը կկատարվի SQL կառուցվածքի աղյուսակի սկանավորման կամ ինդեքսի սկանավորման միջոցով (ամբողջությամբ կամ մասամբ): Սա կազդի ոչ միայն հարցման կատարման ժամանակի վրա, այլև ավելորդ տողերի վրա կտեղադրվի ավելորդ S կողպեք, որն իր հերթին կարող է հանգեցնել կողպեքի էսկալացիայի, այսինքն՝ ամբողջ աղյուսակը կկողպվի։

• Օգտագործելով OR հարցումների պայմաններում

Օգտագործելով տրամաբանական օպերատորը ԿԱՄդիզայնի մեջ ՈՐՏԵՂկարող է նաև հանգեցնել աղյուսակի սկանավորման: Դա տեղի է ունենում, քանի որ DBMS-ը չի կարող ճիշտ օգտագործել ինդեքսը: Փոխարեն ԿԱՄդուք կարող եք օգտագործել դիզայնը ՄԻԱՎՈՐԵԼ ԱՄԵՆ ԻՆՉ։

• Տվյալների ստացում կետի միջոցով կոմպոզիտային տիպի դաշտերի համար

Խորհուրդ չի տրվում արժեքներ ստանալ կետի միջոցով (շինարարության մեջ ԸՆՏՐԵՔ ՈՐՏԵՂ), քանի որ եթե օբյեկտի հատկանիշը պարզվում է, որ բարդ տեսակ է, ապա միացումը տեղի կունենա այս բարդ տիպի մեջ ներառված յուրաքանչյուր աղյուսակի հետ: Արդյունքում, DBMS հարցումը զգալիորեն կբարդանա, ինչը կարող է խանգարել օպտիմալացնողին ընտրել հարցումների կատարման ճիշտ պլանը:

1C GOODWILL ընկերության բլոգ

1C Enterprise հարթակը թույլ է տալիս կատարել մի քանի հարցումներ հաջորդաբար միաժամանակ: 1C-ում սա կոչվում է հարցումների փաթեթ: Մեկ փաթեթում յուրաքանչյուր հարցումն առանձնացված է ստորակետով:

Փաթեթում հարցումների քայլ առ քայլ կատարմանը հասնելու համար, որպես կանոն, սկզբում ստեղծվում են ժամանակավոր աղյուսակներ, այնուհետև ձևավորվում են դրանց համօգտագործման պայմանները՝ զտիչներ, միացումներ և միացումներ: Դրա շնորհիվ ձեռք է բերվում վերջնական արդյունք։ Խմբաքանակի ցանկացած հարցումների արդյունքում ստացված ժամանակավոր աղյուսակները շարունակում են գոյություն ունենալ մինչև ամբողջ խմբաքանակի ավարտը, կամ մինչև կատարվի հարցում, որը ոչնչացնում է ժամանակավոր աղյուսակները:

Բացի այդ, խմբաքանակային հարցումների և ժամանակավոր աղյուսակների օգտագործումը զգալիորեն մեծացնում է այս կոդի ամբողջ հատվածի ընթեռնելիությունը: Բարդ հարցումները, որոնք պարունակում են նաև ներդիր հարցումներ, կարող են շատ դժվար հասկանալ: Այնուամենայնիվ, եթե երկար բարդ հարցումը բաժանեք մի քանիսի և նույնիսկ օգտագործեք ժամանակավոր աղյուսակներ, դա ոչ միայն կբարելավի ընկալումը, այլև շատ դեպքերում կբերի կատարողականի բարձրացման:

Մեկ այլ կարևոր մանրուք 1C-ում խմբաքանակային հարցումների օգտին այն է, որ, ի տարբերություն ներդիր հարցումների, մենք կարող ենք առանձին ստանալ խմբաքանակի յուրաքանչյուր հարցման արդյունքը:

1C լեզվով հարցումների փաթեթ ստեղծելու օրինակ

Հարցումների փաթեթ ստեղծելու օրինակը տեսնելու համար մենք կօգտագործենք հարցումների դիզայներ, որը մենք կկանչենք, պարզության համար, հարցումների վահանակից: Այսպիսով, մենք կարող ենք անմիջապես տեսնել փաթեթի կատարման արդյունքը:

Եկեք ստեղծենք պարզ խմբաքանակի հարցում: Առաջարկում եմ անմիջապես տեղադրել հարցման տեքստը վահանակի մեջ, այնուհետև բացել կոնստրուկտորը և տեսնել, թե ինչպես է ձևավորվում հարցումների փաթեթը: Վահանակին ավելացրեք նոր հարցում և տեղադրեք հետևյալ տեքստը.

Ինքնապահովող: Ծնող,

Ինքնապահովվող Կոդ,

Ինքնասպասվող Արագ ընտրության ծածկագիր,

Ինքնապահովվող Անուն,

Ինքնասպասվող: Տեսակ,

Ինքնասպասվող, արտահաշվեկշռային,

Ինքնապահովվող, քանակական,

Հաշվային պլան Ինքնապահովվող ՀԾ Ինքնասպասվող

////////////////////////////////////////////////////////////////////////////////

Ինքնասպասվող TypesSubconto.Line Number AS Line Number,

Ինքնապահովվող Subconto.ViewSubconto AS TypeSubconto տեսակները,

Self-supportingTypesSubconto.TypeSubconto.Name AS Անուն,

Self-supportingTypesSubconto.TypeSubconto.ValueType ASValueType,

Self-supportingTypesSubconto.OnlyTurnover AS OnlyTurnover,

Self-supportingTypesSubconto.Summary AS Summative

Հաշվային պլան Ինքնապահովիչ Ենթահաշիվների տեսակները ՀԾ Ինքնահաշվառում Ենթահաշիվների տեսակները

ԴԱՍԱՎՈՐԵԼ ԸՍՏ

Ինքնապահովվող TypesSubconto.NumberLines

Ինձ համար այն կարծես հետևյալն է.

Հիմա եկեք գնանք հարցման դիզայներին: Այստեղ մեզ կհետաքրքրի «Պահանջել փաթեթ» ներդիրը.

Ինչպես տեսնում եք, մենք ունենք երկու հարցումների փաթեթ: Կրկնակի սեղմելով դրանցից որևէ մեկի վրա՝ կարող եք անցնել այն խմբագրելու.

Սեղմեք «Ok» կոճակը և փորձեք տեսնել խմբաքանակի հարցման արդյունքը:

Եկեք սահմանենք «Հաշիվ» պարամետրը: Դուք կարող եք ընտրել ցանկացած հաշիվ հաշվային պլանից: Ինչպես հավանաբար արդեն կռահեցիք, այս հարցումների փաթեթը պետք է ստանա հաշվի հատկություններ: Կտտացրեք «Գործարկել» և տեսեք արդյունքը.

Run() և RunBatch() մեթոդներ

Բացի Execute() մեթոդից, որը մեկ առ մեկ կկատարի բոլոր հարցումները խմբաքանակով և կվերադարձնի վերջին հարցման արդյունքը, 1C-ում կա ExecuteBatch() մեթոդ: Այն վերադարձնում է խմբաքանակի յուրաքանչյուր հարցման նմուշների զանգված: Վերոնշյալ օրինակում հենց սա է մեթոդը:

ArrayResults = Query.ExecuteBatch();

Selection1 = ArrayResults.Select();

Եթե ​​Select1.Next() Ապա

//Գործողություններ ընտրությամբ 1

վերջԵթե;

SelectionViewsSubconto = ArrayResults.Select();

1C 8.3 և 8.2 խմբաքանակի հարցումների հետ աշխատելու գրառումն առաջին անգամ հայտնվել է 1C GOODWILL ընկերության բլոգում:

1C 8.3-ում և 8.2-ում հարցումների դիզայները զարգացման հզոր գործիք է: Այն թույլ է տալիս ստեղծել հարցման տեքստ՝ օգտագործելով հատուկ տեսողական միջավայր: Այսպիսով, 1C հարցում ստեղծելու համար անհրաժեշտ չէ իմանալ ներկառուցված հարցումների լեզուն, բավական է նավարկել դիզայների պարզ և ինտուիտիվ ինտերֆեյսը:

Հարցման ստեղծողը ներդիրների մի շարք է, որոնցից յուրաքանչյուրը պատասխանատու է հարցման իր մասի համար: Այսպիսով, լրացնելով ներդիրը Աղյուսակներ և դաշտերՄենք ընտրում ենք աղյուսակներ, որոնցից 1C հարցումը կստանա տվյալ աղյուսակների տվյալներն ու դաշտերը, որոնք անհրաժեշտ են կոնկրետ խնդիր լուծելու համար: Լցնում է որմնադրությանը Պայմաններմենք պայմաններ ենք դնում ընտրված աղյուսակների վրա, որպեսզի դրանցից ընտրենք միայն մեզ անհրաժեշտ տվյալները և այլն։

Հարցման դիզայների նկարագրությունը պաշտոնական 1C 8 կայքում՝ v8.1c.ru

Աղյուսակներ և դաշտեր; ; ; ; ; ; Ներդրված հարցումներ (մշակման փուլում):

Ծրագրի կոդը 1s 8 հարցման դիզայներին զանգահարելու համար անհրաժեշտ է.

• Ստեղծեք նոր հարցում

Request = Նոր հարցում;

• Սահմանեք հարցման դատարկ տեքստային տող

Request.Text = "";

• Տեղադրեք մկնիկի կուրսորը չակերտների միջև և սեղմեք մկնիկի աջ կոճակը: Համատեքստի ընտրացանկում, որը բացվում է, ընտրեք տարրը Հարցման կառուցողև պատասխանիր Այո՛նոր հարցում ստեղծելու մասին հարցին։ Եթե ​​հարցման տեքստն արդեն գրված է, ապա դուք պետք է սեղմեք դրա ներսում ցանկացած կետ և զանգահարեք կոնստրուկտորին ;

Եկեք դիտարկենք հարցումների ստեղծողի բոլոր հիմնական ներդիրները՝ օգտագործելով աճող բարդության փոքր օրինակներ: Այս մոտեցումը թույլ կտա սկսնակ 1C ծրագրավորողին ավելի արդյունավետ ուսումնասիրել կոնստրուկտորը և նրա բոլոր հնարավորությունները: Օրինակների համար մենք կօգտագործենք կոնֆիգուրացիան Հաշվապահություն 3.0.

Դաս թիվ 1. Հարցման ստեղծողը օգտագործման ամենապարզ դեպքն է:

Առաջադրանք. գրեք հարցում նոմենկլատուրային գրացուցակում, ընտրեք գրացուցակի ամբողջ նոմենկլատուրան:

Նոր ներդիրներ. Աղյուսակներ և դաշտեր.

Նոր մեխանիզմներ՝ հարցումի տեքստի դիտում և խմբագրում «Հարցում» կոճակի միջոցով:

Հարցում ստեղծելու համար եկեք ստեղծենք նոր հարցում և կանչենք կոնստրուկտորին (ինչպես գրված է վերևում մի քանի պարբերություն): Դրանից հետո դիզայների պատուհանը կբացվի ներդիրում Աղյուսակներ և դաշտեր.

Թիվ 1 դասի տեսական մասը

Ներդիր Աղյուսակներ և դաշտերբաղկացած է երեք բաժիններից.

Տվյալների բազա. Այս բաժինը ներկայացնում է տվյալների բազայի բոլոր աղյուսակները, որոնք կարող են օգտագործվել հարցում կառուցելու համար.

Սեղաններ. Այս բաժնում ընտրված են այս հարցման համար անհրաժեշտ աղյուսակները: Այնուհետև դրանք հատվածից տեղափոխելու համար տվյալների բազաանհրաժեշտ է.

• Կամ կրկնակի սեղմեք սեղանի վրա;
• Կամ օգտագործեք «>» կամ «>>» կոճակները:

Վերևի հատվածը ՍեղաններԿան մի շարք կոճակներ: Նրանցից շատերը ավելի մանրամասն կքննարկվեն հաջորդ դասերում: Առայժմ կտամ միայն հակիրճ բացատրություններ։

• Ստեղծեք ենթահարկ(Կարմիր գիծ). Նախագծված է նոր ենթահարկ ստեղծելու համար;
• Ստեղծեք ժամանակավոր աղյուսակի նկարագրություն(դեղին գիծ): Թույլ է տալիս նշել ժամանակավոր աղյուսակի անունը, որը գտնվում է այս հարցումից դուրս; այն կարող է օգտագործվել նաև արժեքների աղյուսակը հարցմանը փոխանցելու համար.
• Փոխել ընթացիկ տարրը(կանաչ գիծ): Թույլ է տալիս անցնել ընտրված ենթհարցմանը, ժամանակավոր աղյուսակին կամ ժամանակավոր աղյուսակի նկարագրությանը.
• Հեռացնել ընթացիկ տարրը(կապույտ գիծ): Հեռացնում է ընտրված աղյուսակը ընտրված աղյուսակներից;
• Փոխարինեք աղյուսակը(կապույտ գիծ): Բացում է ընտրված աղյուսակը փոխարինելու երկխոսությունը: Օգտակար է, եթե սխալ եք ընտրել ռեգիստրի վիրտուալ աղյուսակը, քանի որ դիրքավորումը տեղի է ունենում ցուցակի ներկայումս ընտրված աղյուսակում:
• Վիրտուալ սեղանի ընտրանքներ(մանուշակագույն գիծ): Բացում է վիրտուալ ռեգիստրի աղյուսակի պարամետրերը:

Դաշտեր. Այս բաժինը ընտրում է աղյուսակի դաշտերը նախորդ բաժնից: Այս դաշտերը կլինեն աղյուսակի կամ հարցման արդյունքում ստացված ընտրության սյունակները։ Դրանք առաջին հերթին անհրաժեշտ են ընտրված աղյուսակներից միայն կոնկրետ դեպքում անհրաժեշտ տեղեկատվությունը ստանալու համար: դրանք հատվածից տեղափոխելու համար Պահանջվող սեղաններ.

• Կամ կրկնակի սեղմեք դաշտի վրա;
• Կամ օգտագործեք «>» կամ «>>» կոճակները;
• Դուք կարող եք նաև ինքներդ նոր դաշտ ավելացնել՝ օգտագործելով կամայական արտահայտություն ընտրված աղյուսակների դաշտերից և հարցման լեզվի գործառույթներից:

Վերևի հատվածը ԴաշտերԿան մի շարք կոճակներ: Կամայական արտահայտությունների միջոցով դաշտերի ստեղծումը ավելի մանրամասն կքննարկվի հաջորդ դասերում: Առայժմ կտամ միայն հակիրճ բացատրություններ։

• Ավելացնել(կանաչ գիծ): Նախագծված է նոր դաշտ ավելացնելու համար՝ օգտագործելով ազատ արտահայտությունների խմբագրիչը.
• Փոխել ընթացիկ տարրը(Կարմիր գիծ). Թույլ է տալիս փոխել ընտրված դաշտը՝ օգտագործելով խմբագրիչը.
• Ջնջել ընթացիկը(կապույտ գիծ): Հեռացնում է ընտրված դաշտը ցանկից:

Թիվ 1 դասի գործնական մասը

Մենք գործ ունենք այս դասում ներկայացված առաջադրանքը կատարելու համար անհրաժեշտ տեսության հետ: Հիշեցնեմ, թե ինչպես է դա հնչում՝ հարցում գրեք նոմենկլատուրային գրացուցակում, ընտրեք գրացուցակի ամբողջ նոմենկլատուրան։

Եկեք սկսենք ստեղծել իրերի հարցում.

• Եկեք ստեղծենք նոր հարցում և բացենք կոնստրուկտորը՝ օգտագործելով դասի սկզբում նշված մեթոդը;
• Գլխում Տվյալների բազա, արի թեմա բացենք տեղեկատուներև մենք այնտեղ ուղեցույց կգտնենք Անվանակարգ;
• Ընտրեք այն և օգտագործեք «>» կոճակը՝ այն բաժին տեղափոխելու համար Սեղաններ;
• Գլխում Սեղաններբացել նոմենկլատուրայի գրացուցակը, օգտագործելով «+» պատկերակը;
• Բացվող դաշտերի ցանկում գտեք դաշտը Հղումև տեղափոխեք այն բաժին Դաշտերօգտագործելով «>» կոճակը
• Նյութի հարցումը պատրաստ է, կտտացրեք «OK» կոճակը դիզայների պատուհանի ներքևում:

Երբ հարցումս այնքան բարդացավ, որ գերազանցեց իմ հասկացողության սահմանները, ես որոշեցի օգտագործել խմբաքանակային հարցումներ:

Բայց ես կանգնած էի այն փաստի հետ, որ ես ոչինչ չգիտեի նրանց մասին։ Պարզվեց, որ ամեն ինչ շատ պարզ է. 5 րոպեից դուք կկարողանաք օգտագործել խմբաքանակի հարցումները: Սկսեք կարդալ։

Ինչպես պարզվեց, ամեն ինչ շատ պարզ է. Պարզապես պետք է գրել մի քանի հարցումներ՝ բաժանված կետ-ստորակետերով: Արդյունքը կվերադարձվի վերջին հարցումով:

Խմբաքանակի հարցումները հայտնվել են միայն 8.1.11.67.4 տարբերակում:

Ահա խնդրանքի տեքստը.

SELECT T1.Zn PLACE VTBletters FROM (Ընտրեք «A» AS Zn ՄԻԱՎՈՐԵԼ ԲՈԼՈՐԸ SELECT «B») ՈՐՊԵՍ T1;

SELECT T1.ZN PLACE VTDIGITS FROM-ից (Ընտրեք «1» AS VN ՄԻԱՎՈՐԵԼ ԲՈԼՈՐ SELECT «2») ՈՐՊԵՍ T1;

SELECT TB.Zn, TC.Zn, TB.Zn+TC.Zn VTB տառեր AS TB, VTC համարներ AS TC

Խմբային հարցումներն ապահովվում են ցանկացած սովորական հարցումների վահանակում:

Նկարը ցույց է տալիս հարցման օրինակելի կատարումը.

Իսկ հիմա մի քիչ փորձից։ Ինչու՞ են մեզ անհրաժեշտ խմբաքանակի հարցումները:

Փաստն այն է, որ դուք կարող եք ինչ-որ միջանկյալ արդյունք տեղադրել ժամանակավոր աղյուսակում, որը կարող է անհրաժեշտ լինել մի քանի հաջորդ հարցումներում:

Նախկինում, երբ ժամանակավոր աղյուսակներ չկային, հարցման տեքստը պետք է կրկնօրինակվեր:

Դուք, իհարկե, կարող եք անել առանց խմբաքանակի հարցման՝ հաջորդաբար կատարելով մի քանի հարցումներ և շահարկելով տեղադրված աղյուսակները: Բայց դա ավելի հարմար է խմբաքանակի հարցումներով: Դուք պարզապես հարցում եք գրում և չեք մտածում ժամանակավոր աղյուսակներ տեղադրելու մասին: Ամեն ինչ ինքնուրույն է լինում։

Բացի այդ, եթե օգտագործվում է տվյալների կազմման համակարգ (DCS), այն խելամտորեն ընտրում է անհրաժեշտ դաշտերը և նվազագույնի է հասցնում հարցումների ամբողջ փաթեթը:

Եթե ​​հարցումները մեթոդ ունենային Request.Run()ապա հիմա կա մեթոդ Request.ExecuteBatch(), որը վերադարձնում է բոլոր աղյուսակները փաթեթից՝ որպես զանգված։

Խմբաքանակի հարցումների հայտարարությունը 1c կայքում՝ այստեղ. http://v8.1c.ru/overview/release_8_1_11/#Functional

Կյանքի պատմություն

Թույլ տվեք բացատրել, թե ինչն ինձ դրդեց սկսել խմբաքանակի հարցումները:

Ուրեմն, պատկերացրեք, փաստաթուղթ կա, աղյուսակային մաս ունի։ մի սյունակում» Սխալ» ցույց է տալիս, թե արդյոք փաստաթուղթը լրացնելիս սխալ կա: մի սյունակում» Տեքստի սխալներ» կարող է լինել մեկ կամ մի քանի նախադասություն սխալ տեքստերով: Նախադասություններում պարունակվող սխալների տեսակները հայտնի են նախապես։

Այսպիսով, մենք դնում ենք բոլոր սխալների ցանկը աղյուսակում Սխալի կոդերը- այն պարունակում է սխալի կոդը և որոնման ենթատողը:

Յուրաքանչյուր տողի համար մենք ստանում ենք մեկ, երկու կամ ավելի սխալ: Որովհետեւ Մեկ տողում կարող են լինել մի քանի սխալ:

Բայց սխալը կարող է չճանաչվել, այսինքն. դրոշ» Սխալ« կանգնած է, բայց սխալի տեքստը մեզ սխալի կոդ չի տվել:

Մենք կատարում ենք ձախ միացում, որտեղ սխալի կոդը NULL է, մենք տալիս ենք սխալի կոդը « Այլ սխալներ» .

Բայց խնդիրն այն էր, որ կային մոտ 200 սխալի կոդ, ուստի ձախ կապը շատ երկար աշխատեց: Ես ստիպված էի փոխարինել այն ներքին կապով, որը թռավ: Բայց միևնույն ժամանակ կորել են տողերը, որոնց համար սխալ չի հայտնաբերվել։ Ես դեռ չէի կարողանում հասկանալ, թե ինչպես կարելի է այս տողերը բերել արդյունքի:

Հարցումը գրվել է դասավորության համակարգի համար, այսինքն. Սկզբունքորեն, արժեքային աղյուսակներ կամ ժամանակավոր աղյուսակներ չեն կարող օգտագործվել: Հենց այստեղ են խմբաքանակային հարցումները օգտակար:

Ես պարզապես ևս մեկ անգամ միացրեցի սխալներով բոլոր տողերը բոլոր այն տողերի հետ, որոնց համար հայտնաբերվել են սխալներ, և դեռ ավելացրեցի «Այլ սխալներ» սխալի տեսակը: