Ang Query Console ay napaka-maginhawang gamitin kapag kailangan mong i-debug ang ilang kumplikado , o mabilis na kumuha ng seleksyon ng ilang partikular na data.

Makakahanap ka ng maraming iba't ibang mga console sa Internet. Para sa mga regular at pinamamahalaang form, ang mga ito ay karaniwang ganap na magkakaibang mga console. Ayon dito, maaari mong i-download ang universal query console 1C 8.3 at 8.2, na gagana sa parehong mga kaso. Tandaan lamang na naka-on ang console pinamamahalaang interface magbubukas ka lamang sa isang makapal na kliyente.

Paggawa gamit ang Query Console

Sa 1C program, bubukas ang query console sa parehong paraan tulad ng anumang panlabas na pagproseso: ang menu na "File" - "Buksan", o gamit ang kumbinasyon ng hot key na "Ctrl + O". Sa madalas na paggamit, maaari itong idagdag sa panlabas na pagproseso ng base ng impormasyon.

Ang listahan ng iyong mga kahilingan ay ipinakita sa kaliwang bahagi ng console ng kahilingan. Nagbibigay-daan ito sa iyo na mag-imbak hindi lamang ng isang kahilingan, ngunit ng ilan nang sabay-sabay. Ang query tree ay may hierarchical na istraktura, na napaka-maginhawa para sa pagpapangkat sa kanila.

Sa pamamagitan ng pag-click sa "Add" na buton, maaari kang magdagdag ng bagong kahilingan sa pamamagitan ng pagbibigay dito ng isang pangalan. Gayundin, binibigyang-daan ka ng built-in na functionality na lumikha ng mga query na may pagkopya, pataas o pababa sa listahan, at marami pang iba.

Ang teksto ng kahilingan mismo ay ipinapakita sa kanang bahagi ng form sa pagpoproseso. Maaari itong isulat nang manu-mano o gamit ang tagabuo ng query. Gumagana lamang ang tagabuo ng query sa makapal na kliyente.

Sa kanan ng constructor button ay ang "Insert Query Operators" na button. Agad itong magdaragdag ng walang laman na istraktura ng query na may kundisyon, pagpapangkat, pagkakasunud-sunod, at mga kabuuan.

Sa kanan ay napakakapaki-pakinabang na mga button na makakatulong kung gagamitin mo ang query na ito kapag gumagawa ng mga solusyon para sa 1C.

Binibigyang-daan ka ng button na i-convert ang query na isinulat mo sa text. Sa aming kaso, magiging katulad ng larawan sa ibaba.

Maaari kang mag-save ng mga kahilingan sa isang file o mag-load mula dito. Ito ay napaka-maginhawa para sa hinaharap na paggamit.

Bago direktang isagawa ang query, kailangan mong itakda ang mga parameter ng input nito (kung mayroon man), pagkatapos ay mag-click sa pindutang "Ipatupad ang query". Dito rin posible na magsagawa ng mga kahilingan hindi ganap, ngunit hiwalay ang anumang pakete.

Tinutukoy ng view mode kung paano ipapakita ang resulta ng query: isang listahan, isang hierarchical na listahan, o isang puno.

Ang resulta ng execution ay ipapakita sa pinakailalim ng request console. Ipinapakita rin nito ang bilang ng mga row na natanggap at ang oras ng pagpapatupad. Kung kinakailangan, maaari mong ilipat ang mga hilera ng resulta ng query.

Kadalasan, hinihiling sa mga user na pumili ng ilang data at i-save ito sa Excel. Maaaring kailanganin mo rin ito. Upang makumpleto ang gawain, kailangan mo lamang piliin ang item na "Display list" sa menu na "Higit pa". Ipo-prompt ka ng program na markahan ang mga kinakailangang column.

Bilang karagdagan sa pagtatakda ng listahan ng mga column para sa output, maaari mo ring tukuyin ang mga partikular na row dito. Ginagawa ito sa pamamagitan ng pag-highlight ng mga row sa query mismo. Dagdag pa, sa form ng pagpili ng hanay, sapat na upang itakda ang bandila sa setting na "Napili lamang".

Sa aming halimbawa, ipinakita namin ang lahat ng data ng resulta ng query. Maaari mong i-save ang mga ito sa isang panlabas na file sa pamamagitan ng pagkopya sa kanila mula sa binuksan na dokumento ng spreadsheet, o sa pamamagitan ng paggamit ng kumbinasyon ng Ctrl+O hotkey. Mayroong maraming mga pagpipilian para sa pag-save ng mga format, pinili namin ang "*. xlsx".

