Poproś o formularze zarządzane w konsoli 1s 8.3.

I szybka informacja. W tym artykule postaram się opisać jak korzystać z Query Console oraz podać link do pobrania Query Console.

Przyjrzyjmy się bliżej temu narzędziu.

Pobierz konsolę żądań 1C

Przede wszystkim, aby rozpocząć pracę z konsolą zapytań, musisz ją skądś pobrać. Przetwarzanie zwykle dzieli się na dwa typy - formularze zarządzane i zwykłe (czasami nazywane są 8.1 i 8.2 / 8.3).

Próbowałem połączyć te dwa widoki w jednym przetwarzaniu - w żądanym trybie działania otwiera się żądany formularz ( w trybie zarządzanym konsola działa tylko w trybie grubym).

Możesz pobrać konsolę żądań 1C 8.3 (8.2) dla formularzy zarządzanych i zwykłych pod linkiem:.

Opis konsoli zapytań 1C

Jeśli interesuje Cię sposób zapisywania zapytań w systemie 1C, polecam przeczytanie artykułu i.

Rozważanie konsoli zapytań zacznijmy od opisu głównego panelu przetwarzania:

W nagłówku konsoli zapytań widoczny jest czas wykonania ostatniego zapytania z dokładnością do milisekund, pozwala to na porównanie różnych projektów pod względem wydajności.

Pierwsza grupa przycisków na pasku poleceń odpowiada za zapisanie bieżących zapytań w pliku zewnętrznym. Jest to bardzo wygodne, zawsze możesz wrócić do pisania złożonego zapytania. Lub na przykład przechowuj listę typowych przykładów określonych konstrukcji.

Po lewej stronie w polu Zapytanie możesz tworzyć nowe zgłoszenia i zapisywać je w strukturze drzewiastej. Druga grupa przycisków odpowiada właśnie za zarządzanie listą żądań. Dzięki niemu możesz tworzyć, kopiować, usuwać, przenosić żądania.

Uzyskaj 267 lekcji wideo 1C za darmo:

Uruchom żądanie- proste wykonanie i uzyskanie wyniku;
Wykonaj pakiet- umożliwia przeglądanie wszystkich żądań pośrednich w
Przeglądanie tabel tymczasowych- pozwala zobaczyć wynik, jaki zwracają zapytania tymczasowe w tabeli.

Parametry żądania:

Umożliwia ustawienie bieżących parametrów żądania.

W oknie parametrów zapytania interesujące jest:

Przycisk Pobierz z żądania automatycznie wyszukuje wszystkie parametry w żądaniu, dla wygody programisty.
Flaga Pojedyncze parametry dla wszystkich żądań- po zainstalowaniu jego przetwarzanie nie czyści parametrów podczas przechodzenia od żądania do żądania na ogólnej liście żądań.

Ustaw parametr jako listę wartości bardzo proste, przy wyborze wartości parametru wystarczy kliknąć przycisk kasowania wartości (krzyżyk), system poprosi o wybranie typu danych, gdzie należy wybrać „Lista wartości”:

Również w górnym panelu znajduje się przycisk umożliwiający wywołanie ustawień konsoli zapytań:

Gdzie możesz określić opcje automatycznego zapisywania zapytań i opcje wykonywania zapytań.

Tekst żądania jest wprowadzany w polu żądania konsoli. Można to zrobić za pomocą prostego zestawu testów zapytań lub wywołując specjalne narzędzie - konstruktor zapytań.

Wywoływane z menu kontekstowego (prawy przycisk myszy) po kliknięciu pola wejściowego:

Również w tym menu znajdują się przydatne funkcje, takie jak czyszczenie lub dodawanie myślników („|”) do żądania lub pobieranie kodu żądania w tej wygodnej formie:

Żądanie = Nowe żądanie; Wniosek. Text = " |WYBIERZ | Waluty.Referencja |FROM | Podręcznik Waluty jako waluty”; Wynik żądania = Żądanie. Wykonać() ;

W dolnym polu konsoli zapytań wyświetlane jest pole wyniku zapytania, dla którego utworzono to przetwarzanie:

Ponadto konsola zapytań oprócz listy może wyświetlać dane w formie drzewa dla zapytań zawierających sumy.

Konsola zapytań 1s- wygodne narzędzie do budowania i debugowania zapytań w trybie korporacyjnym 1s. Korzystanie z konsoli zapytań Możesz wykonać żądanie do bazy danych 1s i zobaczyć wynik żądania bezpośrednio na ekranie w przedsiębiorstwie 1s. W tym artykule rozważymy dwie konsole, jedną dla 1s 8.2 (zwykłe formy), a druga może działać zarówno w normalnej, jak i zarządzanej formie 1s 8.3.

