Ներդրված հարցումներ կոնստրուկտորում: Հարցման կոնստրուկտորներ 1c հարցումների կառուցման պայմաններ
Այսպիսով, եկեք սկսենք մի պարզ բանից. ստեղծեք նոր մշակում կոնֆիգուրատորում, անվանեք այն Query Console կամ Query Builder, ինչպես ցանկանում եք:
Մենք կարող ենք անմիջապես «Տվյալների» մեջ աղյուսակ ավելացնել մեզ անհրաժեշտ ապագա Պարամետրերի համար, որպեսզի մեր Վահանակում գործարկենք ոչ թե ամենապրիմիտիվ հարցումը, այլ պարամետրերով և հղումներով, օրինակ, մեր աշխատանքի համար մենք հարցում կստեղծենք պարբերական ռեգիստրների համար։ , բայց այստեղ առանց Պարամետրերի հրահանգների=&Ամսաթիվը ոչ մի տեղ:
Մեր Պարամետրերի աղյուսակը ստեղծելու համար «Տվյալներ» ներդիրում իր «Աղյուսակային մասում» կավելացնենք նոր աղյուսակ, եկեք այն անվանենք Query Parameters, այստեղ կավելացնենք այս աղյուսակի սյունակները՝ 1) ParameterName, տեսակը string = 25 նիշ ; ParameterValue, ահա կոմպոզիտային տվյալների տեսակը, տես Նկ.
Հետևաբար, ինչպես ցույց է տրված նկարում, պարամետր արժեքի սյունակի համար մենք ընտրում ենք կոմպոզիտային տեսակ. բացվող տիպի ընտրացանկում նշեք «Կոմպոզիտային տեսակ» վանդակը, ընտրեք համարը, տողը (նշեք 20 նիշ), ամսաթիվը, բուլյան և ստուգեք: ներքևի վանդակը – AnyLink – նշանակում է այն, ինչ հետևում է, երբ մեր հարցման Պարամետրերը նշելիս մենք կարող ենք հղում կատարել մեր կազմաձևման ցանկացած օբյեկտի, օրինակ՝ դիրեկտորիաների կամ փաստաթղթերի:
Այժմ մենք պետք է ստեղծենք մեր ապագա Query Console-ի ձևը: Մշակման ընթացքում եկեք գնանք «Ձևեր» ներդիր և ավելացնենք նորը: Մենք մուտքագրում ենք այս ձևը, և այստեղ արդեն կա ստեղծագործության անսահմանափակ դաշտ. կարող եք դասավորել ձեր նոր ստեղծած երկու մանրամասները և պարամետրերով ափսե, ինչպես ցանկանում եք: Դա անելու համար դուք կարող եք օգտագործել ստանդարտ ձևի տարրեր, ինչպիսիք են Խումբը կամ էջերը էջերով (եթե նախընտրում եք շրջել էջերը.
Այստեղ գլխավորը մեկ բան է՝ «TextValues» հատկանիշը ձևը խմբագրելու ձախ դաշտ քաշելուց հետո, համոզվեք, որ դրա հատկություններում դրեք «View»=Text Document Field: Տես Նկ.
«Հարցումների աղյուսակ» հատկանիշի հատկություններում կարող եք կամայականորեն նշել «Ցուցադրման ցանց» և «Ցուցադրման վերնագրեր»:
Հաջորդը, ձևը խմբագրելու աջ պատուհանում անցեք «Հրամաններ» ներդիր և ավելացրեք նոր կոճակ, երբ սեղմեք, մեր Վահանակը կկատարի որոշակի գործողություն: Եկեք ստեղծենք «Հարցման դիզայներ» կոճակը, եթե ցանկանում եք, կարող եք կոճակի վրա պատկերակ ավելացնել, գլխավորն այն է, որ կոճակն ինքը տեղադրեք ձախ պատուհանում՝ ձևը խմբագրելու համար, որպեսզի մենք տեսնենք այն: Այնուհետև ձևը խմբագրելու աջ պատուհան, աջ սեղմեք մեր կոճակի վրա և ընտրեք հատկություններ – հատկությունների մեջ կտտացրեք «Գործողություն» կետին, կհայտնվի մոդալ պատուհան՝ հարցնելով, թե կոնկրետ որտեղ է կատարվելու մեր ծրագրի կոդը, որը մենք կհատկացնենք կոճակ - ընտրեք «Հաճախորդի վրա»:
Ձևի մոդուլը կբացվի պատրաստի դատարկ ընթացակարգով «Procedure Query Constructor (Command)»: Այս ընթացակարգի ներսում մենք կնկարագրենք զանգը ստանդարտ 1c8 Query Builder-ին: Շատ հեշտ է. Կոնստրուկտոր = Նոր խնդրանք կառուցող;Բայց այստեղ կան որոգայթներ. պլատֆորմում ներկառուցված Query Constructor-ն աշխատում է օգտագործողի ռեժիմով ՄԻԱՅՆ հաստ հաճախորդի տակ: Հետևաբար, մենք կտեղադրենք նախապրոցեսորի հրահանգի պայմանը #If, բայց այստեղ դուք ինքներդ որոշեք՝ հիմնվելով ձեր հարթակի վրա, կամ ունեք սովորական ձևեր, ապա ընտրեք « FatClientRegular Appկամ դուք ունեք հարթակ, որը հիմնված է կառավարվող ձևերի վրա, ապա « ThickClientManagedApplication«.տես նկ.
Այժմ մնում է այս ընթացակարգին ավելացնել հարցման տեքստը գրանցելու պայման, որը Query Builder-ը կստեղծի մեզ համար մեր «Հարցման տեքստ» ձևի մանրամասներում.
If Constructor.OpenModal()=True Ապա Object.RequestText=Constructor.Text; վերջԵթե;
Բայց մենք կարող ենք ձեռքով ինչ-որ բան փոխել հարցման տեքստում (օգտագործողի ռեժիմում՝ «Request Text» հատկանիշի պատուհանում), որպեսզի մեր փոփոխությունները մտնեն Query Constructor, երբ այն նորից կանչվի. մենք այստեղ կավելացնենք մի պարզ պայման.
Եթե ոչ EmptyString(Object.QueryText) Ապա Constructor.Text = Object.QueryText; վերջԵթե;
Վերջ, մենք միացրել ենք Query Constructor-ը, որը ներկառուցված է 1c8 հարթակում, եկեք նայենք մեր աշխատանքին: Դա անելու համար գործարկեք 1C:Enterprise-ը հաստ հաճախորդի ռեժիմում՝ օգտագործելով հետևյալ մեթոդներից մեկը. 2) կամ եթե դուք ունեք այս ստեղները կոնֆիգուրատորի կառավարման վահանակի վրա, պարզապես սեղմեք կոճակը դեղին շրջանակով հաստ կետով, տես նկարը.
Սկսվում է 1cEnterprise8-ի օգտագործողի ռեժիմը, մենք գտնում ենք մեր մշակումը, գործարկում ենք այն, սեղմում ենք մեր «Query Designer» կոճակը և տեսնում, թե ինչպես է բացվում հարթակում ներկառուցված դիզայները: տես նկ.
Այսպիսով, մենք ունենք Query Constructor-ը, մենք կարող ենք սկսել դրանում հավաքել մեր ապագա հարցումը, բայց մեզ հետաքրքրում է, թե ինչպես կաշխատի մեր ստեղծած հարցումը: Եվ դա անելու համար մենք պետք է ստեղծենք մեկ այլ կոճակ կոնֆիգուրատորում մեր վահանակի ձևը խմբագրելիս, եկեք այն անվանենք «Run Query»: «Գործարկել հարցումը» կոճակի հատկություններում սեղմեք «Գործողություն» վրա, նորից հայտնվում է մենյու, որում մեզ հարցնում են, թե որտեղ է մշակվելու մեր ծրագրի կոդը, այս դեպքում մենք ընտրում ենք «Եվ հաճախորդի, այնպես էլ սերվերի վրա», կրկին մենք հայտնվում ենք Ձևերի մոդուլում:
Execute Query() ընթացակարգում, որը մենք ունենք հաճախորդի վրա, մենք կգրենք պայման, եթե օգտվողը չի մուտքագրել հարցման տեքստը, այլ խնդրում է այն կատարել.
If EmptyString(Object.QueryText) Այնուհետեւ report("Enter the query text!"); վերջԵթե;
Համակարգն արդեն ավտոմատ կերպով ստեղծել է հղում դեպի Execute RequestOnServer() ընթացակարգը; – դա լավ է, եկեք գնանք այս ընթացակարգին, որը կատարվում է սերվերի վրա, և այստեղ գրենք մեր մուտքագրված հարցումը կատարելու կոդը:
Այստեղ կան տարբերակներ. Դուք կարող եք ինքներդ գրել հարցումների կառուցման հետ կապված բոլոր արտահայտությունները, այսինքն. ձեռքով, բայց կա նույնիսկ ավելի պարզ տարբերակ. ընթացակարգի ներսում աջ սեղմեք և բացվող ընտրացանկում ընտրեք «Հարցման ստեղծող արդյունքների մշակմամբ, տես նկարը»:
Եթե սեղմել եք «Հարցման ստեղծող՝ արդյունքների մշակմամբ» կետի վրա, ապա կհայտնվի «Հարցման տեքստը չգտնվե՞ց: Ստեղծե՞լ նորը» մոդալ պատուհանը, սեղմեք այո: Կբացվի ներկառուցված հարցման դիզայներ, որն իր առաջին ներդիրում է: «Արդյունքների մշակում» - ընտրեք առաջին կետը «Արդյունքը շրջանցելով»: Ահա և վերջ, այս կոնստրուկտորից մեզ այլ բան պետք չէ, կտտացրեք «Ok» կոճակին - մոդալ պատուհան կհայտնվի «Հայցում ոչ մի դաշտ ընտրված չէ, սեղմեք «Ok»:
Դրանից հետո մեր ExecuteRequestOnServer() ընթացակարգի ներսում կհայտնվի հետևյալ պատրաստի ձևանմուշը.
Անցնենք կոնստրուկտորի կողմից կառուցված արտահայտությանը.
Request.Text = "";
Request.Text = Object.RequestText;
Ահա թե որքան պարզ է, մեր «Կատարել հարցում» կոճակը մշակման ձևի վրա արդեն գործնականում գործում է, մինչ այժմ այն կարող է մշակել միայն պարզ հարցումներ առանց պարամետրերի, բայց գլխավորն այն է, որ այն աշխատում է: Մնում է միայն տեսողականորեն ցուցադրել մեր հարցման արդյունքները մշակման ձևի «Արժեքների աղյուսակ» հատկանիշում: Հիշեցնեմ, որ մեր «Արժեքների աղյուսակ» հատկանիշը «Աղյուսակային փաստաթուղթ» տեսակի է, քանի որ հակառակ դեպքում մենք մեր արդյունքները չենք տեսնի օգտվողի ռեժիմում: Աղյուսակային տվյալների ցուցադրումն օգտագործողին միշտ կատարվում է կա՛մ աղյուսակային փաստաթղթի, կա՛մ դասավորության միջոցով: Ես իսկապես կցանկանայի, որ տվյալները հնարավոր լիներ ցուցադրել արժեքների աղյուսակի միջոցով, քանի որ այն շատ հեշտ է օգտագործել և ծանոթ, բայց Ցավոք սրտի, արժեքների աղյուսակը միայն այն գործիքն է, որն անհրաժեշտ է մշակողին, դուք չեք կարող տվյալներ ցուցադրել էկրանին, օգտագործելով այն...
Եկեք ավելի սերտ նայենք, թե ինչ է աղյուսակի փաստաթուղթը. դա նման է Excel թերթի. դուք կարող եք գրանցել որոշակի բջիջում միայն աղյուսակի բջիջների միջոցով, այստեղ մենք դրանք անվանում ենք տարածք, բայց մենք ինքներս կարող ենք ընտրել այս տարածքի տիրույթը: մեկ կոնկրետ բջիջի մեջ.
Այսպիսով, մենք պարզեցինք, թե ինչ է աղյուսակային փաստաթուղթը և որոշեցինք, որ մեզ անհրաժեշտ կլինի սահմանել մեր հարցման տվյալները այս աղյուսակային փաստաթղթի կոնկրետ բջիջում: Բայց եկեք մտածենք. ո՞րն է «Հարցման արդյունքը», որը դիզայներն այդքան արագ ստեղծեց մեզ համար: Բացեք օգնությունը - Հարցման արդյունքը աղյուսակ է, որն ունի համապատասխան հատկություններ: տես նկ.
Եվ եթե մենք հիմա գրենք Query Result = Query.Execute(); արտահայտությունից հետո (ստեղծվել է կոնստրուկտորի կողմից), ահա այսպիսի պարզ ցիկլ Collections-ի համար.
Յուրաքանչյուր ColumnName From Query Result.Columns Loop report(ColumnName.Name); End Cycle;
Այս ցիկլից հետո, առայժմ նշեք կոնստրուկտորի կողմից ավտոմատ կերպով կառուցված բոլոր արտահայտությունները: Եվ գործարկեք 1C:Enterprise8-ը հաստ հաճախորդի տակ: Ստեղծեք ցանկացած պարզ հարցում (Դուք կարող եք օգտագործել Query Builder - այն արդեն աշխատում է մեզ համար) և սեղմեք «Run Query» կոճակը.
Հաղորդագրության պատուհանի ներքևում կտեսնեք, որ Հարցման արդյունքների աղյուսակը պահում է այն դաշտերի անունները, որոնք մենք հենց նոր ընտրել ենք՝ ստեղծելով պարզ հարցում:
Այժմ եկեք ցուցադրենք մեր տառապանքի դաշտերի այս անունները Աղյուսակային փաստաթղթում.
Յուրաքանչյուր ColumnName From Query Result.Columns Loop Cell=Object.QueryTable.Area(1,QueryResult.Columns.Index(ColumnName)+1); Cell.Text=ColumnName.Name; End Cycle;
Հարցման տվյալների մանրամասները ցուցադրելու համար եկեք վերլուծենք դիզայների կողմից ինքնաբերաբար ստեղծված արտահայտությունները և մտցնենք հարցման «SelectionDetailedRecords» տեսակավորման օղակի մեջ ճիշտ նույն օղակը, որը մենք օգտագործում էինք սյունակների անունները ցուցադրելու համար, միայն հիմա մենք պետք է փոխանցենք: ոչ թե «Հարցման արդյունք» աղյուսակի տվյալները Բջջային տեքստում: և հենց ընտրության տվյալները, եկեք օգնության մեջ տեսնենք, թե ինչպես կարող եք մուտք գործել հարցման Մանրամասն ընտրության դաշտ.
SelectionDetailRecords = QueryResult.Select(); Մինչ SelectionDetailedRecords.Next() Loop //առաջին տողում մենք արդեն ունենք գրված աղյուսակի սյունակների անունները, ուստի մենք բեռնում ենք տվյալները առաջին lineDocRowNumber=Object.QueryTable.TableHeight+1-ի տակ; Յուրաքանչյուր ColumnName From Query Result.Columns Cycle Cell=Object.QueryTable.Area(DocRowNumber,QueryResult.Columns.Index(ColumnName)+1); Cell.Text = SelectionDetailedRecords[ColumnName.Name]; End Cycle; End Cycle;
Այսքանը, մենք կարող ենք ստուգել, բեռնել ձեռնարկությունը հաստ հաճախորդի տակ, մուտքագրել պարզ հարցում առանց պարամետրերի, սեղմել «Run Query» կոճակը, տես նկարը.
Ուռա, ամեն ինչ աշխատում է!!!
Շատ հարմար է, երբ մեր Query Console-ը բացել/փակելիս մեր հարցման տեքստը, որի հետ աշխատել ենք մինչև կոնսոլը փակելը, կրկին գրվում է «Query Text» դաշտում։ Դա անելու համար պարզապես անհրաժեշտ է միացնել ձևի հատկությունը = Autosave, տես նկ.
Վերջ, մեր կոնսոլն աշխատում է։ Որպեսզի մենք կարողանանք գրել ավելի բարդ հարցումներ դրանցում նշված պարամետրերով, մենք պետք է ստեղծենք մեկ այլ «Գտնել պարամետրեր» կոճակը, ինչպես նաև «Գտնել պարամետրերը» կոճակի կոդը. կկատարվի «Գտնել պարամետրեր» կոճակի կոդը: հաճախորդի և սերվերի վրա: Հաջորդը, սերվերի ընթացակարգում մենք հարցումը գործարկում ենք նույն ձևով «Request Text» պատուհանից դրան փոխանցված տեքստով, օգտագործելով «Request.FindParameters()» արտահայտությունը մենք գտնում ենք անցած պարամետրերը և պարզապես մուտքագրում ենք դրանք մուտքագրեք «Հարցման պարամետրեր» ձևի աղյուսակային մասում: Մի մոռացեք այնուհետև դրանք փոխանցել պարամետրերի ամբողջական աղյուսակից «Գործարկել հարցումը» ընթացակարգին:
Դուք կարող եք նաև ավելացնել մի քանի կոճակ մեր Վահանակին, որոնք կջնջեն Պարամետրերի պատուհանը և Օգտագործողի ռեժիմում Տեքստ պահանջելու պատուհանը:
Մեր Query Console-ը պատրաստ է օգտագործման, մաղթում եմ ձեզ հաջողակ ստեղծագործ լուծումներ՝ օգտագործելով այնպիսի պարզ և հզոր գործիք, ինչպիսին Query Console-ն է:
Այս մշակումը գրված է 1c8.3 հարթակի վրա (կառավարվող ձևեր) և աշխատում է հաստ հաճախորդի տակ: Այն կարող է գրվել նաև 1c8.2 հարթակի վրա, ինչպես սովորական, այնպես էլ կառավարվող ձևերի տակ:
Ներբեռնումը պարունակում է Query Console-ի նմուշ, որը մենք ստեղծել ենք:
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Query Console-ի թարմացում.
1) Այժմ մեր տնական Query Console-ը ներկառուցված Query Builder-ով կաշխատի ցանկացած հաճախորդի տակ՝ սովորական և կառավարվող ձևերի հաստ հաճախորդի և բարակ և վեբ հաճախորդի տակ:
p.s. Ներկառուցված Query Builder-ի ձևն ու տեսքը տարբեր են՝ կախված նրանից, թե որ հաճախորդի ներքո ենք գործարկել մեր Console-ը: (Ես անձամբ ավելի ծանոթ և հարմար եմ Query Builder-ի ձևին՝ հաստ հաճախորդի տակ)
&Client Procedure Query Constructor (Հրաման) // ստանդարտ Query Constructor կանչելը հնարավոր է միայն հաստ հաճախորդի տակ #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 («Հարցումների ստեղծողին զանգահարելը հնարավոր է միայն հաստ հաճախորդի տակ»); // Վերադարձ; //# EndIf #Else Report («Դուք աշխատում եք Query Builder-ը բարակ հաճախորդի տակ. այն փոքր-ինչ տարբերվում է իր ձևով և կատարողականի արագությամբ»); Constructor = New QueryConstructor(); Եթե ոչ EmptyString(Object.QueryText) Ապա Constructor.Text = Object.QueryText; վերջԵթե; Constructor Alert = New AlertDescription ("RunAfterClosingConstructor", ThisForm); Constructor.Show(Constructor Alert); # EndIf End of Procedure &On the Client Procedure ExecuteAfterClosingConstructor(Result, ConstructorParameters) Export //Result=text, եթե Constructor-ը փակվել է՝ օգտագործելով ok կոճակը Object.RequestText = AbbreviatedLP(Result); //աշխատում է!!! Ընթացակարգի ավարտը
2) Ավելացվեց մեր պարզ Query Console-ին բարդ հարցումներ մուտքագրելու հնարավորություն՝ պարամետրերին փոխանցված Ժամանակավոր աղյուսակով!!! Մեխանիզմը պարզվեց շատ պարզ և էլեգանտ՝ առանց XML կոդ օգտագործելու, ինչպես դա արվում է պրոֆեսիոնալ կոնսուլներում:
Դուք կարող եք տեսնել ինքնին կոդը և Ժամանակավոր աղյուսակների պարամետրերին փոխանցման մեխանիզմի ընթացակարգերը երկրորդ կից ֆայլում: Ինչպես ես սկսեցի մշակել Ժամանակավոր աղյուսակների իմ սեփական տարբերակը պարամետրերով, կարելի է գտնել այս հղումով https://forum.infostart.ru/forum9/topic183700/
Այժմ ինչպես օգտագործել Console-ը բարդ հարցման համար, երբ ժամանակավոր աղյուսակը փոխանցվում է իր պարամետրերին: Օրինակ, կարող եք վերցնել այս հարցման կոդը.
SELECT ExternalData.Product, ExternalData.Quantity PLACE ExternalData FROM &ExternalData AS ExternalData; //////////////////////////////////////////// ////////////////////////// SELECT ExternalData.Product, ExternalData.Quantity, ISNULL(RemainingProductRemaining.QuantityRemaining, 0) AS Field1, ISNULL(Remaining) ProductsRemainings.QuantityRemainings, 0) - ExternalData.Quantity AS Remaining FROM ExternalData AS ExternalData LEFT JOIN Գրանցվել կուտակումներ.Մնացած արտադրանք. ծորան = RemainingProductRemaining Ապրանք
Վերոնշյալ հարցման կոդի օրինակի և նմանության հիման վրա դուք կարող եք ստեղծել ձեր սեփական բարդ հարցումը՝ հաշվի առնելով ձեր տվյալների օբյեկտները:
Այսպիսով, հարցման դիզայներում մենք ստեղծեցինք վերը նշված հարցումը, փակելով Constructor-ը, հարցման տեքստը կմտնի մեր վահանակի «Հարցման տեքստ» դաշտը, կտտացրեք «Գտնել պարամետրեր» կոճակը, մենք տեսնում ենք, որ Պարամետրերի աղյուսակում տող է հայտնվել: = «Արտաքին տվյալներ», Արժեքի տեսակ = «Արժեքների աղյուսակ» ,տե՛ս նկ.
Պարամետրերի այս աղյուսակում - մուտքագրեք Ամսաթիվ պարամետրը, օրինակ՝ այսօրվա ամսաթիվը, այնուհետև կտտացրեք՝ փորձելով խմբագրել մեր աղյուսակի ժամանակավոր պարամետրը «Արտաքին տվյալներ», սեղմեք «Արժեքների աղյուսակ» դաշտում երեք կետերի վրա. հայտնվի, սեղմեք Row, մեր մեխանիզմը մեզ շրջում է ձևի էջը, որտեղ մենք պետք է ձեռքով մուտքագրենք այս շատ ժամանակավոր աղյուսակը:
Այստեղ նկատի ունեցեք, որ այս դեպքում «Ժամանակավոր աղյուսակի անվանումը պարամետրերում» դաշտի ներքևի «TimeTables» էջում կհայտնվի մեր ժամանակավոր աղյուսակի անունը (այն պատճենված է Պարամետրերի աղյուսակից):
Մինչ այժմ «Ժամանակային աղյուսակներ» էջում մենք տեսնում ենք միայն մեկ դատարկ աղյուսակ՝ սա մեր ապագա ժամանակավոր աղյուսակի տեսակների աղյուսակն է։ «Ավելացնել» կոճակի միջոցով կավելացնենք ապագա աղյուսակի մանրամասների անվանումը և տեսակը։ . Զգույշ եղեք. անունը և տեսակը պետք է համապատասխանեն այն, ինչ մենք նշել ենք &ExternalData-ի հարցում.
Այժմ մենք սեղմում ենք «Թարմացնել ժամանակավոր աղյուսակը» կոճակը, և մենք այստեղ կունենանք երկրորդ աղյուսակը, մենք ուղղակիորեն այն կլցնենք ժամանակավոր աղյուսակի տվյալներով «Ավելացնել» կոճակի միջոցով:
Վերջ, մենք կարող ենք ևս մեկ անգամ ինքներս մեզ ստուգել, թե արդյոք մուտքագրել ենք հարցման պարամետրերի պարզունակ տվյալները մշակման 1-ին էջի պարամետրերի աղյուսակում և սեղմել «Գործարկել հարցումը» կոճակը. ամեն ինչ հաշվարկվում և ընտրվում է համապատասխանաբար: մեր ժամանակավոր աղյուսակի պարամետրում փոխանցված տվյալների սահմանափակում
p.s. Եթե սխալ եք թույլ տվել մանրամասների անվանումը և դրանց տեսակները մուտքագրելիս (առաջին աղյուսակում), պարզապես փակեք վահանակը և նորից բացեք այն, ժամանակավոր տվյալների աղյուսակը կջնջվի, և «Տիպեր» աղյուսակը կրկին կարող է խմբագրվել և նոր տվյալների աղյուսակը կարող է կրկին ստեղծվել:
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Այսքանը, մենք կարող ենք ստեղծել շատ հզոր աշխատանքային գործիք մեր սեփական ձեռքերով, բացի այդ, մեր վահանակը դեռ շատ արագ է, համեմատած պրոֆեսիոնալների հետ, և սա շատ մեծ պլյուս է մշակողների համար: Եվ, իհարկե, այժմ մեր վահանակն աշխատում է ցանկացած հաճախորդի ներքո: Հաջողություն ձեր ստեղծագործական զարգացումներում!!!
Եկեք նայենք, թե ինչպես կարող ենք միացնել այս երկու աղյուսակները ըստ դաշտի Ապրանքի կոդըօգտագործելով
հարցման կոնստրուկտոր (որպես օրինակ տրված է ժամանակավոր աղյուսակներ ստեղծելու կոդը
Ես չեմ անի: Դուք կարող եք վերցնել այն վերը նշված հղումից):
Բացեք դիզայների պատուհանը, անցեք ներդիր «Սեղաններ և դաշտեր», դեպի հատված
«Սեղաններ»ընտրեք մեր երկու աղյուսակները և բաժնում «Դաշտեր» -
երկու աղյուսակների այն դաշտերը, որոնք մենք ցանկանում ենք տեսնել հարցման արդյունքում:
Գնացեք էջանիշ «Միացումներ». Ավելացնել նոր տող: Դաշտում Աղյուսակ 1
բացվող ցանկից ընտրեք ապրանքների աղյուսակը և դաշտում Աղյուսակ 2Աղյուսակ
երկրների հետ։
Համար Աղյուսակներ 1ստուգեք վանդակը Բոլորը. Համար
Աղյուսակներ 2Մենք չենք նշում այս վանդակը: Սա նշանակում է, որ սկսած Աղյուսակներ 1
բոլոր գրառումները կընտրվեն, և սկսած Աղյուսակներ 2միայն նրանց համար, որոնց համար այն կատարվում է
կապի պայմանը, այսինքն դրոշների նման համադրությամբ մենք ստանում ենք
ՁԱԽ ՄԻԱՑՈՒՄ. Հաջորդը դուք պետք է լրացնեք Կապի վիճակ.
Այստեղ մենք ընտրում ենք աղյուսակի դաշտերը բացվող ցուցակներից և համեմատության նշանը նույնպես բացվող ցանկից
ցուցակը. 
Այս կապի արդյունքում մենք ստանում ենք հետևյալ հարցման տեքստը.
SELECT VT_Product.Product Code, VT_Product.Name, VT_Country.Country FROM VT_Product AS VT_Product LEFT ՄԻԱՑԵՔ VT_Country AS VT_Country BY VT_Product.Product Code = VT_Country.Product
Հիմա եկեք ավելի սերտ նայենք որոշ կետերի:
Փորձենք փոխել վանդակը Բոլորը.
Թվում է, թե ի վերջո պետք է ստացվի ՃԻՇՏ ՄԻԱՑԵՔ, բայց եթե մենք
Եկեք նայենք կոնստրուկտորի կողմից ստեղծված հարցման տեքստին, կտեսնենք, որ աղյուսակները
փոխանակվեցին տեղերով, բայց կապը դեռ մնաց ձախ.
SELECT VT_Product.Product Code, VT_Product.Name, VT_Country.Country FROM VT_Country AS VT_Country LEFT ՄԻԱՑԵՔ VT_Product AS VT_Product BY VT_Product.Product Code = VT_Country.Product
Տեսնենք, թե ինչ կլինի, եթե հանենք երկու վանդակների նշումը 
Արդյունքում մենք ստանում ենք ներքին կապ:
SELECT VT_Product.Product Code, VT_Product.Name, VT_Country.Country FROM VT_Product AS VT_Product INTERNAL JOIN VT_Country AS VT_Country BY VT_Product.Product Code = VT_Country.Product
Վերջապես, եթե երկու վանդակներն էլ նշված են 
մենք ստանում ենք լիարժեք կապ
SELECT 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.Product Code = VT_Country.Product
Էջանիշի վրա կարող եք նշել մի քանի տող Միացումներ. Այս դեպքում մի քանի
շարքերը միացված են ըստ պայմանի ԵՎ. Ընդ որում, տողերն անհրաժեշտ չեն
ամեն անգամ նորից ներս քշել: Դրանք կարելի է պատճենել՝ օգտագործելով բանալին F9.
Իսկ նոր տողում փոխեք միայն միացման պայմանը։ Սա զգալիորեն արագացնում է զարգացումը:
Բացի այդ, հղման վիճակում անհրաժեշտ չէ օգտագործել միայն նախապես սահմանված դաշտերը
բացվող ցուցակները: Դուք կարող եք օգտագործել կամայական արտահայտություն, որը բավարարում է
1C հարցման լեզու: Դա անելու համար դուք պետք է նշեք վանդակը անվճար
և մուտքագրեք պայմանը անմիջապես դաշտում կամ բացեք օժանդակ պատուհանը
որտեղ կարող եք օգտագործել հարցման լեզվի գործառույթներով ձևանմուշներ: 
Իհարկե, գործնականում կան շատ ավելի բարդ հարցումներ, որտեղ
մի քանի սեղաններ՝ միմյանց միջև տարբեր կապերով: Բայց հարցման շինարարում
ցանկացած բարդության միացումներ կարող են վերարտադրվել:
Հարցման դիզայները բաղկացած է հետևյալ ներդիրներից.
1. «Սեղաններ և դաշտեր» - ներդիրում կան երեք հիերարխիկ ցուցակներ.
ա. «Տվյալների բազա» - թվարկում է բոլոր հասանելի օբյեկտները, որոնց նկատմամբ կարող է հարցում կատարել: Նաև կոճակ «Ցուցադրել փոփոխության աղյուսակները», որի միջոցով կարող եք մուտք գործել տեղեկատվական անվտանգության օբյեկտների փոփոխությունների աղյուսակներ, եթե դրանք գրանցված են փոխանակման որևէ պլանում:
բ. «Սեղաններ» - ընտրված աղյուսակների ցանկ, որոնց վրա կկատարվի հարցումը: Նաև այս պատուհանում կարող եք ջնջել աղյուսակը, վերանվանել կամ փոխարինել աղյուսակը և ավելացնել ներքին հարցում:
Վիրտուալ աղյուսակների համար կարող եք պարամետրեր նշանակել՝ սեղմելով «Վիրտուալ աղյուսակների պարամետրեր» կոճակը.
Խորհուրդ է տրվում ակտիվորեն օգտագործել վիրտուալ աղյուսակների պարամետրերը որոշակի չափերով ընտրելու համար, քանի որ դա մեծացնում է հարցումների կատարման արագությունը: Պարամետրերում կարող եք օգտագործել արտաքին փոփոխականներ, որոնց անուններին նախորդում է «&» նշանը:
գ. «Դաշտեր» - աղյուսակներից ընտրված դաշտերի ցանկ: Կարող եք նաև ավելացնել հաշվարկված դաշտեր, դրա համար սեղմելով «Ավելացնել» կոճակը բացվում է հատուկ արտահայտությունների կառուցող.
Ձախ կողմում կա մի պատուհան, որտեղ առկա են արտահայտության մեջ առկա դաշտերը: Աջ կողմում օգտագործված գործառույթների ակնարկն է: Ստորև բերված է կառուցվող կամայական արտահայտություն: Արտահայտությունների մեջ կարող եք օգտագործել արտաքին պարամետրեր, դրանք նշվում են «&» նշանի միջոցով, օրինակ՝ &Period, &StartDate
Պետք է զգույշ լինել, եթե պատուհանում մուտքագրված է երկար և բարդ արտահայտություն, որը պարունակում է շարահյուսական փոքր սխալ, ապա «OK» կոճակը սեղմելուց հետո համակարգը նախազգուշացում կտա և կփակի պատուհանը։ Բոլոր մուտքագրված կոդը կկորչի, ուստի խորհուրդ եմ տալիս, որ եթե վստահ չեք արտահայտության ճիշտության մեջ, ապա միշտ պահպանեք բովանդակությունը clipboard-ում (Ctrl-C), նախքան կոնստրուկտորը փակելը:
2. «Հարաբերություններ» - ներդիրում նշված են աղյուսակների միջև կապերը:
Աղյուսակը ցույց է տալիս կապակցվող աղյուսակները, կապվող աղյուսակների և կապի պայմանը: Եթե կապի պայմանը բարդ է, ապա կարող եք նշել որոշակի հաշվարկված արտահայտություն, և կբացվի մաքսային դաշտի կոնստրուկտորը:
3. «Խմբավորում» - ներդիրը ցույց է տալիս, թե որ դաշտերն են խմբավորված և որոնք են ագրեգացված (ամփոփված):
4. «Պայմաններ» ներդիր - թվարկում են այն պայմանները, որոնք դրվում են հայտի վրա:
Պայմաններում կարող եք նաև բարդ արտահայտություններ գրել՝ օգտագործելով պարզ արտահայտությունների կառուցող և օգտագործելով արտաքին փոփոխականներ.
5. «Ընդլայնված»
Հարցման վրա դրված լրացուցիչ պարամետրեր
6. «Ասոցիացիաներ և կեղծանուններ».
Այս ներդիրում դուք կարող եք նշանակել մականուններ դաշտերի համար, ինչպես նաև կառավարել հարցումները, որոնք միացված են «ՄԻԱՎՈՐԵԼ» կամ «ՄԻԱՎՈՐԵԼ ԲՈԼՈՐԸ» կառուցվածքների միջոցով:
7. «Պատվեր»
Ի՞նչ հերթականությամբ կցուցադրվեն հարցման արդյունքները:
Ուշադրություն. Էջանիշի ներքևի մասում դուք կարող եք տեսնել նշան «Ավտոպատվեր»- ACS-ում 1C 8.1-ի ընթացիկ տարբերակում դա անիմաստ է, ավելին, երբ վանդակը ստուգվում է, ձայնագրման ժամանակ ACS-ը սխալ է տալիս, ուստի չպետք է օգտագործեք այն:
8. «Տվյալների կազմը».
Այն ներդիրը, որում սահմանված են մուտքի վերահսկման համակարգի սպասարկման դաշտերը: Այն խաղում է մոտավորապես նույն դերը, ինչ «Report Builder» ներդիրը սովորական հաշվետվությունների նախագծման մեջ:
A. «Սեղաններ» ներդիրում - նշված են հարցման մեջ օգտագործվող աղյուսակները, դուք կարող եք նշել, թե արդյոք աղյուսակը պետք է ներառվի հարցման մեջ՝ նշելով «Պահանջվում է» վանդակը: Նրանք. եթե ընտրության մեջ ոչ մի դաշտ ներառված չէ, ապա այս աղյուսակը ընդհանրապես չի մասնակցում հարցմանը: Կարող եք նաև նշել աղյուսակների պարամետրերը:
Մուտքի կառավարման համակարգի ստեղծման գործընթացում մենք նշում ենք ցանկացած ընտրություն, այնուհետև ընտրության բոլոր արժեքները կփոխարինվեն վիրտուալ աղյուսակների պարամետրերում, ինչը կրկին կօգնի մեզ օպտիմալացնել և արագացնել հարցումը:
բ. «Դաշտեր» ներդիրում նշված են դաշտերը և դրանց անունները, որոնք կավելացվեն 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ընկալման համար այնքան էլ հարմար չէ, եկեք մկնիկի աջ կոճակով վերանվանենք աղյուսակը Մատակարարների թիվը, դրանից ընտրեք դաշտ Արտադրանքև էջանիշի վրա ՊայմաններԳրենք անհրաժեշտ պայմանը. 
Եվ այս բոլոր մանիպուլյացիաներից հետո մենք ստանում ենք ցանկալի խնդրանքը։ Անհրաժեշտության դեպքում կարող եք հարցումներ ստեղծել մի քանի մակարդակներով բույնի վրա:
Ինչպես կատարել կառուցողական հարցում սովորական հարցումից
Շատ հաճախ իրավիճակ է ստեղծվում, երբ սկսում ես հարցում անել կոնստրուկտորում և ինչ-որ պահի հասկանում ես, որ այն պետք է բույն դրված լինի։ Իհարկե, մեր օրինակում խնդիր չկա. դուք կարող եք պարզապես ջնջել ամեն ինչ և նորից թողարկել հարցումը: Բայց պրակտիկայում կան շատ ավելի բարդ օրինակներ, օրինակ՝ մի քանի մակարդակի բնադրումով, երբ մի քանի ժամ է ծախսվել հարցումը կատարելու համար։ Եվ այս դեպքում բավականին պարզ ելք կա. Դուք կարող եք օգտագործել դիզայների մեջ ներկառուցված հարցման տեքստային խմբագրիչը: Պետք է օգտագործել կոճակ Հայցստացեք հարցման տեքստը (տես վերևի նկարը) և պատճենեք այն clipboard-ում: Հաջորդը, ստեղծեք նոր ներդիր հարցում և կրկին սեղմեք կոճակը Հայց, տեղադրեք տեքստը բուֆերից, սեղմեք OK: Համապատասխանաբար, մենք մաքրում ենք հին խնդրանքը ամենաբարձր մակարդակով: Այս կերպ, անհրաժեշտության դեպքում, մենք կարող ենք հեշտությամբ ստեղծել բազմամակարդակ nested հարցումներ թռիչքի ժամանակ:
Հարցման տեքստը «ձեռքով» գրելու ունակությունը երբեք «ավելորդ» չի եղել, բայց ավելի հարմար է օգտագործել հարցումների դիզայներ:
Մեկնաբանություն.
Ցավոք, կառավարվող հավելվածում դուք չեք կարող օգտագործել հարցումների դիզայները «Ծանոթանալ հարցումների հետ» մշակման մեջ: Դուք կարող եք օգտագործել այն այս մշակման մեջ՝ անցնելով նորմալ ռեժիմի, բայց մենք դա չենք անի:
Եկեք ստեղծենք «Request Constructor» մշակումը և սահմանենք այն «Reports and Processing» ենթահամակարգում։
Ստեղծենք մշակող ձև և դրա մեջ ավելացնենք «TabDoc» ձևի «Tabular Document» տիպի հատկանիշը, ինչպես նաև «Run Query» հրամանը՝ «Run Query» գործողությամբ։ Հաջորդը, դրանք քաշեք ձևի վրա:
Ձևի մոդուլում, որպեսզի հրամանը աշխատի, մենք գրում ենք ընթացակարգ.
&OnClient
Հարցման կատարման ընթացակարգ (հրաման)
ExecuteRequestServer();
Ընթացակարգի ավարտը
&Սերվերի վրա
Ընթացակարգի ավարտը
Մենք դառնում ենք սերվերի վրա կանչված ընթացակարգի ներսում և համատեքստի ընտրացանկից կանչում ենք «Հարցումների կառուցող՝ արդյունքների մշակմամբ» (Նկար 2.65):
Նկար 2.65 Հարցման կոնստրուկտոր՝ արդյունքների մշակմամբ
Վերամշակման տեսակը սահմանեք «Արդյունք դեպի աղյուսակային փաստաթուղթ» և սեղմեք «Հաջորդ» կոճակը կամ «Սեղաններ և դաշտեր» ներդիրը:
Դիզայների «Սեղաններ և դաշտեր» ներդիրում կարող եք դիտել համակարգում առկա աղյուսակները (ձախ հատվածը վերնագրված է «Տվյալների բազա») (Նկար 2.66):
Նկար 2.67 Հարցման կառուցող
Աղյուսակները, որոնցից հարցումը կստանա տվյալներ, տեղափոխվում են «Սեղաններ» տարածք, հարցումով պահանջվող դաշտերը՝ «Դաշտեր» տարածք: Եկեք դա անենք, ինչպես Նկար 2.68-ում:
Նկար 2.68 Հարցման կոնստրուկտոր
Այստեղ մենք հանել ենք ստեղծված լռելյայն դիտման դաշտը՝ «ՊՐԵՍԵՆՏԱՑԻԱ (Ապրանքի ստացման Ապրանքներ. Անվանակարգ)»
Դիզայների հետ աշխատելիս ցանկացած պահի կարող եք դիտել ստացված հարցման տեքստը: Այս առաջադրանքը կատարելու համար դուք պետք է սեղմեք «Պահանջել» կոճակը, որը գտնվում է դիզայներական ձևի ստորին ձախ անկյունում (Նկար 2.69):
Դուք կարող եք ձեռքով խմբագրել հարցման տեքստը՝ սեղմելով «Խմբագրել» կոճակը:
Պրակտիկա. Սեղմեք «OK» կոճակը և ստուգեք մեր մշակումը օգտվողի ռեժիմում: Եթե դուք վերլուծում եք հարցումը կատարելիս ստացված տվյալները, կարող եք հանդիպել ապրանքների կետերի «կրկնություններին» (եթե դա ձեզ մոտ չի ստացվում, ապա կարող եք պատճենել և տեղադրել «Ապրանքների անդորրագիր» ցանկացած փաստաթուղթ):
Մենք վերադառնում ենք ExecuteRequestServer() ընթացակարգին «Request Constructor» մշակման մեջ և համատեքստի ընտրացանկից կրկին կանչում ենք «Query Constructor with result processing»:
Եթե ցանկանում եք «փլուզել» հարցման արդյունքը, ապա այդ նպատակով կարող եք օգտագործել հարցումների դիզայների «Խմբավորում» ներդիրը:
Խմբավորումներ սահմանելիս պետք է հետևել հետևյալ կանոնին. հարցման ընտրության բոլոր դաշտերը բաժանվում են դաշտերի, որոնցով կատարվում է խմբավորումը (կոնվոլյուցիան), ներդիր աղյուսակների դաշտերը (դաշտերը, որոնք ամփոփված են նրանց հետ, որոնցով իրականացվում է խմբավորումը) և ագրեգատ։ գործառույթները։ Եկեք սահմանենք խմբավորումները (Նկար 2.70):
Նկար 2.70 Հարցման ստեղծող
Եթե հարցումով ստացված տվյալները պետք է ընտրվեն ինչ-որ պայմանի համաձայն, ապա այս դեպքում կարող է անհրաժեշտ լինել օգտագործել «Պայմաններ» ներդիրը: Եկեք ընտրենք Goods ReceiptGoods.Quantity=10 (Նկար 2.71):
Նկար 2.71 Հարցման կոնստրուկտորի պայման:
Խնդրում ենք նկատի ունենալ, որ եթե պայմանը սահմանված է այնպես, ինչպես նկարում, հարցումը չի կատարվի:
Իրավիճակը շտկելու երկու եղանակ կա.
Վերասահմանելով պայմանը՝ ստուգելով «P...» դրոշակը;
Օգտվելով ինքնին հարցման տեքստը փոխելու հնարավորությունից (ստացվում է «Խմբագրել հարցումը» կոճակի վրա սեղմելով):
Ձեռնարկի փոփոխությունն ինքնին բաղկացած կլինի նրանից, որ անհրաժեշտ է հեռացնել «&» նշանը «10» թվից առաջ: Հարցման տեքստում այս նշանը սահմանում է հարցման պարամետրերը, որոնց մեջ որոշ արժեքներ պետք է գրվեն ավելի ուշ (բայց նախքան հարցումը կատարելը): Կտտացրեք «Խմբագրել հարցումը» կոճակը և խմբագրեք (Նկար 2.72):
Նկար 2.73 Հարցման խմբագրում
«Ընդլայնված» ներդիրում կարող եք ստուգել մի շարք դրոշակներ (կապված հարցման լեզվի «Ընտրել» հիմնաբառի հետ) և որոշել հարցումը փոխելու համար նախատեսված աղյուսակների կազմը (Նկար 2.74):
Նկար 2.74 Հարցման լրացուցիչ գործառույթներ
«Միացումներ/Անանուններ» ներդիրում կարող եք փոխել դաշտերի անվանումները՝ դնելով «Անանուններ», բայց մենք դա չենք անի:
«Պատվեր» ներդիրում հարցման արդյունքում կարող եք որոշել գրառումների տեսակավորման կարգը (Նկար 2.75):
Նկար 2.75 Գրառումների տեսակավորման կարգը
Ուշադրություն դարձրեք «Auto-order» դրոշակին, այն կարող է օգտագործվել տեղեկանքի տիպի դաշտերով պատվիրելու համար:
«Ընդամենը» բաժինը սահմանելիս պետք է պատրաստ լինել, որ հարցման արդյունքում կհայտնվեն «լրացուցիչ» ընդհանուր գրառումները: Այս գրառումների հետ մեկտեղ հարցման արդյունքը դառնում է հիերարխիկ (Նկար 2.76):
Նկար 2.76.Հարցման կոնստրուկտորի արդյունքները:
Հնարավոր է նշել ընդհանուրների մի քանի տեսակներ.
Տարրեր (հարցման արդյունքների ընտրությունը պարունակում է խմբավորման ընդհանուր գումարներ և մանրամասն գրառումներ);
Հիերարխիա (հարցման արդյունքների ընտրության մեջ, ընդհանուր դեպքում, կան ամփոփ գրառումներ ըստ հիերարխիայի, ամփոփ գրառումներ ըստ խմբավորման և մանրամասն գրառումներ);
Միայն հիերարխիա (հարցման արդյունքների ընտրության մեջ, ընդհանուր առմամբ, կան ամփոփ գրառումներ ըստ հիերարխիայի):
Կոնստրուկտորի «Ok» կոճակը սեղմելուց հետո կստեղծվի «Layout» և ExecuteRequestServer() ընթացակարգի կոդը կգրվի ձևի մոդուլում.
&Սերվերի վրա
Գործընթացը ExecuteRequestServer()
//((QUERY_CONSTRUCTOR_WITH_RESULT_PROCESSING
// Այս հատվածը կառուցված է կոնստրուկտորի կողմից:
// Կոնստրուկտորը նորից օգտագործելիս ձեռքով կատարված փոփոխությունները կկորչեն!!!
Layout = Processing.QueryConstructor.GetLayout("Layout");
Request = Նոր հարցում;
Request.Text =
| Ապրանքների ստացում Ապրանքների անվանացանկ AS անվանակարգ,
| ԳՈՒՄԱՐ (Ապրանքների ստացում Ապրանքներ. Քանակ) 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("Nomenclature");
TabDoc.Clear();
TabDoc.Output (AreaHeader);
TabDoc.Output (TableHeadArea);
TabDoc.StartAutoGroupingRows();
SelectionNomenclature = Result.Select(BypassQueryResult.ByGrouping);
Մինչ SelectionNomenclature.Next() Loop
Եթե SelectionNomenclature.RecordType() = RequestRecordType.TotalByHierarchy Ապա
Տարածք = AreaNomenclatureHierarchy;
Տարածաշրջան = RegionNomenclature;
վերջԵթե;
Area.Parameters.Fill(SelectionNomenclature);
TabDoc.Output(Area, SelectionNomenclature.Level());
End Cycle;
TabDoc.FinishAutoGroupingRows();
TabDoc.Output (TableFooterArea);
TabDoc.Output (AreaFooter);
//)) CONSTRUCTOR_QUERY_WITH_RESULT_PROCESSING