Tulad ng nakikita mo, ang pagtatrabaho sa query console ay napaka-maginhawa at kapaki-pakinabang, kaya't masidhi naming inirerekomenda ang pag-download nito at isagawa ito.

Query Console 1s- isang maginhawang tool para sa pagbuo at pag-debug ng mga query sa enterprise mode 1s. Gamit ang Query Console Maaari kang magsagawa ng kahilingan sa 1s database at makita ang resulta ng kahilingan nang direkta sa screen sa 1s enterprise. Sa artikulong ito, isasaalang-alang namin ang dalawang console, isa para sa 1s 8.2 (mga regular na form), at ang pangalawa ay maaaring gumana pareho sa normal at pinamamahalaang mga form 1s 8.3.

I-download ang query console 1s

Upang magsimulang magtrabaho sa pagproseso, kailangan mo munang i-download ang query console 1s, sa ibaba ay magbibigay kami ng mga link sa pag-download, ngunit sa ngayon tandaan natin ang katotohanan na ang 1s request console ay maaaring uriin at uriin sa isa sa mga sumusunod na uri:

1. Para sa mga regular na form (1s 8.2)
2. Para sa mga pinamamahalaang form (1s 8.3)
3. Mixed (parehong gumagana sa 1s 8.2 at 1s 8.3)

Sa aming artikulo, isasaalang-alang namin ang dalawang console, ang una ay gumagana lamang sa 1s 8.2 (mga regular na form), at ang pangalawa ay gumagana sa 1s 8.3 ( pinamamahalaang mga form). Ang mga ito ay bahagyang naiiba sa bawat isa, pag-uusapan natin ang mga pagkakaiba sa ibang pagkakataon, ngunit sa ngayon, tandaan namin na sa mga pinamamahalaang application, ang console ay gagana lamang nang maayos sa mode ng paglulunsad ng "Makapal na Kliyente".

I-download ang 1s request console para sa isang regular na application 1s 8.2

Nasa ibaba ang isang screenshot ng pagpoproseso, maaari mong i-download ang 1s request console para sa isang regular na 1s 8.2 na application

I-download ang 1s request console para sa pinamamahalaang application 1s 8.3

At ito ang pangalawang console, maaari mo ring makita ang screenshot nito sa screen sa ibaba, gamit ang link na maaari mong i-download ang 1s request console para sa pinamamahalaang application 1s 8.3

Paglalarawan ng mga prinsipyo ng pagpapatakbo at ang pangunahing pag-andar ng 1s request console para sa isang regular na 1s 8.2 application

Ito query console 1s 8.2 para sa isang regular na aplikasyon madaling gamitin at hindi nangangailangan ng anumang espesyal na kaalaman mula sa gumagamit. Sa screenshot maaari kang makakita ng field ng pagsubok para sa pagsusulat ng query, maaari kang magsulat ng query dito nang manu-mano at gamit ang constructor. Sa ilalim ng numero 1 sa figure makikita mo ang pindutan ng "Mga Parameter", sa pamamagitan ng pag-click dito makakakita kami ng isang form para sa pagpapalit ng mga parameter sa kahilingan, babalik kami dito sa ibang pagkakataon. Sa ilalim ng numero 2 makikita mo ang workspace at ang action bar na may mismong kahilingan, dito maaari kaming magdagdag ng mga kahilingan, tanggalin ang mga ito, at i-save din ang mga ito sa isang hiwalay na file sa disk. Sa ilalim ng numero 3 sa query console 1s 8.2 mayroong isang setting ng output ng resulta, maaari itong ipakita sa anyo ng isang talahanayan o hierarchically sa anyo ng isang puno, ang pangalawang opsyon ay ginagamit kapag kailangan nating makita ang hierarchy bilang isang resulta ng query. Ipinapakita sa amin ng item 4 kung mayroong mga pansamantalang talahanayan sa query, kung gayon, maaari naming i-debug ang mga ito at makita ang resulta ng pagpapatupad, na inilagay sa isang pansamantalang talahanayan.

Ngayon tingnan natin ang ilang mga indibidwal na punto sa query console 1s.

Sa itaas makikita mo ang isang window kung saan ang mga parameter ay pinapalitan sa kahilingan. Sa pamamagitan ng pag-click sa pindutang "Mula sa kahilingan", matatanggap namin ang mga parameter na tinukoy sa kahilingan, ngayon kailangan lang naming itakda ang mga nais na halaga at isara ang form. Siyanga pala, kung nag-e-edit ka ng kahilingan at hindi na ginagamit ang dati mong idinagdag na mga parameter sa form, iha-highlight ang mga ito sa kulay abo. Kung mayroong maraming tulad na mga parameter, maaari silang alisin mula sa window gamit ang pindutang "Tanggalin ang hindi nagamit".