Pobierz konsolę zapytań 1s

Aby rozpocząć pracę z przetwarzaniem, musisz najpierw pobierz konsolę zapytań 1s, poniżej podamy linki do pobrania, ale na razie zwróćmy uwagę na fakt, że konsolę żądań 1s można sklasyfikować i zaklasyfikować do jednego z następujących typów:

Dla formularzy regularnych (1s 8.2)
W przypadku formularzy zarządzanych (1s 8.3)
Mieszane (działa zarówno na 1s 8.2, jak i 1s 8.3)

W naszym artykule rozważymy dwie konsole, pierwsza działa tylko na 1s 8.2 (zwykłe formularze), a druga działa na 1s 8.3 (formy zarządzane). Różnią się one nieco od siebie, o różnicach porozmawiamy dalej, ale na razie zauważamy, że w zarządzanych aplikacjach konsola będzie działać poprawnie tylko w trybie uruchamiania „Grubego Klienta”.

Pobierz konsolę żądań 1s dla zwykłej aplikacji 1s 8.2

Poniżej znajduje się zrzut ekranu przetwarzania, możesz pobrać konsolę żądań 1s dla zwykłej aplikacji 1s 8.2

Pobierz konsolę żądań 1s dla zarządzanej aplikacji 1s 8.3

A to jest druga konsola, jej zrzut ekranu możecie zobaczyć także na screenie poniżej, korzystając z linku można pobrać konsolę żądań 1s dla zarządzanej aplikacji 1s 8.3

Opis zasady działania i głównej funkcjonalności konsoli żądań 1s dla zwykłej aplikacji 1s 8.2

Ten zapytaj konsolę 1s 8.2 dla zwykłej aplikacjiłatwy w obsłudze i nie wymagający od użytkownika żadnej specjalnej wiedzy. Na zrzucie ekranu widać pole testowe do zapisania zapytania, można w nim wpisać zapytanie zarówno ręcznie, jak i za pomocą konstruktora. Pod numerem 1 na rysunku widoczny jest przycisk „Parametry”, klikając na niego wyświetli się formularz wstawienia parametrów do żądania, powrócimy do niego później. Pod cyfrą 2 widzimy obszar roboczy oraz pasek akcji z samym żądaniem, tutaj możemy dodawać żądania, usuwać je, a także zapisywać w osobnym pliku na dysku. Pod numerem 3 konsola zapytań 1s 8.2 istnieje ustawienie wyniku, można go wyświetlić w formie tabeli lub hierarchicznie w formie drzewa, drugiej opcji używamy, gdy chcemy zobaczyć hierarchię w wyniku zapytania. Punkt 4 pokazuje nam, czy w zapytaniu znajdują się tabele tymczasowe, jeśli tak, to możemy je zdebugować i zobaczyć wynik wykonania, który zostaje umieszczony w tabeli tymczasowej.

Przyjrzyjmy się teraz kilku indywidualnym punktom konsola zapytań 1s.

Powyżej widzisz okno, w którym do żądania podstawione są parametry. Klikając przycisk „Z żądania” otrzymamy parametry określone w żądaniu, teraz pozostaje nam tylko ustawić żądane wartości i zamknąć formularz. Przy okazji, jeżeli edytujesz zgłoszenie i Twoje wcześniej dodane parametry w formularzu nie są już używane, zostaną one podświetlone na szaro. Jeżeli takich parametrów jest dużo, można je usunąć z okna przyciskiem „Usuń nieużywane”.

Jeśli w zapytaniu masz tabele tymczasowe, możesz je zdebugować w osobnych podzapytaniach i zobaczyć wynik wykonania tego podzapytania, jeśli w głównym oknie konsoli zapytań 1c zobaczymy, że istnieją tabele tymczasowe, to kliknij „Tymczasowe tabele” (punkt 4 w głównym oknie konsoli). Po kliknięciu pojawi się okno, które widzieliśmy powyżej, pokazuje wszystkie tymczasowe tabele zapytania, kliknij „Debuguj” i zobaczymy następujące okno.

Krótki opis funkcjonalności konsoli żądań 1s dla zarządzanej aplikacji 1s 8.3

Zapoznaliśmy się z głównymi funkcjami konsola zapytań 1s 8.2, teraz czas się zastanowić konsola zapytań 1s 8.3. Nie będziemy rozważać tego przetwarzania tak szczegółowo, jak poprzednie, ale krótko omówimy główne parametry i ustawienia.

Konsola zapytań jest bardzo wygodna w użyciu, gdy trzeba debugować jakiś złożony plik lub szybko uzyskać wybór określonych danych.

