Mga nested na query sa constructor. Query constructor 1c query constructor kundisyon
Kaya, magsimula tayo sa isang simpleng bagay: lumikha ng Bagong Pagproseso sa configurator, pangalanan itong Query Console o Query Builder, ayon sa gusto mo.
Maaari kaming agad na magdagdag ng isang talahanayan sa "Data" para sa mga Parameter sa hinaharap na kailangan namin, upang sa aming Console ay hindi namin pinapatakbo ang pinaka-primitive na kahilingan, ngunit may mga parameter at link, halimbawa, para sa aming trabaho, gagawa kami ng isang kahilingan sa mga pana-panahong pagrehistro , ngunit dito nang walang mga tagubilin sa Parameter=&Date wala kahit saan.
Upang lumikha ng aming talahanayan ng Mga Parameter, sa tab na "Data" sa "Tabular na bahagi" nito ay magdaragdag kami ng bagong talahanayan, tawagin natin itong Mga Parameter ng Query, dito idaragdag namin ang mga haligi ng talahanayang ito: 1) ParameterName, uri ng string = 25 character ; ParameterValue, narito ang isang pinagsama-samang uri ng data, tingnan ang Fig:
Samakatuwid, tulad ng ipinapakita sa larawan, pumili kami ng isang pinagsama-samang uri para sa column ng Parameter Value: sa uri ng menu na bubukas, lagyan ng tsek ang checkbox na "Composite type", piliin ang numero, string (tumukoy ng 20 character), petsa, Boolean, at lagyan ng check ang checkbox sa ibaba – AnyLink – ang ibig sabihin nito ay ang sumusunod, kapag tinukoy ang Mga Parameter ng aming kahilingan, maaari kaming sumangguni sa anumang bagay ng aming configuration, halimbawa, mga direktoryo o dokumento.
Ngayon ay kailangan naming gumawa ng form ng aming Query Console sa hinaharap. Sa pagpoproseso, pumunta tayo sa tab na "Mga Form" at magdagdag ng bago. Ipinasok namin ang form na ito at narito na ang isang walang limitasyong field para sa pagkamalikhain - maaari mong ayusin ang dalawang detalye na kakagawa mo lang at isang plato na may mga parameter ayon sa gusto mo! Upang gawin ito, maaari mong gamitin ang mga karaniwang elemento ng form tulad ng isang Pangkat o isang Pahina na may mga pahina (kung mas gusto mong mag-flip ng mga pahina.
Ang pangunahing bagay dito ay isang bagay: pagkatapos i-drag ang attribute na "TextValues" sa kaliwang field ng pag-edit ng form, siguraduhing itakda ang "View"=Text Document Field sa mga property nito. Tingnan ang Fig:
Sa mga katangian ng attribute na "Query Table", maaari mong opsyonal na tukuyin ang "Display Grid" at "Display Header".
Susunod, sa kanang window para sa pag-edit ng form, pumunta sa tab na "Mga Command" at magdagdag ng bagong button, kapag na-click, magsasagawa ang aming Console ng isang partikular na pagkilos. Gumawa tayo ng Button na "Query Designer", kung gusto mo, maaari kang magdagdag ng icon sa button, ang pangunahing bagay ay ilagay ang button mismo sa kaliwang window para sa pag-edit ng form - upang makita natin ito. Pagkatapos ay sa kanang window para sa pag-edit ng form, i-right-click ang aming button at piliin ang mga katangian - sa mga katangian, mag-click sa item na "Action", lilitaw ang isang modal window na nagtatanong kung saan eksaktong isasagawa ang aming program code, na itatalaga namin sa button – piliin ang “Sa client”.
Ang Form Module ay magbubukas sa isang handa na walang laman na pamamaraan na "Procedure Query Constructor (Command)". Sa loob ng pamamaraang ito, ilalarawan namin ang tawag sa karaniwang 1c8 Query Builder. Ito ay napakadali: Constructor = Bagong Request Constructor; Ngunit may mga pitfalls dito - ang Query Constructor na binuo sa platform ay gumagana sa user mode LAMANG sa ilalim ng makapal na kliyente! Samakatuwid, ilalagay namin ang kondisyon ng pagtuturo ng preprocessor #Kung, ngunit dito ka magpasya para sa iyong sarili, batay sa iyong platform, o mayroon kang mga ordinaryong form, pagkatapos ay piliin ang " FatClientRegularApp" o mayroon kang isang platform batay sa mga pinamamahalaang form, pagkatapos ay " ThickClientManagedApplication“.tingnan ang fig.
Ngayon ay nananatili pa ring magdagdag sa pamamaraang ito ng kundisyon para sa pagtatala ng text ng kahilingan, na bubuo ng Query Builder para sa amin sa aming mga detalye ng form na “Teksto ng Kahilingan”:
Kung Constructor.OpenModal()=True Then Object.RequestText=Constructor.Text; tapusin kung;
Ngunit maaari naming manu-manong baguhin ang isang bagay sa text ng kahilingan (sa user mode - sa window ng attribute na "Request Text") upang ang aming mga pagbabago ay mapunta sa Query Constructor kapag tinawag itong muli - magdaragdag kami ng isang simpleng kundisyon dito:
Kung hindi EmptyString(Object.QueryText) Pagkatapos Constructor.Text = Object.QueryText; tapusin kung;
Iyon lang, ikinonekta namin ang Query Constructor na binuo sa 1c8 platform, tingnan natin ang aming trabaho. Upang gawin ito, ilunsad ang 1C:Enterprise sa makapal na client mode gamit ang isa sa mga sumusunod na pamamaraan: 1) pangunahing menu ng Configurator - Pag-debug - Simulan ang Pag-debug - Makapal na Client; 2) o kung mayroon kang mga key na ito sa control panel sa configurator - pindutin lamang ang pindutan na may isang dilaw na bilog na may makapal na tuldok, tingnan ang figure:
Magsisimula ang user mode ng 1cEnterprise8, nakita namin ang aming pagpoproseso, ilunsad ito, i-click ang aming "Query Designer" na button at tingnan kung paano nagbubukas ang designer na binuo sa platform. tingnan ang fig.
Kaya, mayroon kaming Query Constructor na tumatakbo, maaari naming simulan ang pagsasama-sama ng aming hinaharap na query dito, ngunit interesado kaming makita kung paano gagana ang query na aming nilikha! At para magawa ito, kailangan naming gumawa ng isa pang button sa configurator kapag nag-e-edit ng form ng aming console, tawagin natin itong “Run Query”. Sa mga katangian ng pindutan ng "Run Query", mag-click sa "Action", lilitaw muli ang isang menu kung saan tatanungin kami kung saan ipoproseso ang aming code ng programa, sa kasong ito pipiliin namin ang "Parehong sa kliyente at sa server", muli nating makikita ang ating sarili sa Forms Module.
Sa Execute Query() procedure, na mayroon kami sa client, magsusulat kami ng kundisyon kung hindi pa naipasok ng user ang query text, ngunit hihilingin niyang isagawa ito:
If EmptyString(Object.QueryText) Then report("Enter the query text!"); tapusin kung;
Ang system ay awtomatikong nakabuo ng isang link sa Execute RequestOnServer() procedure; - mabuti iyon, pumunta tayo sa pamamaraang ito, na isinasagawa sa server, at isulat dito ang code para sa pagpapatupad ng aming ipinasok na kahilingan.
Mayroong mga opsyon dito: Maaari mong isulat ang lahat ng mga expression na nauugnay sa pagbuo ng mga query sa iyong sarili, i.e. manu-mano, ngunit mayroong isang mas simpleng pagpipilian - sa loob ng pamamaraan, i-right-click at sa drop-down na menu piliin ang "Tagabuo ng query na may pagproseso ng mga resulta, tingnan ang figure":
Kung nag-click ka sa item na "Tagabuo ng query na may pagpoproseso ng resulta," lilitaw ang isang modal window na "Hindi nahanap ang teksto ng query. Lumikha ng bago?", i-click ang oo. Magbubukas ang built-in na taga-disenyo ng query, kung saan sa unang tab nito "Pagproseso ng resulta" - piliin ang unang item " Pag-bypass sa resulta." Iyon lang, hindi namin kailangan ng anumang bagay mula sa tagabuo na ito, mag-click sa pindutang "Ok" - lilitaw ang isang modal window "Walang napiling mga patlang sa kahilingan, i-click ang "Ok".
Pagkatapos nito, lalabas ang sumusunod na yari na template sa loob ng aming ExecuteRequestOnServer() procedure:
Lumipat tayo sa expression na binuo ng constructor:
Request.Text = "";
Request.Text = Object.RequestText;
Ganyan kasimple, ang aming "Ipatupad ang Kahilingan" na buton sa form sa pagpoproseso ay praktikal nang gumagana, sa ngayon ay maaari lamang itong magproseso ng mga simpleng kahilingan nang walang mga parameter, ngunit ang pangunahing bagay ay gumagana ito! Ang natitira na lang ay biswal na ipakita ang mga resulta ng aming kahilingan sa attribute na “Value Table” sa processing form. Ipaalala ko sa iyo na ang aming attribute na "Value Table" ay nasa "Tabular Document" na uri, dahil kung hindi, hindi namin makikita ang aming mga resulta sa user mode. Ang pagpapakita ng tabular data sa user ay palaging ginagawa alinman sa pamamagitan ng Tabular Document o Layout. Gusto ko talagang maging posible na magpakita ng data sa pamamagitan ng isang talahanayan ng mga halaga - dahil napakadaling gamitin at pamilyar, ngunit , sa kasamaang palad, ang isang talahanayan ng mga halaga ay isang tool lamang na kailangan ng isang developer, hindi ka maaaring magpakita ng data sa screen gamit ito...
Tingnan natin kung ano ang isang Spreadsheet Document - ito ay tulad ng isang Excel sheet - maaari kang makakuha ng isang talaan sa isang partikular na cell gamit lamang ang mga Table Cell, dito tinatawag namin silang isang lugar, ngunit kami mismo ay maaaring pumili ng saklaw ng lugar na ito. sa isang partikular na Cell:
Kaya, nalaman namin kung ano ang isang dokumento ng spreadsheet at natukoy para sa aming sarili na kakailanganin naming tukuyin ang data mula sa aming query sa isang partikular na cell ng dokumentong ito ng spreadsheet. Ngunit isipin natin: ano ang "Resulta ng Query" na mabilis na nabuo ng taga-disenyo para sa atin? Buksan ang tulong - Ang resulta ng query ay isang talahanayan na may naaangkop na mga katangian! tingnan ang fig.
At kung isusulat natin ngayon pagkatapos ng expression na Query Result = Query.Execute(); (nilikha ng constructor), narito ang isang simpleng cycle para sa Mga Koleksyon:
Para sa bawat ColumnName Mula sa Query Result.Columns Loop report(ColumnName.Name); EndCycle;
Pagkatapos ng cycle na ito, tandaan sa ngayon ang lahat ng mga expression na awtomatikong binuo ng constructor. At patakbuhin ang 1C:Enterprise8 sa ilalim ng makapal na kliyente. Lumikha ng anumang simpleng query (Maaari mong gamitin ang Query Builder - gumagana na ito para sa amin) at mag-click sa button na “Run Query”:
Makikita mo sa ibaba ng window ng mensahe na iniimbak ng talahanayan ng Resulta ng Query ang mga pangalan ng mga field na kakapili lang namin sa pamamagitan ng paglikha ng isang simpleng query.
Ngayon ipakita natin ang mga pangalang ito ng mga field ng ating paghihirap sa isang dokumento ng Spreadsheet:
Para sa bawat ColumnName Mula sa Query Result.Columns Loop Cell=Object.QueryTable.Area(1,QueryResult.Columns.Index(ColumnName)+1); Cell.Text=ColumnName.Name; EndCycle;
Upang ipakita ang mga detalye ng data ng query, i-parse natin ang mga expression na awtomatikong nilikha ng taga-disenyo at ipasok sa "SelectionDetailedRecords" na pag-uuri loop ng query mismo ang eksaktong parehong loop na ginamit namin upang ipakita ang mga pangalan ng column, ngayon lang kailangan naming ilipat hindi ang data mula sa talahanayan ng "Resulta ng Query" sa teksto ng Cell. at ang data ng mismong Pinili, tingnan natin sa tulong kung paano mo maa-access ang field ng Detalyadong Pagpili ng kahilingan:
SelectionDetailRecords = QueryResult.Select(); Habang SelectionDetailedRecords.Next() Loop //sa unang linya ay mayroon na kaming mga pangalan ng mga column ng talahanayan na nakasulat, kaya nilo-load namin ang data sa ibaba ng unang linyaDocRowNumber=Object.QueryTable.TableHeight+1; Para sa bawat ColumnName Mula sa Query Result.Columns Cycle Cell=Object.QueryTable.Area(DocRowNumber,QueryResult.Columns.Index(ColumnName)+1); Cell.Text = SelectionDetailedRecords[ColumnName.Name]; EndCycle; EndCycle;
Iyon lang, maaari naming suriin, i-load ang enterprise sa ilalim ng isang makapal na kliyente, magpasok ng isang simpleng kahilingan nang walang mga parameter, mag-click sa pindutan ng "Run Query", tingnan ang figure:
Hurray, gumagana ang lahat!!!
Napakaginhawa kapag, kapag binubuksan/sinasara ang aming Query Console, ang aming query text, na pinagtulungan namin bago isara ang console, ay muling nakasulat sa field na “Query Text.” Upang gawin ito, kailangan mo lamang paganahin ang form property = Autosave, tingnan ang fig:
Iyon lang, gumagana ang aming console. Upang makapagsulat kami ng mas kumplikadong mga query na may mga parameter na tinukoy sa mga ito, kailangan naming lumikha ng isa pang pindutan ng "Hanapin ang Mga Parameter", pati na rin ang code para sa pindutan ng "Run Query" - ang code para sa pindutan ng "Hanapin ang Mga Parameter" ay isasagawa sa kliyente at sa server. Susunod, sa pamamaraan ng server, inilulunsad namin ang kahilingan sa parehong paraan kasama ang text na ipinasa dito mula sa window ng "Request Text", gamit ang expression na "Request.FindParameters()" hinahanap namin ang mga naipasa na parameter at ipasok lamang ang mga ito sa isang loop sa tabular na bahagi ng form na "Mga Parameter ng Kahilingan". Huwag kalimutang ilipat ang mga ito mula sa nakumpletong talahanayan ng mga parameter patungo sa pamamaraang "Run Query".
Maaari ka ring magdagdag ng ilang button sa aming Console na maglilinis sa window ng Mga Parameter at sa window ng Request Text sa user mode.
Handa nang gamitin ang aming Query Console, nais kong matagumpay kang malikhaing mga solusyon gamit ang isang simple at mahusay na tool gaya ng Query Console!
Ang pagproseso na ito ay nakasulat sa 1c8.3 platform (mga pinamamahalaang form) at tumatakbo sa ilalim ng isang makapal na kliyente. Maaari rin itong isulat sa 1c8.2 platform, parehong sa ilalim ng mga regular na form at sa ilalim ng mga pinamamahalaan.
Naglalaman ang pag-download ng sample ng Query Console na kakagawa lang namin.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Pag-upgrade ng Query Console:
1) Ngayon ang aming homemade Query Console na may built-in na Query Builder ay tatakbo sa ilalim ng anumang kliyente: sa ilalim ng makapal na kliyente ng regular at pinamamahalaang mga form at sa ilalim ng isang manipis at web client.
p.s. Ang anyo at hitsura ng built-in na Query Builder ay iba - depende sa kung aling kliyente namin inilunsad ang aming Console. (Ako mismo ay mas pamilyar at kumportable sa anyo ng Query Builder sa ilalim ng isang makapal na kliyente)
&On the Client Procedure Query Constructor (Command) //ang pagtawag sa karaniwang Query Constructor ay posible lamang sa ilalim ng makapal na client #If ThickClientManagedApplication o ThickClientNormalApplication Then Constructor=New Query Constructor; Kung hindi EmptyString(Object.QueryText) Pagkatapos Constructor.Text = Object.QueryText; tapusin kung; Kung Constructor.OpenModal()=True Then Object.RequestText=Constructor.Text; tapusin kung; // #Else // Report("Ang pagtawag sa Query Builder ay posible lamang sa ilalim ng makapal na kliyente"); // Bumalik; //# EndIf #Else Report("Ikaw ay nagpapatakbo ng Query Builder sa ilalim ng isang thin client - ito ay bahagyang naiiba sa anyo nito at bilis ng pagganap!"); Constructor = Bagong QueryConstructor(); Kung hindi EmptyString(Object.QueryText) Pagkatapos Constructor.Text = Object.QueryText; tapusin kung; Constructor Alert = New AlertDescription("RunAfterClosingConstructor", ThisForm); Constructor.Show(Constructor Alert); # EndIf End of Procedure &On the Client Procedure ExecuteAfterClosingConstructor(Result, ConstructorParameters) Export //Result=text, kung ang Constructor ay isinara gamit ang ok button na Object.RequestText = AbbreviatedLP(Result); //gumana!!! EndProcedure
2) Nagdagdag ng kakayahan sa aming simpleng Query Console na magpasok ng mga kumplikadong query na may Temporary table na ipinasa sa mga parameter!!! Ang mekanismo ay naging napaka-simple at eleganteng - nang hindi gumagamit ng XML code, tulad ng ginagawa sa mga propesyonal na console.
Maaari mong makita ang code mismo at ang mga pamamaraan para sa mekanismo ng paglipat sa mga parameter ng Pansamantalang mga talahanayan sa pangalawang naka-attach na file. Kung paano ko sinimulan ang pagbuo ng sarili kong bersyon ng Temporary table sa mga parameter ay makikita sa link na ito https://forum.infostart.ru/forum9/topic183700/
Ngayon kung paano gamitin ang Console para sa isang kumplikadong query kapag ang isang pansamantalang talahanayan ay ipinasa sa mga parameter nito. Halimbawa, maaari mong kunin ang code ng kahilingang ito;
PUMILI ExternalData.Product, ExternalData.Quantity LUGAR ExternalData MULA SA &ExternalData BILANG ExternalData; ////////////////////////////////////////////// /////////////////////////// PUMILI ExternalData.Product, ExternalData.Quantity, ISNULL(RemainingProductRemaining.QuantityRemaining, 0) AS Field1, ISNULL(Remaining ProductsRemainings.QuantityRemaining, 0) - ExternalData.Quantity AS Remainings FROM ExternalData AS ExternalData LEFT JOIN Register Accumulations.Remaining Products.Remainings(&Petsa, Product IN (SELECT ExternalData.Product FROM ExternalData AS ExternalData)) AS Natitirang ProductsDataRemainingsProduct . Produkto
Batay sa halimbawa at pagkakatulad ng query code sa itaas, maaari kang lumikha ng iyong sariling kumplikadong query, na isinasaalang-alang ang iyong mga object ng data.
Kaya, sa taga-disenyo ng query nilikha namin ang query sa itaas, isinasara ang Constructor - ang teksto ng query ay mapupunta sa aming console field na "Query Text", mag-click sa pindutan ng "Hanapin ang Mga Parameter", nakita namin na sa talahanayan ng Mga Parameter ay may lumitaw na linya = "Panlabas na Data", Uri ng halaga = "Talahanayan ng Halaga", tingnan ang fig.
Sa talahanayang ito ng Mga Parameter - ilagay ang parameter na Petsa, halimbawa, petsa ngayon, pagkatapos ay i-click upang subukang i-edit ang aming pansamantalang parameter ng talahanayan na "External Data", mag-click sa field na may "Talahanayan ng Halaga" sa tatlong tuldok - isang seleksyon ng mga uri ang lilitaw, i-click ang Row, ibinabalik sa amin ng aming mekanismo ang pahina sa form, kung saan kailangan naming manu-manong ipasok ang napaka-pansamantalang talahanayang ito.
Tandaan dito na sa kasong ito, sa page na “TimeTables” sa ibaba sa field na “Pansamantalang pangalan ng talahanayan sa mga parameter,” lalabas ang pangalan ng aming pansamantalang talahanayan (ito ay kinopya mula sa talahanayan ng Mga Parameter).
Sa ngayon, sa page na "Mga Talahanayan ng Oras" ay nakikita lamang namin ang isang walang laman na talahanayan - ito ang talahanayan ng Mga Uri ng aming pansamantalang talahanayan sa hinaharap. Gamit ang pindutang "Idagdag", idaragdag namin ang pangalan ng mga detalye at uri ng talahanayan sa hinaharap. . Mag-ingat - dapat tumugma ang pangalan at uri sa tinukoy namin sa kahilingan para sa &ExternalData:
Ngayon ay pinindot namin ang pindutang "I-update ang Pansamantalang Talahanayan" - at magkakaroon kami ng pangalawang talahanayan dito - direkta naming pupunuin ito ng pansamantalang data ng talahanayan sa pamamagitan ng pindutang "Magdagdag".
Iyon lang, maaari nating suriin muli ang ating sarili kung naipasok natin ang primitive na data ng mga parameter ng query sa talahanayan ng parameter sa unang pahina ng pagproseso, at i-click ang pindutang "Patakbuhin ang Query" - lahat ay kinakalkula at napili nang naaayon sa limitasyon ng data na ipinasa sa parameter ng aming pansamantalang talahanayan
p.s. Kung nagkamali ka sa pag-type ng pangalan ng mga detalye at mga uri ng mga ito (sa unang talahanayan) - isara lang ang Console at buksan itong muli - ang pansamantalang talahanayan ng data ay mabubura - at ang talahanayan ng Mga Uri ay maaaring muling i-edit at isang bagong talahanayan ng data ay maaaring gawin muli.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Iyon lang, maaari kaming lumikha ng isang napakalakas na tool sa pagtatrabaho gamit ang aming sariling mga kamay, bilang karagdagan, ang aming console ay napakabilis pa rin kumpara sa mga propesyonal - at ito ay isang napakalaking plus para sa mga developer! At, siyempre, ngayon ang aming console ay gumagana sa ilalim ng anumang kliyente! Good luck sa iyong creative developments!!!
Tingnan natin kung paano natin maisasama ang dalawang talahanayang ito ayon sa field Code ng produkto gamit
query constructor (ang code para sa paglikha ng mga pansamantalang talahanayan ay ibinigay bilang isang halimbawa
hindi ko gagawin. Maaari mong kunin ito mula sa link sa itaas).
Buksan ang window ng taga-disenyo, pumunta sa tab "Mga talahanayan at mga patlang", sa seksyon
"Mga mesa" piliin ang pareho ng aming mga talahanayan, at sa seksyon "Mga Patlang" -
yaong mga patlang mula sa parehong mga talahanayan na gusto naming makita bilang isang resulta ng query.
Pumunta sa bookmark "Mga Koneksyon". Magdagdag ng bagong linya. Sa field Talahanayan 1
mula sa drop-down na listahan piliin ang talahanayan na may mga produkto, at sa field Talahanayan 2 mesa
kasama ang mga bansa.
Para sa Mga Talahanayan1 lagyan ng tsek ang kahon Lahat. Para sa
Mga talahanayan2 Hindi namin nilagyan ng check ang kahon na ito. Nangangahulugan ito na mula sa Mga Talahanayan1
lahat ng mga tala ay pipiliin, at mula sa Mga talahanayan2 tanging ang mga kung saan ito ay ginanap
kondisyon ng koneksyon, iyon ay, na may ganitong kumbinasyon ng mga flag na nakukuha namin
LEFT CONNECTION. Susunod na kailangan mong punan Kondisyon ng komunikasyon.
Dito pipiliin namin ang mga field ng talahanayan mula sa mga drop-down na listahan at ang paghahambing na sign din mula sa drop-down
listahan. 
Bilang resulta ng koneksyon na ito, nakukuha namin ang sumusunod na text ng kahilingan:
PUMILI VT_Product.Product Code, VT_Product.Name, VT_Country.Country FROM VT_Product AS VT_Product LEFT JOIN VT_Country AS VT_Country BY VT_Product.Product Code = VT_Country.Product Code
Ngayon tingnan natin ang ilang mga punto.
Subukan nating palitan ang checkbox Lahat.
Ito ay tila na sa huli ay dapat itong gumana RIGHT JOIN, ngunit kung tayo
Tingnan natin ang teksto ng query na nabuo ng tagabuo, makikita natin na ang mga talahanayan
nagpalit ng mga lugar, ngunit nanatili pa rin ang koneksyon:
PUMILI VT_Product.Product Code, VT_Product.Name, VT_Country.Country FROM VT_Country AS VT_Country LEFT JOIN VT_Product AS VT_Product BY VT_Product.Product Code = VT_Country.Product Code
Tingnan natin kung ano ang mangyayari kung alisan ng tsek ang parehong mga kahon 
Bilang resulta, nakakakuha kami ng panloob na koneksyon.
PUMILI 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 Code
Panghuli, kung ang parehong mga checkbox ay naka-check 
nakakakuha kami ng buong koneksyon
PUMILI 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 Code
Maaari kang tumukoy ng maraming linya sa isang bookmark Mga koneksyon. Sa kasong ito, ilan
ang mga hilera ay konektado sa pamamagitan ng kundisyon AT. Bukod dito, ang mga linya ay hindi kinakailangan
magmaneho muli sa bawat oras. Maaari silang kopyahin gamit ang susi F9.
At sa bagong linya, baguhin lamang ang kundisyon ng koneksyon. Ito ay makabuluhang nagpapabilis sa pag-unlad.
Gayundin, sa kondisyon ng link, hindi kinakailangan na gamitin lamang ang mga paunang natukoy na mga patlang mula sa
mga drop-down na listahan. Maaari kang gumamit ng isang di-makatwirang expression na nagbibigay-kasiyahan
1C query language. Upang gawin ito, kailangan mong suriin ang kahon libre
at direktang ilagay ang kundisyon sa field, o magbukas ng pantulong na window sa
kung saan maaari kang gumamit ng mga template na may mga function ng query language. 
Siyempre, sa pagsasanay mayroong mas kumplikadong mga query kung saan
ilang mga talahanayan na may iba't ibang koneksyon sa pagitan ng bawat isa. Ngunit sa tagabuo ng query
ang mga koneksyon ng anumang kumplikado ay maaaring kopyahin.
Ang taga-disenyo ng query ay binubuo ng mga sumusunod na tab:
1. "Mga talahanayan at mga patlang" - mayroong tatlong hierarchical na listahan sa tab:
a. "Database" - naglilista ng lahat ng magagamit na mga bagay kung saan maaaring gawin ang isang query. Gayundin pindutan "Ipakita ang mga talahanayan ng pagbabago", kung saan maaari mong i-access ang mga talahanayan ng mga pagbabago sa mga bagay na panseguridad ng impormasyon kung nakarehistro ang mga ito para sa anumang exchange plan.
b. "Mga Talahanayan" - isang listahan ng mga napiling talahanayan kung saan isasagawa ang query. Gayundin sa window na ito maaari mong tanggalin ang isang talahanayan, palitan ang pangalan o palitan ang isang talahanayan, at magdagdag ng isang panloob na query.
Maaari kang magtalaga ng mga parameter para sa mga virtual na talahanayan sa pamamagitan ng pag-click sa button na "Mga Parameter ng Virtual Table":
Inirerekomenda na aktibong gamitin ang mga parameter ng mga virtual na talahanayan para sa pagpili ng ilang partikular na dimensyon, dahil pinapataas nito ang bilis ng pagsasagawa ng query. Maaari kang gumamit ng mga panlabas na variable sa mga parameter, na ang mga pangalan ay pinangungunahan ng "&" sign.
c. "Mga Patlang" - isang listahan ng mga patlang na pinili mula sa mga talahanayan. Maaari ka ring magdagdag ng mga kalkuladong patlang; upang gawin ito, ang pag-click sa pindutang "Magdagdag" ay magbubukas ng custom na expression constructor:
Sa kaliwa ay isang window na may mga field na available sa expression. Sa kanan ay isang pahiwatig ng mga function na ginamit. Nasa ibaba ang isang constructable arbitrary expression. Maaari kang gumamit ng mga panlabas na parameter sa mga expression; ang mga ito ay tinutukoy ng "&" sign, halimbawa: &Period, &StartDate
Kailangan mong mag-ingat, kung ang isang mahaba at kumplikadong expression ay nai-type sa window, na naglalaman ng isang maliit na error sa syntax, pagkatapos ay pagkatapos ng pag-click sa pindutan ng "OK", ang system ay magbibigay ng babala at isara ang window. Mawawala ang lahat ng nai-type na code, kaya inirerekumenda ko na kung hindi ka sigurado sa tama ng expression, palaging i-save ang mga nilalaman sa clipboard (Ctrl-C) bago isara ang constructor.
2. "Mga Relasyon" - sa tab, ang mga koneksyon sa pagitan ng mga talahanayan ay ipinahiwatig.
Ang talahanayan ay nagpapahiwatig ng mga talahanayan na mai-link, ang relasyon sa pagitan ng mga talahanayan na ili-link at ang kundisyon ng koneksyon. Kung kumplikado ang kundisyon ng koneksyon, maaari mong tukuyin ang isang tiyak na kinakalkula na expression, at magbubukas ang custom na field constructor.
3. "Pagpapangkat" - ang tab ay nagpapahiwatig kung aling mga field ang pinagsama-sama at kung alin ang pinagsama-sama (summed up).
4. Tab na "Mga Kundisyon" - naglilista ng mga kundisyon na ipinataw sa kahilingan.
Sa mga kundisyon, maaari ka ring magsulat ng mga kumplikadong expression gamit ang simpleng expression constructor at gamit ang mga panlabas na variable:
5. "Advanced"
Mga karagdagang parameter na ipinataw sa kahilingan
6. "Mga asosasyon at pseudonym"
Sa tab na ito maaari kang magtalaga ng mga alias para sa mga field, gayundin ang pamahalaan ang mga query na konektado sa pamamagitan ng mga construct na “UNITE” o “UNITE ALL”.
7. "Order"
Sa anong pagkakasunud-sunod ipapakita ang mga resulta ng query?
Pansin! Sa ibaba ng bookmark makakakita ka ng checkmark "Auto-order"- sa kasalukuyang bersyon ng 1C 8.1 sa ACS, ito ay walang silbi; bukod dito, kapag ang checkbox ay nasuri, kapag nagre-record, ang ACS ay nagbibigay ng isang error, kaya hindi mo dapat gamitin ito.
8. "Komposisyon ng Data"
Ang tab kung saan tinukoy ang mga field ng serbisyo para sa access control system. Ito ay gumaganap ng humigit-kumulang kaparehong tungkulin gaya ng tab na "Tagabuo ng Ulat" sa isang regular na taga-disenyo ng ulat.
A. Sa tab na "Mga Talahanayan" - nakalista ang mga talahanayan na ginamit sa query; maaari mong ipahiwatig kung dapat isama ang talahanayan sa query sa pamamagitan ng paglalagay ng check sa checkbox na "Kinakailangan". Yung. kung walang mga field na kasama sa pagpili, ang talahanayang ito ay hindi nakikilahok sa query. Maaari mo ring tukuyin ang mga parameter para sa mga talahanayan.
Sa proseso ng pag-set up ng access control system, tinukoy namin ang anumang mga pagpipilian, pagkatapos ang lahat ng mga halaga ng pagpili ay papalitan sa mga parameter ng mga virtual na talahanayan, na muli ay makakatulong sa amin na i-optimize at pabilisin ang query.
b. Sa tab na "Mga Patlang," nakalista ang mga field at ang kanilang mga alias na idaragdag sa listahan ng mga field ng ACS.
c. "Mga Kundisyon" - kung ang mga pagpipilian ay tinukoy sa mga setting ng ACS, ang lahat ng mga halaga ng pagpili ay idaragdag bilang mga karagdagang kundisyon; ang mga kumplikadong expression ay maaari ding idagdag sa mga kundisyon.
9. "Mga Katangian"
Isang bookmark na walang analogue sa karaniwang output form constructor.
Binibigyang-daan ka ng tab na ito na palawakin ang gawain ng mga query na may mga katangian. Ang talahanayan sa tab ay binubuo ng ilang mga field:
a. "Uri ng halaga" - ang uri kung saan pipiliin ang mga katangian. Halimbawa, kung tinukoy mo ang "Directory Link.Nomenclature", ang lahat ng katangian para sa nomenclature ay pipiliin sa query.
b. "Pinagmulan" - ang pinagmulan para sa mga katangian ng mga uri ng katangian, ay maaaring isang query o isang talahanayan. Sa field na ito maaari kaming sumulat ng isang kahilingan upang piliin lamang ang mga katangian na kailangan namin.
c. "Listahan ng mga katangian" - isang patlang kung saan ipinahiwatig ang pinagmulan para sa mga katangian ng mga katangian. Kadalasan ito ay isang plano ng mga uri ng katangian o isang kahilingan. Kailangan mo ring tukuyin ang mga field na responsable para sa "Identifier", "Pangalan" at "Uri" ng property.
d. Ang "Source" ay ang susunod na field kung saan ipinapahiwatig namin ang pinagmulan ng mga katangiang value, na maaari ding maging table o query.
e. Ang "characteristic value" ay isang talahanayan o query na tumatanggap ng mga katangiang value. Halimbawa, ang rehistro ng impormasyon na "ObjectPropertyValues" ay maaaring magsilbi bilang isang talahanayan ng mga halaga ng katangian. Dapat din nating ipahiwatig ang mga field na iyon mula sa talahanayan (o query) na responsable para sa "Object", "Property" at "Value" ng katangian.
Pagkatapos i-edit ang kahilingan, makikita ang text ng kahilingan sa window sa ilalim ng listahan ng mga field. Sa ibaba, gamit ang checkbox na "Autofill," maaari naming i-regulate ang pagkumpleto ng mga karagdagang parameter para sa mga field na tinukoy sa kahilingan. Pakitandaan na ang komposisyon ng mga field ay tinutukoy lamang sa mismong kahilingan.
Ang impormasyon na kinuha mula sa site
Ngayon ay pag-uusapan natin kung paano gawin mga nested na query gamit tagabuo ng query. Dumiretso tayo sa isang halimbawa.
Sabihin nating mayroon kaming ganitong simpleng rehistro ng impormasyon, kung saan ang mga presyo ay iniimbak ng mga kalakal at mga supplier:
Gusto naming humiling na matanggap ang lahat ng produkto na mayroong higit sa isang supplier. Ito ay maaaring ipatupad gamit ang sumusunod na query:
PUMILI NG Bilang ng mga Supplier.Produkto BILANG Produkto MULA (PUMILI NG Presyo.Produkto BILANG Produkto, DAMI(IBA'T IBANG Presyo.Supplier) BILANG Mga Supplier MULA sa RegisterInformation.Presyo BILANG Presyo GROUP AYON SA Presyo.Produkto) BILANG Bilang ng mga Supplier KUNG SAAN Bilang ng Mga Supplier.Mga Supplier > 1
Bumubuo ng nested query sa constructor
Gawin natin ang kahilingan sa itaas gamit ang constructor.
Upang gawin ito, sa command panel sa itaas ng field Mga mesa pindutin ang pindutan Gumawa ng subquery:
Pagkatapos nito ay magbubukas ang isang window na may isa pang instance ng query constructor: 
At sa bagong window na ito, bumuo kami ng nested query: 
Ang pag-click sa pindutan Hiling Sa ibabang kaliwang sulok makikita natin ang teksto ng subquery: 
Matapos i-click ang OK na buton sa auxiliary constructor, makuha namin ang sumusunod na larawan sa pangunahing window: 
Mula sa parirala NestedQuery hindi masyadong maginhawa para sa pang-unawa, gamitin natin ang kanang pindutan ng mouse upang palitan ang pangalan ng talahanayan Bilang ng mga Supplier, pumili ng field mula dito produkto at sa bookmark Mga kundisyon Isulat natin ang kinakailangang kondisyon: 
At pagkatapos ng lahat ng mga manipulasyong ito, natatanggap namin ang ninanais na kahilingan. Kung kinakailangan, maaari kang lumikha ng mga query na may ilang antas ng nesting.
Paano gumawa ng nested query mula sa isang regular na query sa constructor
Kadalasan ang isang sitwasyon ay lumitaw kapag nagsimula kang gumawa ng isang kahilingan sa tagabuo at sa isang punto ay napagtanto mo na dapat itong naka-nest. Siyempre, sa aming halimbawa ay walang problema - maaari mo lamang tanggalin ang lahat at muling ibigay ang kahilingan. Ngunit sa pagsasagawa, mayroong mas kumplikadong mga halimbawa, halimbawa, na may ilang mga antas ng nesting, kapag ilang oras ang ginugol sa paggawa ng kahilingan. At sa kasong ito mayroong isang medyo simpleng paraan. Maaari mong gamitin ang query text editor na nakapaloob sa taga-disenyo. Kailangang gumamit ng isang pindutan Hiling kunin ang text ng kahilingan (tingnan ang larawan sa itaas) at kopyahin ito sa clipboard. Susunod, gumawa ng bagong nested query at pindutin muli ang button Hiling, i-paste ang teksto mula sa buffer, i-click ang OK. Alinsunod dito, nililinis namin ang lumang kahilingan sa pinakamataas na antas. Sa ganitong paraan, kung kinakailangan, madali kaming makakagawa ng mga multi-level na nested na query sa mabilisang.
Ang kakayahang magsulat ng teksto ng query na "manu-mano" ay hindi kailanman naging "labis", ngunit mas maginhawang gumamit ng isang taga-disenyo ng query.
Magkomento.
Sa kasamaang palad, sa isang pinamamahalaang application, hindi mo magagamit ang taga-disenyo ng query sa pagpoproseso ng "Makilala Gamit ang Query." Magagamit mo ito sa pagproseso na ito sa pamamagitan ng paglipat sa normal na mode, ngunit hindi namin ito gagawin.
Gawin natin ang pagproseso ng "Request Constructor" at tukuyin ito sa subsystem na "Mga Ulat at Pagproseso".
Gumawa tayo ng form sa pagpoproseso at idagdag dito ang katangian ng form na "TabDoc" ng uri ng "Tabular Document", pati na rin ang command na "Run Query" na may aksyon na "Run Query." Susunod, i-drag ang mga ito sa form.
Sa form na module, para gumana ang utos, sumulat kami ng isang pamamaraan:
&OnClient
Pamamaraan Ipatupad ang Query (Utos)
ExecuteRequestServer();
EndProcedure
&Sa server
EndProcedure
Nasa loob tayo ng procedure na tinatawag sa server at tinatawagan ang “Query constructor with result processing” mula sa context menu (Figure 2.65).
Figure 2.65 Query constructor na may pagpoproseso ng resulta
Itakda ang uri ng pagproseso sa "Output sa isang spreadsheet na dokumento" at i-click ang alinman sa "Next" na button o ang tab na "Tables and Fields".
Sa tab na "Mga Talahanayan at Mga Patlang" ng taga-disenyo, maaari mong tingnan ang kasalukuyang umiiral na mga talahanayan sa system (ang kaliwang bahagi ay pinamagatang "Database") (Figure 2.66).
Larawan 2.67 Tagabuo ng query
Ang mga talahanayan kung saan kukuha ng data ang query ay inililipat sa lugar na "Mga Talahanayan"; ang mga patlang na kinakailangan ng query ay inililipat sa lugar na "Mga Patlang". Gawin natin ito tulad ng sa Figure 2.68.
Fig 2.68 Tagabuo ng query
Dito ay inalis namin ang ginawang default na field ng view - “PRESENTATION (Product ReceiptProducts.Nomenclature)”
Sa anumang oras habang nagtatrabaho kasama ang taga-disenyo, maaari mong tingnan ang nagreresultang teksto ng kahilingan. Upang maisagawa ang gawaing ito, dapat mong i-click ang pindutang "Humiling" na matatagpuan sa ibabang kaliwang sulok ng form ng taga-disenyo (Larawan 2.69).
Maaari mong manu-manong i-edit ang teksto ng kahilingan sa pamamagitan ng pag-click sa pindutang "I-edit".
Magsanay. I-click ang button na “OK” at suriin ang aming pagproseso sa user mode. Kung susuriin mo ang data na natanggap kapag isinasagawa ang kahilingan, maaari mong mahanap ang "pag-uulit" ng mga item ng item (kung hindi ito gumana para sa iyo, maaari mong kopyahin at i-post ang anumang dokumentong "Resibo ng Mga Kalakal").
Bumalik kami sa pamamaraan ng ExecuteRequestServer() sa pagproseso ng "Request Constructor" at mula sa menu ng konteksto ay muling tumawag sa "Query Constructor na may pagpoproseso ng resulta".
Kung gusto mong "i-collapse" ang resulta ng isang query, para sa layuning ito maaari mong gamitin ang tab na "Pagpapangkat" ng taga-disenyo ng query.
Kapag tinutukoy ang mga pagpapangkat, dapat kang sumunod sa sumusunod na panuntunan: ang lahat ng mga field ng pagpili ng query ay nahahati sa mga field kung saan isinasagawa ang pagpapangkat (convolution), mga field ng mga nested table (mga field na pinagsama-samang nauugnay sa kung saan isinasagawa ang pagpapangkat) at pinagsama-samang mga function. Tukuyin natin ang mga pagpapangkat (Figure 2.70).
Larawan 2.70 Tagabuo ng Query
Kung ang data na natanggap ng kahilingan ay dapat mapili ayon sa ilang kundisyon, kung gayon sa kasong ito ay maaaring kailanganing gamitin ang tab na "Mga Kundisyon". Piliin natin ang Goods ReceiptGoods.Quantity=10 (Figure 2.71).
Figure 2.71 Kondisyon ng constructor ng query.
Pakitandaan na kung ang kundisyon ay tinukoy sa parehong paraan tulad ng sa figure, ang kahilingan ay hindi isasagawa.
Mayroong dalawang paraan upang itama ang sitwasyon:
Sa pamamagitan ng muling pagtukoy sa kundisyon sa pamamagitan ng pagsuri sa bandila ng “P...”;
Sa pamamagitan ng pagsasamantala sa pagkakataong baguhin ang mismong teksto ng kahilingan (nakuha sa pamamagitan ng pag-click sa pindutang "I-edit ang Kahilingan").
Ang manu-manong pagbabago mismo ay bubuo sa katotohanan na kinakailangang tanggalin ang simbolo na "&" bago ang numerong "10". Ang simbolo na ito sa teksto ng kahilingan ay tumutukoy sa mga parameter ng kahilingan, kung saan ang ilang mga halaga ay dapat isulat sa ibang pagkakataon (ngunit bago isagawa ang kahilingan). Mag-click sa pindutang "I-edit ang Query" at i-edit (Larawan 2.72).
Larawan 2.73 Pag-edit ng Query
Sa tab na "Advanced", maaari mong suriin ang ilang mga flag (na nauugnay sa keyword na "Piliin" ng wika ng query) at tukuyin ang komposisyon ng mga talahanayan na nilayon para sa pagbabago ng query (Figure 2.74).
Figure 2.74 Mga karagdagang function ng query
Sa tab na "Mga Pagsali/Alyas", maaari mong baguhin ang mga pangalan ng field sa pamamagitan ng pagtatakda ng "Mga Alyas", ngunit hindi namin ito gagawin.
Sa tab na "Order", matutukoy mo ang pagkakasunud-sunod ng pag-uuri ng mga tala bilang resulta ng query (Figure 2.75).
Larawan 2.75 Itala ang pagkakasunod-sunod ng pag-uuri
Bigyang-pansin ang flag na "Auto-order", maaari itong magamit upang mag-order ayon sa mga field ng isang uri ng sanggunian.
Kapag tinukoy ang seksyong "Mga Kabuuan", dapat kang maging handa para sa katotohanang lilitaw ang "karagdagang" kabuuang mga tala bilang resulta ng query. Kasama ng mga rekord na ito, ang resulta ng query ay nagiging hierarchical (Figure 2.76).
Figure 2.76. Resulta ng constructor ng query.
Posibleng tukuyin ang ilang uri ng kabuuan:
Mga Elemento (ang pagpili ng resulta ng query ay naglalaman ng mga kabuuan ng pagpapangkat at mga detalyadong tala);
Hierarchy (sa pagpili ng resulta ng query, sa pangkalahatang kaso, may mga buod na talaan ayon sa hierarchy, mga tala ng buod ayon sa pagpapangkat, at mga detalyadong tala);
Hierarchy lamang (sa pagpili ng resulta ng query, sa pangkalahatan, may mga buod na talaan ayon sa hierarchy).
Pagkatapos ng pag-click sa "Ok" na buton ng constructor, isang "Layout" ang bubuo at ang code para sa ExecuteRequestServer() procedure ay isusulat sa form module:
&Sa server
Pamamaraan ExecuteRequestServer()
//((QUERY_CONSTRUCTOR_WITH_RESULT_PROCESSING
// Ang fragment na ito ay binuo ng constructor.
// Kapag muling ginagamit ang constructor, mawawala ang mga pagbabagong ginawa nang manu-mano!!!
Layout = Processing.QueryConstructor.GetLayout("Layout");
Kahilingan = Bagong Kahilingan;
Request.Text =
| Pagtanggap ng Goods Goods. Nomenclature AS Nomenclature,
| SUM (Receipt of Goods Goods. Dami) BILANG Dami,
| SUM(Receipt of GoodsGoods.Amount) BILANG Halaga
| Dokumento.Receipt of Goods.Goods
| PAANO MAKATANGGAP NG MGA PRODUKTO
| Pagtanggap ng Goods Goods. Dami > 1
|GROUP BY
| Pagtanggap ng GoodsGoods.Nomenclature
|ORDER NI
| dami,
| PAGBABA ng Halaga
| SUM(Dami),
| SUM(Sum)
| HIERARCY ng Nomenclature";
Resulta = 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);
Habang SelectionNomenclature.Next() Loop
Kung SelectionNomenclature.RecordType() = RequestRecordType.TotalByHierarchy Then
Lugar = AreaNomenclatureHierarchy;
Rehiyon = RehiyonNomenclature;
tapusin kung;
Area.Parameters.Fill(SelectionNomenclature);
TabDoc.Output(Area, SelectionNomenclature.Level());
EndCycle;
TabDoc.FinishAutoGroupingRows();
TabDoc.Output(TableFooterArea);
TabDoc.Output(AreaFooter);
//))CONSTRUCTOR_QUERY_WITH_RESULT_PROCESSING