Kung mayroon kang mga pansamantalang talahanayan sa iyong query, maaari mong i-debug ang mga ito sa magkakahiwalay na mga subquery at makita ang resulta ng pagpapatupad ng subquery na ito, kung sa pangunahing window ng 1c query console ay makikita natin na mayroong mga pansamantalang talahanayan, pagkatapos ay mag-click sa "Pansamantalang tables" na button (punto 4 sa pangunahing console window). Pagkatapos ng pag-click, lalabas ang window na nakita natin sa itaas, ipinapakita nito ang lahat ng pansamantalang talahanayan ng query, i-click ang "Debug" at makikita natin ang sumusunod na window.

Maikling paglalarawan ng functionality ng 1s request console para sa pinamamahalaang application 1s 8.3

Nakilala namin ang mga pangunahing pag-andar query console 1s 8.2, ngayon ay oras na upang isaalang-alang query console 1s 8.3. Ang pagpoproseso na ito hindi namin ito isasaalang-alang nang detalyado tulad ng nauna, ngunit saglit na talakayin ang pangunahing mga parameter at setting.

At mabilis na impormasyon. Sa artikulong ito, susubukan kong ilarawan kung paano gamitin ang Query Console at magbigay ng link para i-download ang Query Console.

Tingnan natin ang tool na ito.

I-download ang request console 1C

Una sa lahat, upang makapagsimula sa query console, kailangan mong i-download ito mula sa kung saan. Ang pagproseso ay karaniwang nahahati sa dalawang uri - pinamamahalaang mga form at regular (o kung minsan ay tinatawag silang 8.1 at 8.2 / 8.3).

Sinubukan kong pagsamahin ang dalawang view na ito sa isang pagproseso - sa nais na mode ng operasyon, bubukas ang nais na form ( sa managed mode, gumagana lang ang console sa thick mode).

Maaari mong i-download ang console ng kahilingan sa 1C 8.3 (8.2) para sa mga pinamamahalaang form at mga regular sa link:.

Paglalarawan ng 1C query console

Kung interesado ka sa kung paano isinusulat ang mga query sa 1C system, inirerekumenda kong basahin mo ang artikulo at.

Simulan natin ang ating pagsasaalang-alang sa query console na may paglalarawan ng pangunahing panel ng pagpoproseso:

Sa header ng query console, makikita mo ang oras ng pagpapatupad ng huling query na may katumpakan ng milliseconds, nagbibigay-daan ito sa iyong paghambingin ang iba't ibang disenyo sa mga tuntunin ng pagganap.

Ang unang pangkat ng mga pindutan sa command bar ay responsable para sa pag-save ng mga kasalukuyang query sa isang panlabas na file. Ito ay napaka-maginhawa, maaari mong palaging bumalik sa pagsulat ng isang kumplikadong query. O, halimbawa, mag-imbak ng listahan ng mga tipikal na halimbawa ng ilang partikular na konstruksyon.

Sa kaliwa, sa field ng Kahilingan, maaari kang lumikha ng mga bagong kahilingan at i-save ang mga ito sa isang istraktura ng puno. Ang pangalawang pangkat ng mga button ay responsable lamang sa pamamahala sa listahan ng mga kahilingan. Gamit ito, maaari kang lumikha, kopyahin, tanggalin, ilipat ang isang kahilingan.

Kumuha ng 267 1C na mga aralin sa video nang libre:

• Patakbuhin ang kahilingan- simpleng pagpapatupad at pagkuha ng resulta;
• Ipatupad ang package- nagbibigay-daan sa iyong tingnan ang lahat ng intermediate na kahilingan sa
• Pagtingin sa mga pansamantalang talahanayan- nagbibigay-daan sa iyong makita ang resulta na ibinabalik ng mga pansamantalang query sa talahanayan.

Mga parameter ng kahilingan:

Binibigyang-daan kang itakda ang kasalukuyang mga parameter para sa kahilingan.

Sa window ng mga parameter ng query, ang mga sumusunod ay kawili-wili:

• Pindutan Kunin mula sa kahilingan awtomatikong hinahanap ang lahat ng mga parameter sa kahilingan, para sa kaginhawahan ng developer.
• Bandila Mga solong parameter para sa lahat ng kahilingan- kapag naka-install, ang pagproseso nito ay hindi na-clear ang mga parameter kapag lumilipat mula sa kahilingan sa kahilingan sa pangkalahatang listahan ng mga kahilingan.