W Internecie można znaleźć wiele różnych konsol. W przypadku formularzy zwykłych i zarządzanych są to zazwyczaj zupełnie różne konsole. Zgodnie z tym możesz pobrać uniwersalną konsolę zapytań 1C 8.3 i 8.2, która będzie działać w obu przypadkach. Pamiętaj tylko, że konsola na zarządzanym interfejsie otworzy się tylko w grubym kliencie.

Praca z konsolą zapytań

W programie 1C konsola zapytań otwiera się w taki sam sposób, jak każde przetwarzanie zewnętrzne: menu „Plik” - „Otwórz” lub za pomocą kombinacji klawiszy skrótu „Ctrl + O”. Przy częstym użyciu można go dodać do zewnętrznego przetwarzania samej bazy danych.

Lista Twoich żądań jest prezentowana po lewej stronie konsoli żądań. Dzięki temu możesz przechowywać nie tylko jedno żądanie, ale kilka na raz. Drzewo zapytań ma strukturę hierarchiczną, co jest bardzo wygodne przy ich grupowaniu.

Klikając przycisk „Dodaj”, możesz dodać nowe zgłoszenie, samodzielnie nadając mu nazwę. Ponadto wbudowana funkcjonalność umożliwia tworzenie zapytań z kopiowaniem, przesuwaniem w górę lub w dół listy i wiele więcej.

Sam tekst żądania jest wyświetlany po prawej stronie formularza przetwarzania. Można go napisać ręcznie lub za pomocą konstruktora zapytań. Kreator zapytań działa tylko w grubym kliencie.

Po prawej stronie przycisku konstruktora znajduje się przycisk „Wstaw operatory zapytań”. Natychmiast doda pustą strukturę zapytania z warunkiem, grupowaniem, kolejnością i sumami.

Po prawej stronie znajdują się bardzo przydatne przyciski, które pomogą, jeśli użyjesz tego zapytania podczas opracowywania rozwiązań dla 1C.

Przycisk umożliwia konwersję napisanego zapytania na tekst. W naszym przypadku będzie to wyglądało jak na obrazku poniżej.

Możesz zapisać żądania do pliku lub załadować z niego. Jest to bardzo wygodne do wykorzystania w przyszłości.

Przed bezpośrednim wykonaniem zapytania należy ustawić jego parametry wejściowe (jeśli istnieją), a następnie kliknąć przycisk „Uruchom zapytanie”. Również tutaj możliwe jest wykonywanie żądań nie w całości, ale osobno dowolnego pakietu.

Tryb widoku określa sposób wyświetlania wyniku zapytania: lista, lista hierarchiczna lub drzewo.

Wynik wykonania zostanie wyświetlony na samym dole konsoli żądań. Wyświetla także liczbę otrzymanych wierszy i czas wykonania. W razie potrzeby możesz przenieść wiersze wyniku zapytania.

Bardzo często użytkownicy proszeni są o wybranie niektórych danych i zapisanie ich w Excelu. Możesz tego też potrzebować. Aby wykonać zadanie, wystarczy wybrać opcję „Wyświetl listę” w menu „Więcej”. Program poprosi Cię o zaznaczenie wymaganych kolumn.

Oprócz ustawienia listy kolumn dla wyników, możesz także określić tutaj określone wiersze. Odbywa się to poprzez podświetlanie wierszy w samym zapytaniu. Ponadto w formularzu wyboru kolumny wystarczy ustawić flagę w ustawieniu „Tylko wybrane”.

W naszym przykładzie wyświetliliśmy wszystkie dane wyników zapytania. Możesz zapisać je w pliku zewnętrznym, kopiując je z otwartego dokumentu arkusza kalkulacyjnego lub używając kombinacji klawiszy skrótu Ctrl+O. Istnieje wiele opcji zapisywania formatów, wybraliśmy „*. xlsx”.

Jak widać, praca w konsoli zapytań jest bardzo wygodna i przydatna, dlatego zdecydowanie zalecamy pobranie jej i zastosowanie w praktyce.

Bez wątpienia jednym z najpotężniejszych narzędzi 1C Enterprise 8 jest Konstruktor zapytań. Konstruktor to wizualne narzędzie do pracy z zapytaniami w języku 1C. Konstruktor ma jednak jedną dużą wadę - nie pokazuje wyniku wykonania zapytania. Ta wada jest szczególnie odczuwalna przez początkujących twórców rozwiązań aplikacyjnych na platformie 1C:Enterprise 8.3 i 8.2.

Ponadto nawet doświadczeni programiści 1C często stają w obliczu sytuacji, w której konieczne jest dokonanie „jednorazowej” analizy danych bazy informacyjnej w różnych sekcjach, ale nie chcesz pisać pełnoprawnego raportu dla ze względu na taki „jednorazowy wniosek”.