Magtakda ng parameter bilang isang listahan ng mga halaga napaka-simple, kapag pumipili ng isang halaga ng parameter, sapat na upang mag-click sa pindutan ng malinaw na halaga (krus), ipo-prompt ka ng system na piliin ang uri ng data, kung saan kailangan mong piliin ang "Listahan ng halaga":

Gayundin sa tuktok na panel mayroong isang pindutan para sa pagtawag sa mga setting ng query console:

Kung saan maaari mong tukuyin ang mga pagpipilian sa autosave ng query at mga pagpipilian sa pagpapatupad ng query.

Ang teksto ng kahilingan ay ipinasok sa field ng kahilingan sa console. Magagawa ito sa isang simpleng set ng pagsubok sa query o sa pamamagitan ng pagtawag sa isang espesyal na tool - ang tagabuo ng query.

Tinatawag mula sa menu ng konteksto (kanang pindutan ng mouse) kapag nag-click sa field ng input:

Gayundin sa menu na ito ay kapaki-pakinabang na mga tampok, tulad ng paglilinis o pagdaragdag ng mga character na hyphen ("|") sa kahilingan, o pagkuha ng request code sa maginhawang form na ito:

Kahilingan = Bagong Kahilingan; Pagtatanong. Text = " |PUMILI | Currencies.Reference |FROM | Handbook. Mga Pera BILANG Pera"; RequestResult = Kahilingan. Ipatupad();

Ipinapakita ng ibabang field ng query console ang field ng resulta ng query, kung saan ginawa ang pagproseso na ito:

Gayundin, ang query console, bilang karagdagan sa listahan, ay maaaring magpakita ng data sa anyo ng isang puno para sa mga query na naglalaman ng mga kabuuan.

Kaya, magsimula tayo sa isang simple: sa configurator, lumikha ng Bagong Pagproseso, 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 hindi tinukoy ang Parameter=&Date wala kahit saan.

Upang lumikha ng aming talahanayan ng Mga Parameter, sa tab na "Data" sa "Tabular na bahagi" nito, magdagdag ng bagong talahanayan, tawagin natin itong Mga Parameter ng Query, dito idaragdag natin ang mga column 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 - piliin ang pinagsama-samang uri para sa column na ParameterValue: sa menu ng mga uri na bubukas, lagyan ng tsek ang checkbox na "Composite type", piliin ang numero, string (tukuyin ang 20 character), petsa, boolean, at ilagay ang pinakamababang checkmark - AnyReference - nangangahulugan ito na higit pa, 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 nating gawin ang form ng ating Query Console sa hinaharap. Sa pagpoproseso, pumunta sa tab na "Mga Form" at magdagdag ng bago. Pumasok kami sa form na ito at mayroon nang walang limitasyong field para sa pagkamalikhain - maaari mong ayusin ang dalawang attribute na kakagawa mo lang at ang plate na may mga parameter ayon sa gusto mo! Para dito maaari kang gumamit ng mga karaniwang elemento ng form tulad ng Pangkat o Pahina na may Mga Pahina (kung mas gusto mong buksan ang mga pahina.

Ang pangunahing bagay dito ay isang bagay: sa pamamagitan ng pag-drag sa attribute na "TextValues" sa kaliwang edit field ng form - tiyaking itakda ang "View" = Field ng text document sa mga property nito. Tingnan ang figure:

Sa mga katangian ng attribute na "QueryTable," maaari mong opsyonal na tukuyin - "Display Grid" at "Display Header".

Susunod, sa tamang window 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 Constructor", maaari kang magdagdag ng icon sa button kung nais mo, ang pangunahing bagay ay ilipat ang mismong button sa kaliwang window ng pag-edit ng form - upang makita natin ito. Pagkatapos, sa tamang form window sa pag-edit, i-right-click sa aming pindutan at piliin ang mga katangian - sa mga katangian, mag-click sa item na "Action", lilitaw ang isang modal window na may tanong - kung saan eksaktong isasagawa ang aming code ng programa, na itatalaga namin sa pindutan - piliin ang "Sa kliyente".

Ang Form Module ay magbubukas sa isang handa na walang laman na pamamaraan na "Procedure Request Constructor (Command)". Sa loob ng pamamaraang ito, ilalarawan namin ang tawag sa karaniwang Query Builder 1c8. Ito ay napakadali: Constructor=Bagong Query Constructor; Ngunit may mga pitfalls dito - gumagana ang Query Constructor na binuo sa platform 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 " ThickClientOrdinaryApplication" o mayroon kang pinamamahalaang platform ng mga form, pagkatapos ay " ThickClientManagedApplication". tingnan ang fig.

Ngayon ay nananatili pa ring magdagdag sa pamamaraang ito ng kundisyon para sa pagsulat ng text ng kahilingan, na bubuo ng Query Builder para sa amin sa aming katangian ng form na "Text Request":

Kung Constructor.OpenModally()=True Then Object.QueryText=Constructor.Text; Tapusin kung;

Ngunit maaari naming manu-manong baguhin ang isang bagay sa teksto ng kahilingan (sa user mode - sa "QueryText" props window), upang ang aming mga pagbabago ay mapunta sa QueryConstructor kapag tinawag itong muli - magdagdag tayo 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, patakbuhin ang 1C:Enterprise sa makapal na client mode gamit ang isa sa mga sumusunod na pamamaraan: 1) pangunahing menu ng Configurator - Debugging - StartDebugging - ThickClient; 2) o kung mayroon kang mga key na ito sa control panel sa configurator - pindutin lamang ang pindutan na may dilaw na bilog na may makapal na tuldok, tingnan ang figure:

Ang 1sEnterprise8 user mode ay inilunsad, nakita namin ang aming pagpoproseso, ilunsad ito, i-click ang aming "Query Constructor" na button at tingnan kung paano bubukas ang constructor na binuo sa platform. tingnan ang fig.

Kaya, nagsisimula na ang Query Constructor, maaari na naming simulan ang pagdaragdag ng aming kahilingan sa hinaharap dito, ngunit interesado kaming makita kung paano gagana ang kahilingang ginawa namin! At para dito kailangan naming lumikha ng isa pang pindutan sa configurator sa pag-edit ng form ng aming console, tawagan natin itong "Run Request". Nag-click kami sa mga katangian ng pindutan ng "Run Request" sa "Action", ang menu ay muling bumababa, kung saan tatanungin kami - kung saan ipoproseso ang aming program code, sa kasong ito piliin ang "Parehong sa kliyente at sa server", muli tayong makapasok sa ModuleForms.

Sa ExecuteRequest() na pamamaraan, na mayroon kami sa kliyente, magsusulat kami ng kundisyon kung hindi naipasok ng user ang text ng kahilingan, 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 ExecuteRequestOnServer() na pamamaraan para sa amin; - 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 pagpipilian dito: Maaari mong isulat ang lahat ng mga expression na nauugnay sa pagbuo ng mga query sa iyong sarili, i. manu-mano, ngunit mayroong mas madaling opsyon - sa loob ng pamamaraan, i-right-click at piliin ang "Query Builder na may mga resulta sa pagproseso, tingnan ang figure" sa drop-down na menu:

Kung nag-click ka sa Query Builder na may Result Processing item, may lalabas na modal window na "Query text not found. Create a new one?", i-click ang yes. Bypassing the result". Iyon lang, hindi na namin kailangan ng kahit ano mula sa ang tagabuo na ito, mag-click sa pindutan ng "OK" - isang modal window ay lilitaw "Walang mga patlang ang napili sa kahilingan, i-click ang "OK".

Pagkatapos nito, sa loob ng aming procedure ExecuteRequestOnServer(), lalabas ang sumusunod na handa na blangko:

Lumipat tayo sa expression na binuo ng constructor:

Request.Text = "";

Request.Text =Object.QueryText;

Napakasimple nito, ang aming button na "Isagawa ang Kahilingan" sa form sa pagpoproseso ay praktikal na gumagana, sa ngayon ay maaari lamang itong magproseso mga simpleng tanong walang mga parameter, ngunit ang pangunahing bagay ay gumagana ito! Ito ay nananatiling biswal na ipakita sa prop ng "Talahanayan ng Halaga" sa form sa pagpoproseso - ang mga resulta ng aming kahilingan. Ipaalala ko sa iyo na ang aming attribute na "Table of Values" ay may uri na "Spreadsheet Document", dahil kung hindi, hindi namin makikita ang aming mga resulta sa user mode. Ang user ay palaging naglalabas ng tabular data alinman sa pamamagitan ng isang Spreadsheet Document o isang Layout, gusto ko talagang maipakita ang data sa pamamagitan ng isang talahanayan ng mga halaga - dahil ito ay napakadaling gamitin at pamilyar, ngunit, sa kasamaang-palad, 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 tiyak na cell gamit lamang ang mga Table Cell, dito sila ay tinatawag na isang lugar, ngunit tayo mismo ay maaaring pumili ng saklaw nito lugar sa isang partikular na Cell:

Kaya, nalaman namin kung ano ang isang dokumento ng spreadsheet, na tinutukoy para sa aming sarili na kailangan naming tukuyin ang data mula sa aming query sa isang partikular na cell ng dokumentong ito ng spreadsheet. Ngunit isipin natin: ano ang "RequestResult" na ginawa ng constructor para sa atin nang napakabilis? Pagbubukas ng tulong - Ang resulta ng query ay isang talahanayan na may kaukulang mga katangian! tingnan ang fig.

At kung isusulat natin ngayon pagkatapos ng expression na QueryResult = Query.Execute(); (nilikha ng constructor) narito ang isang simpleng loop para sa Mga Koleksyon:

Para sa bawat ColumnName Mula sa QueryResult.Columns Loop report(ColumnName.Name); EndCycle;

Pagkatapos ng loop na ito, sa ngayon, tingnan 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 kahilingan (Maaari mong gamitin ang Query Builder - gumagana na ito para sa amin) at mag-click sa button na "Run Request":

Pagkatapos ay makikita mo sa ibaba ng window sa mga mensahe - na ang QueryResult table ay nag-iimbak ng 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 QueryResult.Columns Loop Cell=Object.QueryTable.Scope(1,QueryResult.Columns.Index(ColumnName)+1); Cell.Text=ColumnName.Name; EndCycle;

Upang ipakita ang mga detalye sa data ng query, i-unmarshal natin ang mga expression na awtomatikong nilikha ng constructor at ipasok ang eksaktong parehong loop na ginamit namin upang ipakita ang mga pangalan ng column sa loob ng loop na "SelectionDetailedRecords", ngayon lang kailangan nating ilipat hindi ang "QueryResult" data ng talahanayan sa teksto ng Cell, at ang data ng Selection mismo, tingnan natin sa tulong kung paano mo maa-access ang field ng Detalyadong pagpili ng query:

SamplingDetailRecords = QueryResult.Select(); Habang SelectionDetailedRecords.Next() Loop //sa unang linya ay mayroon na kaming mga pangalan ng mga column ng talahanayan, kaya nilo-load namin ang data sa ibaba ng unang linyaDocumentLineNumber=Object.QueryTable.TableHeight+1; Para sa bawat ColumnName Mula sa QueryResult.Columns Loop Cell=Object.QueryTable.Region(DocumentRowNumber,QueryResult.Columns.Index(ColumnName)+1); Cell.Text=SelectionDetailRecords[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 Request", tingnan ang figure:

Hurrah, gumagana ang lahat!!!

Napakaginhawa kapag, kapag binubuksan / isinasara ang aming Query Console, ang aming query text, na pinagtulungan namin bago isara ang console, ay muling nakasulat sa field na "QueryText." Para magawa ito, kailangan mo lang paganahin ang form property = Autosave see pic:

Lahat, 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 "FindParameters" na button, pati na rin ang code para sa "RunQuery" na button - ang code para sa "FindParameters" na button ay isasagawa sa kliyente at sa server. Dagdag pa, sa pamamaraan ng server, inilulunsad namin ang kahilingan sa parehong paraan sa text na ipinasa dito mula sa window ng "QueryText", gamit ang expression na "Query.FindParameters()", hinahanap namin ang mga naipasa na parameter at ipinasok lang ang mga ito sa tabular na seksyon ng form na "QueryParameters" sa isang loop. Huwag kalimutang ipasa ang mga ito mula sa nakumpletong talahanayan ng parameter patungo sa pamamaraang "Ipatupad ang Kahilingan" sa ibang pagkakataon.

Maaari ka ring magdagdag ng ilang button sa aming Console na maglilinis sa window ng Mga Parameter at window ng Query Text sa user mode.

Handa nang gamitin ang aming Query Console, hilingin sa iyo ang matagumpay na mga malikhaing solusyon sa tulong ng isang simple at mahusay na tool gaya ng Query Console!

Ang pagproseso na ito ay nakasulat sa 1s8.3 platform (pinamamahalaang mga form), ito ay tumatakbo sa ilalim ng isang makapal na kliyente. Maaari rin itong isulat sa 1s8.2 platform tulad ng sa ilalim mga karaniwang anyo, at sa ilalim ng kontrol.

Sa pag-download ay isang 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 normal at pinamamahalaang mga form at sa ilalim ng thin at web client.

ps Ang anyo at hitsura ng built-in na Query Builder ay iba - depende sa kung aling kliyente namin inilunsad ang aming Console.