We wszystkich tych i wielu innych przypadkach mamy przyjemność zaoferować Państwu przetwarzanie zewnętrzne. Konsola zapytań z możliwością przetwarzania wyników dla 1C 8.3 i 1C 8.2!

Kluczowe funkcje konsoli zapytań dla 1C 8.3 i 1C 8.2:

Uniwersalne przetwarzanie, działa na dowolnej konfiguracji platform 1C: Enterprise 8.1 - 8.3;
- uruchamia się w trybie 1C:Enterprise;
- zapytanie można napisać ręcznie lub wywołać Konstruktora zapytań;
- pokazuje wynik żądania;
- możesz określić parametry raportu bezpośrednio w Konsoli Zapytań;
- może zapisywać i ładować pliki żądań.

Aby uruchomić konsolę zapytań, musisz uruchomić konfigurację w trybie 1C:Enterprise i otworzyć zewnętrzne przetwarzanie konsoli zapytań, jak każdy inny plik przechowywany na dysku. Taka obróbka będzie działać dokładnie tak samo, jakby była częścią zastosowanego rozwiązania.

Przetwarzanie zewnętrzne Konsola zapytań powtarza znajomy interfejs i większość funkcjonalności standardowych narzędzi do wysyłania zapytań 1C:Enterprise 8.3 i 8.2. Umożliwia także uzyskanie wyników zapytań, zapytań wsadowych i tabel tymczasowych.

Konsola zapytań jest wykonywana zarówno w trybie klient-serwer, jak i serwer plików systemu, zarówno na grubych, jak i cienkich klientach! Konsola zapytań integruje standardowy Konstruktor zapytań, wywoływany poprzez menu kontekstowe w polu tekstowym zapytania.

WAŻNY! Projektant zapytań w cienkim kliencie nie działa, ten element menu umożliwiający otwarcie Projektanta jest niedostępny. W grubym kliencie dostępny jest Konstruktor zapytań!

W cienkim kliencie żądania możemy pisać jedynie ręcznie, wszystkie pozostałe funkcje działają bez zmian.

Zacznijmy więc od prostego: w konfiguratorze utwórz Nowe Przetwarzanie, nadaj mu nazwę Query Console lub Query Builder, jak chcesz.

Możemy od razu dodać etykietę do „Danych” dla przyszłych parametrów, które będą nam potrzebne, aby w naszej Konsoli uruchamiać nie najprymitywniejsze żądanie, ale z parametrami i linkami np. do naszej pracy utworzymy żądanie do rejestrów okresowych , ale tutaj bez określenia Parametr=&Data nigdzie.

Aby utworzyć naszą tabelę Parametry, na zakładce „Dane” w jej „sekcji tabelarycznej” dodaj nową tabelę, nazwijmy ją Query Parameters, tutaj dodajemy kolumny tej tabeli: 1) Nazwa Parametru, typ ciągu = 25 znaków; ParameterValue, tutaj jest złożony typ danych, patrz rys.:

Dlatego tak jak pokazano na rysunku - wybierz typ złożony dla kolumny ParametrWartość: w menu Typ, które się otworzy, zaznacz pole wyboru „Typ złożony”, wybierz liczbę, ciąg znaków (określ 20 znaków), datę, wartość logiczną i wstaw najniższy znacznik - AnyReference - oznacza, że dodatkowo określając Parametry naszego żądania, możemy odwołać się do dowolnego obiektu naszej konfiguracji, np. katalogów czy dokumentów.