&AtClient Procedure Query Constructor(Command) //ang pagtawag sa karaniwang Query Constructor ay posible lamang sa ilalim ng makapal na client #If ThickClientManagedApplication o ThickClientRegularApplication Then Constructor=New Query Constructor; Kung Hindi EmptyString(Object.QueryText) Pagkatapos Constructor.Text=Object.QueryText; Tapusin kung; Kung Constructor.OpenModally()=True Then Object.QueryText=Constructor.Text; Tapusin kung; // #Otherwise // Report("Matatawag lang ang Query Builder sa ilalim ng makapal na kliyente"); // Bumalik; //# EndIf #Else Report("Pinapatakbo mo ang Query Builder sa ilalim ng thin client - bahagyang naiiba ito sa anyo nito at bilis ng pagganap!"); Constructor = Bagong Kahilingan Constructor(); Kung Hindi EmptyString(Object.QueryText) Pagkatapos Constructor.Text=Object.QueryText; Tapusin kung; AlertConstructor = Bagong AlertDescription("RunAfterClosingConstructor", ThisForm); Constructor.Show(ConstructorAlert); # EndIf EndProcedure &AtClient Procedure ExecuteAfterClosingConstructor(Resulta, Constructor Parameters) I-export //Result=text kung ang Concer ay isinara sa pamamagitan ng ok button Object.QueryText = ShortLP(Result); //nagtatrabaho!!! 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 walang paggamit ng XML code, tulad ng ginagawa nila sa mga propesyonal na console.

Maaari mong makita ang code mismo at ang mga pamamaraan para sa mekanismo ng paglilipat sa mga parameter ng Temporary Tables sa pangalawang naka-attach na file. Paano simulan ang pagbuo ng sarili mong bersyon ng Pansamantalang mga talahanayan sa mga parameter ay maaaring matingnan sa link na ito https://forum.site/forum9/topic183700/

Ngayon kung paano gamitin ang Console na may 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 PUT ExternalData MULA sa &ExternalData BILANG ExternalData; ///////////////////////////////////////////// / ///////////////////////////// PUMILI NG ExternalData.Item, ExternalData.Quantity, ISNULL(ItemsRemainsRemains.QuantityRemains, 0) AS Field1 , ISNULL(Mga Natitira sa Mga Kalakal. Natitira ang Dami, 0) - Panlabas na Data. Dami NA Natitira MULA SA Panlabas na Data BILANG Panlabas na Data INIWAN SUMALI Rehistrasyon ng akumulasyon. Produkto

Katulad ng query code sa itaas - maaari kang lumikha ng iyong sariling kumplikadong query, na isinasaalang-alang ang iyong mga object ng data.

Kaya, sa query constructor, nilikha namin ang query sa itaas sa pamamagitan ng pagsasara ng Constructor - ang query text ay mahuhulog sa aming field ng console na "Query Text", mag-click sa "Find Parameters" na buton, nakita namin na ang string = "External Data", uri ng halaga \u003d "Talahanayan ng Halaga" ay lumitaw sa talahanayan ng Mga Parameter , tingnan ang fig.

Sa Talahanayan ng Mga Parameter na ito - ilagay ang parameter na Petsa, halimbawa, petsa ngayon, pagkatapos ay mag-click sa aming parameter ng pansamantalang talahanayan na "ExternalData" upang subukang mag-edit, mag-click sa tatlong tuldok sa field na may "Talahanayan ng Halaga" - isang pagpipilian ng mga uri ay lilitaw, mag-click sa linya, ang aming mekanismo ay lumiliko ang pahina sa form para sa amin, kung saan kailangan naming manu-manong ipasok ang napaka-pansamantalang talahanayan na ito.

Dito, tandaan na sa kasong ito, sa pahina ng "TempTables" 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 "TempTables," nakikita lang namin ang isang walang laman na talahanayan - ito ang talahanayan ng Mga Uri ng aming hinaharap na pansamantalang talahanayan. Gamit ang "Add" na button, idaragdag namin ang pangalan ng attribute at uri ng hinaharap na talahanayan. . Mag-ingat - dapat tumugma ang pangalan at uri sa tinukoy namin sa kahilingan para sa &ExternalData:

Ngayon ay pinindot namin ang pindutang "UpdateTemporaryTable" - at magkakaroon kami ng pangalawang talahanayan dito - direkta naming pupunuin ito ng data ng pansamantalang talahanayan sa pamamagitan ng pindutang "Idagdag".

Iyon lang, maaari nating suriin muli ang ating sarili kung ipinasok natin ang primitive na data ng mga parameter ng query sa talahanayan ng parameter sa 1st processing page, at i-click ang button na "Ipatupad ang Kahilingan" - lahat ay binibilang, pipili nang naaayon sa paghihigpit sa data na ipinadala sa parameter ng aming pansamantalang talahanayan

ps Kung nagkamali ka sa pag-type ng mga pangalan ng mga detalye at kanilang mga uri (sa unang talahanayan) - isara lamang ang Console at buksan itong muli - ang pansamantalang talahanayan ng data ay tatanggalin - at ang talahanayan ng Mga Uri ay maaaring i-edit muli at isang bagong data table 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 gumagana ang aming console sa ilalim ng anumang kliyente! Good luck sa iyong creative developments!!!

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

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

Patuloy akong nagtatrabaho sa aking Query Console, at kamakailan ay nakatagpo ako ng isang napaka-interesante na query kung saan ang mga Temporary table ay wala sa una. humiling ng pakete, at sa mga susunod pa - at dito medyo nabaliw ang console ko ... Kinailangan niyang mag-upgrade.

Kaya, ang tagapamahala ng Temporary Table sa query ay hindi palaging nauunawaan na sila ay nagtatrabaho dito)) Samakatuwid, kailangan mong tahasang itakda itong napaka Temporary Table manager:

&OnServer Procedure ExecuteQueryOnServer() //upgrade2 - tahasang kahulugan ng TemporaryTable manager! VTManager=NewTempTableManager; Kahilingan = Bagong Kahilingan; //upgrade2 - tahasang kahulugan ng TemporaryTable manager! Query.TempTableManager = VTManager; Request.Text = Object.QueryText;

Ang bersyon na ito ng console ay nasa ikatlong boot.

Ang isa sa pinakamakapangyarihang tool ng 1C Enterprise 8, walang alinlangan, ay ang Query Builder. Ang constructor ay isang visual na tool para sa pagtatrabaho sa mga query sa 1C na wika. Ngunit ang tagabuo ay may isang malaking sagabal - hindi ito nagpapakita ng resulta ng pagpapatupad ng query. Ang pagkukulang na ito ay lalo na nararamdaman ng mga baguhang developer ng mga solusyon sa application sa 1C: Enterprise 8.3 at 8.2 platform.

Bilang karagdagan, kahit na ang mga nakaranas ng 1C programmer ay madalas na nakakaranas ng isang sitwasyon kung saan kinakailangan na gumawa ng isang "isang beses" na pagsusuri ng data ng base ng impormasyon sa iba't ibang mga seksyon, ngunit hindi mo nais na magsulat ng isang buong ulat para sa kapakanan ng tulad ng isang "isang beses na konklusyon".

Para sa lahat ng ito at marami pang ibang mga kaso, nalulugod kaming mag-alok sa iyo panlabas na pagproseso Query console na may kakayahang magproseso ng mga resulta para sa 1C 8.3 at 1C 8.2!

Mga pangunahing feature ng Query Console para sa 1C 8.3 at 1C 8.2:

Universal processing, tumatakbo sa anumang configuration ng 1C platforms: Enterprise 8.1 - 8.3;
- tumatakbo sa 1C: Enterprise mode;
- ang query ay maaaring isulat nang manu-mano, o maaari mong tawagan ang Query Builder;
- nagpapakita ng resulta ng kahilingan;
- maaari mong tukuyin ang mga parameter ng ulat nang direkta sa Query Console;
- maaaring mag-save at mag-load ng mga file ng kahilingan.

Upang ilunsad ang Query Console, kailangan mong patakbuhin ang iyong configuration sa 1C:Enterprise mode at buksan ang panlabas na pagproseso ng Query Console tulad ng anumang iba pang file na nakaimbak sa disk. Ang ganitong pagproseso ay gagana sa eksaktong parehong paraan na parang bahagi ito ng inilapat na solusyon.

Inuulit ng External processing Query Console ang pamilyar na interface at karamihan functionality karaniwang toolkit para sa pag-compile ng mga query ng 1C: Enterprise 8.3 at 8.2 system. Binibigyang-daan ka rin nitong makuha ang mga resulta ng mga query, batch query, at pansamantalang mga talahanayan.

Ang query console ay pinaandar pareho sa client-server at file-server operating mode ng system, parehong sa ilalim ng makapal at manipis na mga kliyente! Isinasama ng Query Console ang karaniwang Query Builder, na tinatawag sa pamamagitan ng menu ng konteksto sa patlang ng katawan ng kahilingan.

MAHALAGA! Query constructor in manipis na kliyente ay hindi gumagana, ang menu item na ito para sa pagbubukas ng Constructor ay hindi magagamit. Sa makapal na kliyente, available ang Query Builder!

Sa manipis na kliyente, maaari lamang kaming sumulat ng mga kahilingan sa pamamagitan ng kamay, lahat ng iba pang mga pag-andar ay gumagana nang walang mga pagbabago.