Teraz musimy stworzyć formę naszej przyszłej Konsoli Zapytań. W trakcie obróbki przechodzimy do zakładki „Formularze” i dodajemy nowy. Wchodzimy w ten formularz i już mamy nieograniczone pole do popisu – dwa utworzone przed chwilą atrybuty i płytkę z parametrami możemy dowolnie aranżować! W tym celu możesz użyć standardowych elementów formularza, takich jak Grupa lub Strona ze stronami (jeśli bardziej lubisz przewracać strony.

Najważniejsze tutaj jest jedno: przeciągając atrybut „TextValues” do lewego pola edycyjnego formularza - pamiętaj o ustawieniu „Widok” = Pole dokumentu tekstowego w jego właściwościach. Zobacz rysunek:

We właściwościach atrybutu „QueryTable” możesz opcjonalnie określić - „Display Grid” i „Display Headers”.

Następnie w odpowiednim oknie edycji formularza przejdź do zakładki „Komendy” i dodaj nowy przycisk, po kliknięciu nasza Konsola wykona określoną akcję. Stwórzmy przycisk „Konstruktor zapytań”, na własne życzenie możesz dodać ikonę do przycisku, najważniejsze jest, aby sam przycisk przesunąć w lewą stronę okna edycji - tak, abyśmy mogli go zobaczyć. Następnie w prawym w oknie edycji formularza kliknij nasz przycisk prawym przyciskiem myszy i wybierz właściwości - we właściwościach kliknij pozycję „Akcja”, pojawi się okno modalne z pytaniem – gdzie dokładnie zostanie wykonany kod naszego programu, który przypiszemy do przycisk - wybierz „Na kliencie”.

Otworzy się moduł formularza z gotową, pustą procedurą „Konstruktor żądania procedury (polecenie)”. W ramach tej procedury opiszemy wywołanie standardowego Konstruktora zapytań 1c8. To bardzo łatwe: Konstruktor=Nowy konstruktor zapytań; Są tu jednak pułapki — wbudowany w platformę Konstruktor zapytań działa w trybie użytkownika TYLKO w przypadku grubego klienta! Dlatego wstawimy warunek instrukcji preprocesora #If, ale tutaj sam decydujesz, na podstawie swojej platformy, czy masz zwykłe formularze, to wybierz „ Aplikacja ThickClientOrdinary" lub masz platformę zarządzanych formularzy, to " Gruba aplikacja zarządzana przez klienta„.patrz rys.

Teraz pozostaje dodać do tej procedury warunek zapisania tekstu żądania, który Konstruktor zapytań wygeneruje dla nas w naszym atrybucie formularza „Żądanie tekstowe”:

Jeśli Constructor.OpenModally()=True To Object.QueryText=Constructor.Text; KoniecJeśli;

Możemy jednak ręcznie zmienić coś w tekście żądania (w trybie użytkownika - w oknie atrybutu „QueryText”), tak aby nasze zmiany trafiły do QueryConstructora przy jego ponownym wywołaniu - dodajmy tutaj prosty warunek:

Jeśli nie jest pustyString(Object.QueryText), to Constructor.Text=Object.QueryText; KoniecJeśli;

To wszystko, podłączyliśmy Query Constructor wbudowany w platformę 1c8, spójrzmy na naszą pracę. Aby to zrobić, uruchom 1C:Enterprise w trybie grubego klienta, korzystając z jednej z następujących metod: 1) menu główne Konfiguratora - Debugowanie - StartDebugging - Gruby Klient; 2) lub jeśli masz te klawisze na panelu sterowania w konfiguratorze - wystarczy nacisnąć przycisk z żółtym kółkiem z grubą kropką, patrz rysunek:

Uruchamia się tryb użytkownika 1sEnterprise8, znajdujemy nasze przetwarzanie, uruchamiamy je, klikamy na nasz przycisk „Konstruktor zapytań” i widzimy, jak otwiera się konstruktor wbudowany w platformę. patrz rys.

A więc uruchamia się Konstruktor zapytań, możemy już zacząć dodawać do niego nasze przyszłe żądanie, ale jesteśmy ciekawi, jak sprawdzi się utworzone przez nas żądanie! A do tego musimy stworzyć w konfiguratorze kolejny przycisk w edycji formularza naszej konsoli, nazwijmy go „Run Request”. We właściwościach przycisku „Wykonaj żądanie” kliknij „Akcja”, ponownie pojawia się menu, w którym zostajemy zapytani, gdzie będzie przetwarzany kod naszego programu, w tym przypadku wybierz „Zarówno na kliencie, jak i na serwerze ", ponownie wchodzimy do ModuleForms.

W procedurze ExecuteRequest(), którą mamy na kliencie, napiszemy warunek w przypadku, gdy użytkownik nie wpisał tekstu żądania, ale poprosi o jego wykonanie:

IfpustyString(Object.QueryText) then report("Wprowadź tekst zapytania!"); KoniecJeśli;

System już automatycznie wygenerował dla nas link do procedury ExecuteRequestOnServer(); - to dobrze, przejdźmy do tej procedury, która jest wykonywana na serwerze i napisz tutaj kod realizujący nasze wprowadzone żądanie.

Do wyboru są tutaj: Wszystkie wyrażenia związane z konstrukcją zapytań możesz napisać samodzielnie, tj. ręcznie, ale istnieje jeszcze łatwiejsza opcja - w obrębie procedury kliknij prawym przyciskiem myszy i wybierz z menu rozwijanego „Kreator zapytań z przetwarzaniem wyników, patrz rysunek”:

Jeśli kliknąłeś na pozycję Konstruktor zapytań z przetwarzaniem wyników, pojawi się okno modalne „Nie znaleziono tekstu zapytania. Utworzyć nowe?”, kliknij tak. Pomijanie wyniku”. To wszystko, nie potrzebujemy niczego więcej od tego konstruktora, kliknij przycisk „OK” - wyskoczy okno modalne „W żądaniu nie wybrano żadnych pól, kliknij „OK”.

Następnie w naszej procedurze ExecuteRequestOnServer() pojawi się gotowe puste pole:

Przejdźmy do wyrażenia zbudowanego przez konstruktora:

Żądanie.Text = "";

Żądanie.Text =Obiekt.QueryText;

Wszystko jest takie proste, nasz przycisk „Wykonaj żądanie” na formularzu przetwarzania jest już praktycznie sprawny, na razie może przetwarzać tylko proste żądania bez parametrów, ale najważniejsze, że działa! Pozostaje tylko wizualnie wyświetlić w rekwizycie „Tabela wartości” na formularzu przetwarzania - wyniki naszego żądania. Przypominam, że nasz atrybut „Tabela wartości” ma typ „Dokument arkusza kalkulacyjnego”, gdyż w przeciwnym razie w trybie użytkownika nie zobaczymy naszych wyników. Użytkownik jest zawsze zaangażowany w wyprowadzanie danych tabelarycznych za pomocą dokumentu arkusza kalkulacyjnego lub układu. Naprawdę chciałbym, aby możliwe było wyświetlanie danych za pomocą tabeli wartości - ponieważ jest to bardzo łatwe w użyciu i znajome, ale , niestety tabela wartości to tylko narzędzie potrzebne programiście, nie da się za jej pomocą wyświetlić danych na ekranie...

Przyjrzyjmy się bliżej, czym jest Dokument arkusza kalkulacyjnego - jest jak arkusz Excela - do rekordu w konkretnej komórce można dostać się tylko za pomocą komórek tabeli, tutaj nazywamy je obszarem, ale sami możemy wybrać zakres tego obszar w jedną konkretną komórkę:

Ustaliliśmy więc, czym jest dokument arkusza kalkulacyjnego, sami ustaliliśmy, że musimy określić dane z naszego zapytania w określonej komórce tego dokumentu arkusza kalkulacyjnego. Ale zastanówmy się: jaki jest „RequestResult”, który tak szybko wygenerował dla nas konstruktor? Otwarcie pomocy - Wynikiem zapytania jest tabela posiadająca odpowiednie właściwości! patrz rys.

A jeśli teraz napiszemy po wyrażeniu QueryResult = Query.Execute(); (utworzonym przez konstruktora) to oto taka prosta pętla dla Kolekcji:

Dla każdego ColumnName z QueryResult.Columns Loop report(ColumnName.Name); Koniec cyklu;

Po tej pętli sprawdź na razie wszystkie wyrażenia zbudowane automatycznie przez konstruktora. I uruchom 1C:Enterprise8 pod grubym klientem, utwórz dowolne proste żądanie (możesz użyć Konstruktora zapytań - u nas już działa) i kliknij przycisk „Uruchom żądanie”:

Wtedy zobaczysz na dole okna w komunikatach - że tabela QueryResult przechowuje nazwy pól, które właśnie wybraliśmy tworząc proste zapytanie.

Wyświetlmy teraz nazwy pól naszego cierpienia w dokumencie arkusza kalkulacyjnego:

Dla każdej nazwy kolumny z QueryResult.Columns Loop Cell=Object.QueryTable.Scope(1,QueryResult.Columns.Index(NazwaKolumny)+1); Cell.Text=NazwaKolumny.Nazwa; Koniec cyklu;

Aby wyświetlić szczegóły danych zapytania - zmieńmy rozmiar wyrażeń utworzonych automatycznie przez konstruktora i wstawmy dokładnie tę samą pętlę, której użyliśmy do wyświetlenia nazw kolumn w pętli "SelectionDetailedRecords", tylko teraz musimy przenieść nie dane Tabela „QueryResult” do tekstu komórki i danych samej selekcji, zobaczmy w pomocy, jak uzyskać dostęp do pola Szczegółowy wybór zapytania:

SamplingDetailRecords = QueryResult.Select(); Podczas gdy SelectionDetailedRecords.Next() Loop //w pierwszej linii mamy już nazwy kolumn tabeli, zatem wczytujemy dane poniżej pierwszej liniiDocumentLineNumber=Object.QueryTable.TableHeight+1; Dla każdej nazwy kolumny z QueryResult.Columns Loop Cell=Object.QueryTable.Region(DocumentRowNumber,QueryResult.Columns.Index(NazwaKolumny)+1); Cell.Text=SelectionDetailRecords[NazwaKolumny.Nazwa]; Koniec cyklu; Koniec cyklu;

To wszystko, możemy sprawdzić, załadować przedsiębiorstwo pod grubym klientem, wprowadzić proste żądanie bez parametrów, kliknąć przycisk „Uruchom żądanie”, patrz rysunek:

Hurra, wszystko działa!!!

Jest to bardzo wygodne, gdy przy otwieraniu/zamykaniu naszej Konsoli Zapytań nasz tekst zapytania, z którym pracowaliśmy przed zamknięciem konsoli, jest ponownie wpisywany w polu „QueryText”. Aby to zrobić, wystarczy włączyć właściwość formularza = Autozapis, patrz zdjęcie:

Wszystko, nasza konsola działa. Abyśmy mogli pisać bardziej złożone zapytania z określonymi w nich parametrami, musimy stworzyć kolejny przycisk „FindParameters”, a także kod dla przycisku „RunQuery” - kod dla przycisku „FindParameters” zostanie wykonany na kliencie i na serwerze. Dalej w procedurze serwera uruchamiamy żądanie w ten sam sposób z tekstem przekazanym mu z okna „QueryText”, korzystając z wyrażenia „Query.FindParameters()”, odnajdujemy przekazane parametry i po prostu wpisujemy je do tabelaryczna część formularza „QueryParameters” w pętli. Nie zapomnij przekazać ich później z wypełnionej tabeli parametrów do procedury „Wykonaj żądanie”.

Możesz także dodać do naszej Konsoli kilka przycisków, które wyczyścią okno Parametry i okno Tekst zapytania w trybie użytkownika.

Nasza Konsola Zapytań jest gotowa do użycia, życzymy udanych kreatywnych rozwiązań przy pomocy tak prostego i potężnego narzędzia jak Konsola Zapytań!

To przetwarzanie jest napisane na platformie 1s8.3 (formularze zarządzane), działa pod grubym klientem. Można go również napisać na platformie 1s8.2 zarówno w normalnych formach, jak iw zarządzanych.

W pobranym pliku znajduje się próbka właśnie utworzonej przez nas konsoli zapytań.

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

Aktualizacja konsoli zapytań:

1) Teraz nasza domowa konsola zapytań z wbudowanym Konstruktorem zapytań będzie działać pod dowolnym klientem: w grubym kliencie formularzy normalnych i zarządzanych oraz w kliencie cienkim i internetowym.

ps Forma i wygląd wbudowanego Konstruktora Zapytań jest różna - w zależności od tego, pod jakim klientem uruchomiliśmy naszą Konsolę (osobiście formularz Konstruktora Zapytań pod grubym klientem jest mi bardziej znajomy i wygodny)

Procedura &AtClient Konstruktor zapytań(polecenie) //wywołanie standardowego konstruktora zapytań jest możliwe tylko w przypadku grubego klienta #If ThickClientManagedApplication lub ThickClientRegularApplication then Constructor=Nowy konstruktor zapytań; Jeśli nie jest pustyString(Object.QueryText), to Constructor.Text=Object.QueryText; KoniecJeśli; Jeśli Constructor.OpenModally()=True To Object.QueryText=Constructor.Text; KoniecJeśli; // #Otherwise // Report("Kreatora zapytań można wywołać tylko w grubym kliencie"); // Powrót; //# EndIf #Else Report("Używasz Konstruktora zapytań na cienkim kliencie - różni się on nieco formą i szybkością działania!"); Konstruktor = Nowy konstruktor żądania(); Jeśli nie jest pustyString(Object.QueryText), to Constructor.Text=Object.QueryText; KoniecJeśli; AlertConstructor = New AlertDescription("RunAfterClosingConstructor", ThisForm); Konstruktor.Show(ConstructorAlert); # EndIf EndProcedure &AtClient Procedura ExecuteAfterClosingConstructor(Result, Constructor Parameters) Export //Result=text jeśli Concer został zamknięty przyciskiem OK Obiekt.QueryText = ShortLP(Result); //Pracuje!!! Zakończ procedurę

2) Dodano możliwość wprowadzania złożonych zapytań do naszej prostej konsoli zapytań z tabelą tymczasową przekazywaną do parametrów!!! Mechanizm okazał się bardzo prosty i elegancki – bez użycia kodu XML, jak to ma miejsce w profesjonalnych konsolach.

Sam kod oraz procedury mechanizmu przenoszenia parametrów Tablic tymczasowych możecie zobaczyć w drugim załączonym pliku. Jak rozpocząć tworzenie własnej wersji tabel tymczasowych w parametrach można zobaczyć pod tym linkiem https://forum.site/forum9/topic183700/

Teraz jak korzystać z konsoli przy złożonym zapytaniu, gdy do jej parametrów przekazywana jest tabela tymczasowa. Na przykład możesz pobrać kod tego żądania;

WYBIERZ dane zewnętrzne.Item, dane zewnętrzne.ilość PUT dane zewnętrzne z &ExternalData jako dane zewnętrzne; /////////////////////////////////////////////// / //////////////////////////// SELECT externalData.Item, externalData.Quantity, ISNULL(ItemsRemainsRemains.QuantityRemains, 0) AS Field1 , ISNULL(ItemsRemainsRemains.QuantityRemains, 0) - OutsideData.Quantity AS Pozostało FROM dane zewnętrzne AS dane zewnętrzne LEWY DOŁĄCZ statystyki oprogramowania externalData.Product = RemainingProductsRemains. Product

Podobnie jak w powyższym kodzie zapytania - możesz stworzyć własne złożone zapytanie, biorąc pod uwagę Twoje obiekty danych.

Zatem w konstruktorze zapytań utworzyliśmy powyższe zapytanie zamykając Konstruktor - tekst zapytania wpadnie do naszego pola konsoli „Tekst zapytania”, klikamy na przycisk „Znajdź parametry”, widzimy, że ciąg = „Zewnętrzny Dane”, typ wartości \u003d „Tabela wartości” pojawił się w tabeli Parametry , patrz ryc.

W tej Tabeli Parametrów - wprowadź parametr Date, np. dzisiejszą datę, następnie kliknij aby spróbować edytować nasz parametr tabeli tymczasowej "ExternalData", kliknij trzy kropki w polu z "Tabelą Wartości" - wybór typów pojawi się, kliknij linię, nasz mechanizm przewróci za nas stronę w formularzu, gdzie musimy ręcznie wejść do tej bardzo tymczasowej tabeli.

Tutaj zwróć uwagę, że w tym przypadku na stronie „TempTables” na dole w polu „Tymczasowa nazwa tabeli w parametrach” pojawi się nazwa naszej tabeli tymczasowej (jest ona skopiowana z tabeli Parametry).

Póki co na stronie "TempTables" widzimy tylko jedną pustą tabelę - jest to tabela Typów naszej przyszłej tabeli tymczasowej. Za pomocą przycisku "Dodaj" dodamy nazwę atrybutu i typ przyszłej tabeli . Bądź ostrożny - nazwa i typ muszą odpowiadać tym, które określiliśmy w żądaniu &ExternalData:

Teraz wciskamy przycisk „UpdateTemporaryTable” – i będziemy mieli tutaj drugą tabelę – bezpośrednio wypełnimy ją danymi tabeli tymczasowej poprzez przycisk „Dodaj”.

To wszystko, możemy jeszcze raz sprawdzić, czy wprowadziliśmy dane parametrów pierwotnego zapytania do tabeli parametrów na 1. stronie przetwarzania i kliknąć przycisk „Uruchom żądanie” - wszystko się liczy, odpowiednio wybiera z ograniczeniem przesyłanych danych w parametrze naszej tabeli tymczasowej

ps Jeżeli pomyliłeś się przy wpisywaniu nazw detali i ich typów (w pierwszej tabeli) - po prostu zamknij Konsolę i otwórz ją ponownie - tymczasowa tabela danych zostanie usunięta - a tabelę Typy będzie można ponownie edytować i można ponownie utworzyć nową tabelę danych.

To wszystko, własnoręcznie możemy stworzyć bardzo potężne narzędzie robocze, w dodatku nasza konsola jest nadal bardzo zwinna w porównaniu do profesjonalnych - i to jest bardzo duży plus dla programistów! I oczywiście teraz nasza konsola działa pod dowolnym klientem! Powodzenia w twórczym rozwoju!!!

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

Stale pracuję z moją Query Console i ostatnio natknąłem się na bardzo ciekawe żądanie, w którym tabele tymczasowe nie znajdowały się w pierwszym pakiecie żądań, ale w kolejnych - i tutaj moja konsola trochę się przygnębiła... Miałem aby dokonać kolejnej aktualizacji.

Zatem menedżer tabeli tymczasowej w zapytaniu nie zawsze rozumie, że z nim pracuje)) Dlatego musisz jawnie ustawić tego właśnie menedżera tabeli tymczasowej:

Procedura &OnServer ExecuteQueryOnServer() //upgrade2 - jawna definicja menedżera TemporaryTable! VTManager=NewTempTableManager; Żądanie = Nowe żądanie; //upgrade2 - jawna definicja menedżera TemporaryTable! Query.TempTableManager = VTManager; Żądanie.Text = Obiekt.QueryText;

Ta wersja konsoli jest w trzecim rozruchu.