dom Okna

Zagnieżdżone zapytania w konstruktorze. Konstruktory zapytań 1c Warunki konstruktora zapytań

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

Możemy od razu dodać tabelę w „Danych” dla przyszłych parametrów, które będą nam potrzebne, dzięki czemu w naszej Konsoli uruchomimy nie najprymitywniejsze żądanie, ale z parametrami i linkami np. do naszej pracy utworzymy żądanie do rejestrów okresowych , ale tutaj bez instrukcji dotyczących parametrów=&Data nigdzie.

Aby utworzyć naszą tabelę Parametry, w zakładce „Dane” w jej „części tabelarycznej” dodamy nową tabelę, nazwijmy ją Query Parameters, tutaj dodamy kolumny tej tabeli: 1) ParametrNazwa, wpisz ciąg = 25 znaków; ParameterValue, tutaj jest złożony typ danych, patrz ryc.:

Dlatego, jak pokazano na obrazku, wybieramy typ złożony dla kolumny Wartość parametru: w menu typu, 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 zaznacz dolny checkbox – AnyLink – oznacza to co następuje: podają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 obróbce przechodzimy do zakładki „Formy” i dodajemy nowy. Wchodzimy w ten formularz i już mamy nieograniczone pole do popisu – dwa stworzone przed chwilą detale i płytkę z parametrami możesz dowolnie aranżować! Aby to zrobić, możesz użyć standardowych elementów formularza, takich jak Grupa lub Strona ze stronami (jeśli wolisz przewracać strony.

Najważniejsze tutaj jest jedno: po przeciągnięciu atrybutu „TextValues” do lewego pola w celu edycji formularza, pamiętaj o ustawieniu w jego właściwościach „Widok”=Pole dokumentu tekstowego. Patrz rysunek:

We właściwościach atrybutu „Tabela zapytań” możesz opcjonalnie określić „Wyświetl siatkę” i „Wyświetl nagłówki”.

Następnie w prawym oknie edycji formularza przejdź do zakładki „Komendy” i dodaj nowy przycisk, po kliknięciu nasza Konsola wykona określoną akcję. Stwórzmy przycisk „Query Designer”, jeśli chcesz, możesz dodać ikonę do przycisku, najważniejsze jest umieszczenie samego przycisku w lewym oknie edycji formularza - abyśmy mogli go zobaczyć. Następnie w odpowiedniej formie w oknie edycji kliknij prawym przyciskiem myszy na nasz przycisk i wybierz właściwości – we właściwościach kliknij pozycję „Akcja”, pojawi się modalne okno z pytaniem, gdzie dokładnie zostanie wykonany kod naszego programu, który przypiszemy do przycisku – wybierz „ Na kliencie”.

Otworzy się moduł formularza z gotową, pustą procedurą „Konstruktor zapytania o procedurę (polecenie)”. Wewnątrz tej procedury opiszemy wywołanie standardowego Konstruktora zapytań 1c8. To bardzo łatwe: Konstruktor = Nowy konstruktor żądania; 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, w oparciu o Twoją platformę, czy masz zwykłe formularze, to wybierz „ Aplikacja FatClientRegular” lub masz platformę opartą na zarządzanych formularzach, 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 szczegółach naszego formularza „Tekst żądania”:

Jeśli Constructor.OpenModal()=True, to Object.RequestText=Constructor.Text; koniecJeśli;

Możemy jednak ręcznie zmienić coś w tekście żądania (w trybie użytkownika - w oknie atrybutu „Tekst żądania”), aby nasze zmiany trafiły do Konstruktora zapytań przy jego ponownym wywołaniu - dodamy 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 – Rozpocznij debugowanie – 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 1cEnterprise8, znajdujemy nasze przetwarzanie, uruchamiamy je, klikamy nasz przycisk „Projektant zapytań” i widzimy, jak otwiera się projektant wbudowany w platformę. patrz rys.

Mamy więc uruchomiony Konstruktor zapytań i możemy zacząć w nim składać nasze przyszłe zapytanie, ale jesteśmy ciekawi, jak sprawdzi się utworzone przez nas zapytanie! A żeby to zrobić musimy utworzyć w konfiguratorze kolejny przycisk podczas edycji formularza naszej konsoli, nazwijmy go „Uruchom zapytanie”. We właściwościach przycisku „Uruchom zapytanie” kliknij „Akcja”, ponownie pojawi się menu, w którym zostaniemy zapytani, gdzie będzie przetwarzany kod naszego programu, w tym przypadku wybieramy „Zarówno na kliencie, jak i na serwerze”, ponownie znajdujemy się w module Formularze.

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

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

System automatycznie wygenerował już link do procedury Execute RequestOnServer(); – OK, przejdźmy do tej procedury, która jest wykonywana na serwerze i napisz tutaj kod realizujący nasze wprowadzone żądanie.

Możliwości są tutaj: Możesz sam napisać wszystkie wyrażenia związane z budowaniem zapytań, czyli tzw. ręcznie, ale istnieje jeszcze prostsza opcja - w obrębie procedury kliknij prawym przyciskiem myszy i z rozwijanego menu wybierz „Kreator zapytań z przetwarzaniem wyników, patrz rysunek”:

Jeśli kliknąłeś na pozycję „Kreator zapytań z przetwarzaniem wyników”, pojawi się okno modalne „Nie znaleziono tekstu zapytania. Utworzyć nowe?”, kliknij tak. Otworzy się wbudowany projektant zapytań, w którym na pierwszej karcie „Przetwarzanie wyniku” - wybierz pierwszą pozycję „Pomijanie wyniku”. To wszystko, nie potrzebujemy niczego więcej od tego konstruktora, kliknij przycisk „Ok” - pojawi się okno modalne „W żądaniu nie wybrano żadnych pól, kliknij „Ok”.

Następnie w naszej procedurze ExecuteRequestOnServer() pojawi się następujący gotowy szablon:

Przejdźmy do wyrażenia skonstruowanego przez konstruktora:

Żądanie.Text = "";

Request.Text = Obiekt.RequestText;

Jakie to proste, nasz przycisk „Wykonaj żądanie” na formularzu przetwarzania jest już praktycznie funkcjonalny, na razie może przetwarzać tylko proste żądania bez parametrów, ale najważniejsze, że działa! Pozostaje tylko wizualnie wyświetlić wyniki naszego żądania w atrybucie „Tabela wartości” na formularzu przetwarzania. Przypominam, że nasz atrybut „Tabela wartości” jest typu „Dokument tabelaryczny”, gdyż w przeciwnym razie w trybie użytkownika nie zobaczymy naszych wyników. Wyświetlanie danych tabelarycznych użytkownikowi zawsze odbywa się albo za pomocą dokumentu tabelarycznego, albo układu.Bardzo chciałbym, aby możliwe było wyświetlanie danych poprzez tabelę wartości - ponieważ jest ona bardzo łatwa w użyciu i znajoma, 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 obszaru do jednej konkretnej komórki:

Ustaliliśmy więc, czym jest dokument arkusza kalkulacyjnego i sami ustaliliśmy, że będziemy musieli zdefiniować dane z naszego zapytania w określonej komórce tego dokumentu arkusza kalkulacyjnego. Ale zastanówmy się: jaki jest „Wynik zapytania”, który tak szybko wygenerował dla nas projektant? Otwórz pomoc - Wynikiem zapytania jest tabela posiadająca odpowiednie właściwości! patrz rys.

A jeśli teraz napiszemy po wyrażeniu Query Result = Query.Execute(); (utworzonym przez konstruktora), to oto taki prosty cykl dla Kolekcji:

Dla każdego ColumnName From Query Result.Columns Loop report(ColumnName.Name); Koniec cyklu;

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

Na dole okna komunikatu zobaczysz, że tabela Query Result 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 zapytania Result.Columns Loop Cell=Object.QueryTable.Area(1,QueryResult.Columns.Index(NazwaKolumny)+1); Cell.Text=NazwaKolumny.Nazwa; Koniec cyklu;

Aby wyświetlić szczegóły danych zapytania, przeanalizujmy wyrażenia utworzone automatycznie przez projektanta i wstawmy do pętli sortującej „SelectionDetailedRecords” samego zapytania dokładnie tę samą pętlę, której używaliśmy do wyświetlania nazw kolumn, tylko teraz musimy przenieść a nie dane z tabeli „Wynik zapytania” do tekstu komórki, a dane samej selekcji, zobaczmy w pomocy, jak uzyskać dostęp do pola Szczegółowy wybór żądania:

SelectionDetailRecords = QueryResult.Select(); Podczas gdy SelectionDetailedRecords.Next() Loop //w pierwszej linii mamy już zapisane nazwy kolumn tabeli, zatem wczytujemy dane poniżej pierwszej liniiDocRowNumber=Object.QueryTable.TableHeight+1; Dla każdej nazwy kolumny z zapytania Result.Columns Cycle Cell=Object.QueryTable.Area(DocRowNumber,QueryResult.Columns.Index(NazwaKolumny)+1); Cell.Text = SelectionDetailedRecords[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 zapytanie”, patrz rysunek:

Hurra, wszystko działa!!!

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

To wszystko, nasza konsola działa. Abyśmy mogli pisać bardziej złożone zapytania z określonymi w nich parametrami, musimy stworzyć kolejny przycisk „Znajdź parametry”, a także kod przycisku „Uruchom zapytanie” - zostanie wykonany kod przycisku „Znajdź parametry” na kliencie i na serwerze. Następnie w procedurze serwera uruchamiamy żądanie w ten sam sposób z tekstem przekazanym do niego z okna „Request Text”, korzystając z wyrażenia „Request.FindParameters()” odnajdujemy przekazane parametry i po prostu wpisujemy je w pętli do tabelarycznej części formularza „Parametry żądania”. Nie zapomnij następnie przenieść ich z wypełnionej tabeli parametrów do procedury „Uruchom zapytanie”.

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

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

To przetwarzanie jest napisane na platformie 1c8.3 (formularze zarządzane) i działa pod grubym klientem. Można go także napisać na platformie 1c8.2, zarówno w formie zwykłej, jak i zarządzanej.

Pobrany plik zawiera przykładową właśnie utworzoną przez nas konsolę zapytań.

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

Aktualizacja konsoli zapytań:

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

p.s. Forma i wygląd wbudowanego Konstruktora zapytań jest różna - w zależności od tego, pod jakim klientem uruchomiliśmy naszą Konsolę (ja osobiście bardziej zaznajomiona i wygodna jestem z formą Konstruktora zapytań pod grubym klientem)

&W procedurze klienta Konstruktor zapytań (polecenie) //wywołanie standardowego konstruktora zapytań jest możliwe tylko w przypadku grubego klienta #If ThickClientManagedApplication lub ThickClientNormalApplication then Constructor=Nowy konstruktor zapytań; Jeśli nie jest pustyString(Object.QueryText), to Constructor.Text = Object.QueryText; koniecJeśli; Jeśli Constructor.OpenModal()=True, to Object.RequestText=Constructor.Text; koniecJeśli; // #Else // Report("Wywołanie Konstruktora zapytań jest możliwe tylko w przypadku grubego klienta"); // 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 QueryConstructor(); Jeśli nie jest pustyString(Object.QueryText), to Constructor.Text = Object.QueryText; koniecJeśli; Alert konstruktora = New AlertDescription("RunAfterClosingConstructor", ThisForm); Constructor.Show(Alert konstruktora); # EndIf Koniec procedury &Na procedurze klienta ExecuteAfterClosingConstructor(Result, ConstructorParameters) Eksport //Result=tekst, jeśli Konstruktor został zamknięty za pomocą przycisku OK. Obiekt.RequestText = AbbreviatedLP(Result); //Pracuje!!! Koniec procedury

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

Sam kod oraz procedury mechanizmu przenoszenia do parametrów tabel tymczasowych możecie zobaczyć w drugim załączonym pliku. Jak zacząłem opracowywać własną wersję tabel tymczasowych w parametrach można znaleźć pod tym linkiem https://forum.infostart.ru/forum9/topic183700/

Teraz jak używać konsoli do złożonego zapytania, gdy tabela tymczasowa jest przekazywana do jej parametrów. Na przykład możesz pobrać kod tego żądania;

WYBIERZ dane zewnętrzne.Produkt, dane zewnętrzne.ilość MIEJSCE dane zewnętrzne z &ExternalData AS dane zewnętrzne; /////////////////////////////////////////////// ///////////////////////// SELECT dane zewnętrzne.Produkt, dane zewnętrzne.ilość, ISNULL(pozostała ilość produktu. ilość pozostała, 0) AS Field1, ISNULL(pozostała ProductsRemainings.QuantityRemaining, 0) - externalData.Quantity AS pozostałe z dane zewnętrzne jako dane zewnętrzne LEWY DOŁĄCZ Zarejestruj akumulacje.pozostałe produkty.pozostałe(&data, produkt IN (WYBIERZ dane zewnętrzne.Produkt z danych zewnętrznych jako dane zewnętrzne)) AS pozostałe produktypozostałe oprogramowanie dane zewnętrzne.produkt = pozostały produktpozostały Produkt

Bazując na przykładzie i podobieństwie powyższego kodu zapytania, możesz stworzyć własne złożone zapytanie, uwzględniające Twoje obiekty danych.

Tak więc w kreatorze zapytań utworzyliśmy powyższe zapytanie, zamykając Konstruktor - tekst zapytania trafi do naszego pola konsoli „Tekst zapytania”, kliknij przycisk „Znajdź parametry”, widzimy, że w tabeli Parametry pojawiła się linia = „Dane zewnętrzne”, Typ wartości = „Tabela wartości”, patrz rys. 2.

W tej tabeli Parametrów - wprowadź parametr Data, na przykład dzisiejszą datę, następnie kliknij, aby spróbować edytować nasz parametr tabeli tymczasowej „Dane zewnętrzne”, kliknij pole z „Tabelą wartości” na trzech kropkach - zostanie wyświetlony wybór typów się pojawi, klikamy Wiersz, nasz mechanizm przekieruje nas na stronę w formularzu, gdzie musimy ręcznie wprowadzić tę bardzo tymczasową tabelę.

Zwróćmy uwagę, że w tym przypadku na dole strony „Plany zajęć” w polu „Tymczasowa nazwa tabeli w parametrach” pojawi się nazwa naszej tabeli tymczasowej (jest ona skopiowana z tabeli Parametry).

Jak dotąd na stronie „Tabele czasu” widzimy tylko jedną pustą tabelę - jest to tabela Typy naszej przyszłej tabeli tymczasowej. Za pomocą przycisku „Dodaj” dodamy nazwę szczegółów 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 „Aktualizuj tabelę tymczasową” - i będziemy mieli tutaj drugą tabelę - bezpośrednio wypełnimy ją danymi tabeli tymczasowej za pomocą przycisku „Dodaj”.

To wszystko, możemy jeszcze raz sprawdzić, czy w tabeli parametrów na pierwszej stronie przetwarzania wprowadziliśmy pierwotne dane parametrów zapytania i kliknąć przycisk „Uruchom zapytanie” - wszystko zostanie wyliczone i odpowiednio wybrane za pomocą ograniczenie danych przekazywanych w parametrze naszej tabeli tymczasowej

p.s. Jeżeli pomyliłeś się przy wpisywaniu nazwy szczegółów 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, możemy własnymi rękami stworzyć bardzo potężne narzędzie robocze, w dodatku nasza konsola jest nadal bardzo szybka 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!!!

Przyjrzyjmy się, jak połączyć te dwie tabele według pól Kod produktu za pomocą
konstruktor zapytań (jako przykład podano kod do tworzenia tabel tymczasowych
Nie zrobię tego. Możesz go pobrać z powyższego linku).

Otwórz okno projektanta, przejdź do zakładki „Tabele i pola”, do sekcji
„Stoły” wybierz oba nasze stoły oraz w sekcji „Pola” -
te pola z obu tabel, które chcemy zobaczyć w wyniku zapytania.

Przejdź do zakładki "Znajomości". Dodaj nową linię. W polu Tabela 1
z rozwijanej listy wybierz tabelę z produktami, a w polu Tabela 2 Tabela
z krajami.

Dla Stoły1 Sprawdź pudełko Wszystko. Dla
Stoły2 Nie zaznaczamy tego pola. Oznacza to, że od Stoły1
zostaną wybrane wszystkie rekordy i z Stoły2 tylko te, dla których jest wykonywana
warunek połączenia, czyli przy takiej kombinacji flag otrzymamy
POŁĄCZENIE LEWE. Następnie musisz wypełnić Stan komunikacji.
Tutaj wybieramy pola tabeli z list rozwijanych i znak porównania również z rozwijanych list
lista.

W wyniku tego połączenia otrzymujemy następujący tekst żądania:

WYBIERZ VT_Product.Country Code, VT_Product.Name, VT_Country.Country Z VT_Product AS VT_Product LEFT DOŁĄCZ VT_Country AS VT_Country PRZEZ VT_Product.Product Code = VT_Country.Product Code

Przyjrzyjmy się teraz bliżej niektórym punktom.
Spróbujmy zamienić pole wyboru Wszystko.

Wydawałoby się, że w końcu powinno się udać PRAWO DOŁĄCZ, ale jeśli
Przyjrzyjmy się tekstowi zapytania wygenerowanemu przez konstruktora, zobaczymy, że tabele
zamieniliśmy się miejscami, ale połączenie nadal pozostało:

WYBIERZ VT_Product.Product Code, VT_Product.Name, VT_Country.Country Z VT_Country AS VT_Country LEWO DOŁĄCZ VT_Product AS VT_Product BY VT_Product.Product Code = VT_Country.Product Code

Zobaczmy, co się stanie, jeśli odznaczymy oba pola

W rezultacie otrzymujemy połączenie wewnętrzne.

WYBIERZ VT_Product.Product Code, VT_Product.Name, VT_Country.Country Z VT_Product AS VT_Product WEWNĘTRZNE POŁĄCZENIE VT_Country AS VT_Country BY VT_Product.Product Code = VT_Country.Product Code

Na koniec, jeśli oba pola wyboru są zaznaczone

uzyskujemy pełne połączenie

WYBIERZ VT_Product.Product Code, VT_Product.Name, VT_Country.Country Z VT_Product AS VT_Product PEŁNE POŁĄCZENIE VT_Country AS VT_Country BY VT_Product.Product Code = VT_Country.Product Code

Można określić wiele wierszy na zakładce Znajomości. W tym przypadku kilka
wiersze są połączone według warunku I. Co więcej, linie nie są konieczne
za każdym razem wjeżdżaj ponownie. Można je skopiować za pomocą klucza F9.
W nowej linii zmień tylko warunek połączenia. To znacznie przyspiesza rozwój.
Ponadto w warunku łącza nie jest konieczne używanie wyłącznie predefiniowanych pól z
listy rozwijane. Możesz użyć dowolnego wyrażenia, które spełnia
Język zapytań 1C. Aby to zrobić, musisz zaznaczyć pole bezpłatny
i wprowadź warunek bezpośrednio w polu lub otwórz okno pomocnicze w
gdzie można używać szablonów z funkcjami języka zapytań.

Oczywiście w praktyce istnieją znacznie bardziej złożone zapytania gdzie
kilka tabel z różnymi połączeniami między sobą. Ale w konstruktorze zapytań
można odtworzyć połączenia o dowolnej złożoności.

Projektant zapytań składa się z następujących zakładek:

1. „Tabele i pola” – na zakładce znajdują się trzy hierarchiczne listy:
A. „Baza danych” - zawiera listę wszystkich dostępnych obiektów, do których można wykonać zapytanie. Również przycisk „Wyświetl tabele zmian”, za pomocą którego można uzyskać dostęp do tabel zmian obiektów bezpieczeństwa informacji, jeśli są one zarejestrowane w dowolnym planie wymiany.
B. „Tabele” - lista wybranych tabel, do których zostanie wykonane zapytanie. Również w tym oknie możesz usunąć tabelę, zmienić nazwę lub zastąpić tabelę oraz dodać zapytanie wewnętrzne.

Możesz przypisać parametry do wirtualnych tabel, klikając przycisk „Parametry wirtualnych tabel”:

Zaleca się aktywne wykorzystanie parametrów tabel wirtualnych do selekcji według określonych wymiarów, ponieważ zwiększa to szybkość wykonywania zapytań. W parametrach można używać zmiennych zewnętrznych, których nazwy poprzedzone są znakiem „&”.
C. „Pola” - lista pól wybranych z tabel. Możesz także dodać pola obliczeniowe; w tym celu kliknięcie przycisku „Dodaj” otwiera niestandardowy konstruktor wyrażeń:

Po lewej stronie znajduje się okno z polami dostępnymi w wyrażeniu. Po prawej stronie znajduje się podpowiedź do używanych funkcji. Poniżej znajduje się możliwe do skonstruowania dowolne wyrażenie. W wyrażeniach można używać parametrów zewnętrznych, oznacza się je znakiem „&”, np.: &Period, &StartDate
Należy zachować ostrożność, jeśli w oknie zostanie wpisane długie i złożone wyrażenie, które zawiera mały błąd składniowy, to po kliknięciu przycisku „OK” system wyświetli ostrzeżenie i zamknie okno. Cały wpisany kod zostanie utracony, więc jeśli nie jesteś pewien poprawności wyrażenia, zawsze zapisz zawartość do schowka (Ctrl-C) przed zamknięciem konstruktora.

2. „Relacje” – na zakładce wskazane są powiązania pomiędzy tabelami.

Tabela wskazuje tabele, które mają zostać połączone, relacje między tabelami, które mają zostać połączone oraz stan połączenia. Jeśli warunek połączenia jest złożony, możesz określić określone wyrażenie obliczone i otworzy się niestandardowy konstruktor pola.

3. „Grupowanie” – zakładka wskazuje, które pola są grupowane, a które agregowane (sumowane).

4. Zakładka „Warunki” – zawiera listę warunków nałożonych na żądanie.
W warunkach można także pisać złożone wyrażenia za pomocą prostego konstruktora wyrażeń i zmiennych zewnętrznych:

5. „Zaawansowane”
Dodatkowe parametry narzucone na żądanie

6. „Stowarzyszenia i pseudonimy”
Na tej zakładce możesz przypisywać aliasy do pól, a także zarządzać zapytaniami, które są połączone konstrukcjami „UNITE” lub „UNITE ALL”.

7. „Zamówienie”
W jakiej kolejności będą wyświetlane wyniki zapytania?

Uwaga! Na dole zakładki widać znacznik wyboru „Automatyczne zamówienie”- w aktualnej wersji 1C 8.1 w ACS jest to bezużyteczne, ponadto, gdy pole wyboru jest zaznaczone podczas nagrywania, ACS wyświetla błąd, więc nie należy go używać.

8. „Skład danych”
Zakładka, w której definiuje się pola usługowe dla systemu kontroli dostępu. Pełni mniej więcej tę samą rolę, co zakładka „Kreator raportów” w zwykłym kreatorze raportów.

A. W zakładce „Tabele” - wyszczególnione są tabele użyte w zapytaniu, możesz wskazać, czy tabela ma zostać uwzględniona w zapytaniu poprzez zaznaczenie pola „Wymagane”. Te. jeśli w wyborze nie zostaną uwzględnione żadne pola, wówczas ta tabela w ogóle nie uczestniczy w zapytaniu. Można także określić parametry dla tabel.

W procesie konfiguracji systemu kontroli dostępu określamy dowolne selekcje, następnie wszystkie wartości selekcji zostaną podstawione w parametry wirtualnych tabel, co ponownie pomoże nam zoptymalizować i przyspieszyć zapytanie.
B. W zakładce „Pola” znajdują się pola wraz z ich aliasami, które zostaną dodane do listy pól ACS.
C. „Warunki” – jeśli w ustawieniach ACS określono selekcje, wszystkie wartości selekcji zostaną dodane jako dodatkowe warunki; do warunków można także dodać złożone wyrażenia.

9. „Charakterystyka”
Zakładka, która nie ma odpowiednika w zwykłym konstruktorze formularzy wyjściowych.

Zakładka ta umożliwia rozszerzenie pracy zapytań o charakterystyki. Tabela na zakładce składa się z kilku pól:
A. „Typ wartości” – typ, dla którego zostaną wybrane cechy. Na przykład, jeśli określisz „Directory Link.Nomenclature”, to w zapytaniu zostaną wybrane wszystkie cechy dla nomenklatury.
B. „Źródło” – źródłem właściwości typów charakterystycznych może być zapytanie lub tabela. W tym polu możemy napisać prośbę o wybranie tylko tych nieruchomości, które są nam potrzebne.
C. „Lista cech” – pole, w którym wskazane jest źródło właściwości danej cechy. Najczęściej jest to plan typów charakterystycznych lub prośba. Należy także określić pola, które odpowiadają za „Identyfikator”, „Nazwę” i „Typ” właściwości.
D. „Źródło” to kolejne pole, w którym wskazujemy źródło wartości charakterystycznych, którym może być również tabela lub zapytanie.
mi. „Wartość charakterystyczna” to tabela lub zapytanie, które otrzymuje wartości charakterystyczne. Na przykład rejestr informacyjny „ObjectPropertyValues” może służyć jako tabela wartości charakterystyk. Musimy także wskazać te pola z tabeli (lub zapytania), które odpowiadają za „Obiekt”, „Właściwość” i „Wartość” cechy.
Po edycji żądania treść żądania widoczna jest w oknie pod listą pól. Poniżej za pomocą checkboxa „Autouzupełnianie” możemy regulować uzupełnienie dodatkowych parametrów dla pól wskazanych w zgłoszeniu. Należy pamiętać, że skład pól jest określony wyłącznie w samym żądaniu.

Informacje zaczerpnięte ze strony

Dzisiaj porozmawiamy o tym, jak to zrobić zagnieżdżone zapytania za pomocą konstruktor zapytań. Przejdźmy od razu do przykładu.

Załóżmy, że mamy prosty rejestr informacji, w którym przechowywane są ceny towarów i dostawców:

Chcemy poprosić o odbiór wszystkich produktów, które mają więcej niż jednego dostawcę. Można to zaimplementować za pomocą następującego zapytania:

WYBIERZ liczbę dostawców.Produkt JAKO produkt Z (WYBIERZ cenę.Produkt JAKO produkt, ILOŚĆ(RÓŻNA cena.Dostawca) AS Dostawcy Z Rejestr informacji.Cena AS Cena GRUPA WG Ceny.Produkt) AS Liczba dostawców GDZIE Liczba dostawców.Dostawcy > 1

Tworzenie zagnieżdżonego zapytania w konstruktorze

Utwórzmy powyższe żądanie za pomocą konstruktora.

W tym celu w panelu poleceń nad polem Stoły naciśnij przycisk Utwórz podzapytanie:

Po czym otworzy się okno z inną instancją konstruktora zapytań:

W tym nowym oknie konstruujemy zagnieżdżone zapytanie:

Kliknięcie przycisku Wniosek W lewym dolnym rogu widzimy tekst podzapytania:

Po kliknięciu przycisku OK w konstruktorze pomocniczym w oknie głównym otrzymamy następujący obrazek:

Od frazy Zagnieżdżone zapytanie niezbyt wygodne dla percepcji, użyjmy prawego przycisku myszy, aby zmienić nazwę tabeli na Liczba dostawców, wybierz z niego pole Produkt i na zakładkę Warunki Zapiszmy warunek konieczny:

A po tych wszystkich manipulacjach otrzymujemy upragnioną prośbę. W razie potrzeby możesz tworzyć zapytania z kilkoma poziomami zagnieżdżenia.

Jak utworzyć zagnieżdżone zapytanie ze zwykłego zapytania w konstruktorze

Bardzo często zdarza się sytuacja, gdy zaczynasz składać żądanie w konstruktorze i w pewnym momencie zdajesz sobie sprawę, że trzeba je zagnieżdżać. Oczywiście w naszym przykładzie nie ma problemu - możesz po prostu wszystko usunąć i ponownie wystawić żądanie. Ale w praktyce istnieją znacznie bardziej złożone przykłady, na przykład z kilkoma poziomami zagnieżdżenia, gdy na złożenie wniosku spędziliśmy kilka godzin. I w tym przypadku istnieje dość proste wyjście. Możesz użyć edytora tekstu zapytań wbudowanego w projektanta. Trzeba użyć przycisku Wniosek pobierz tekst żądania (patrz obrazek powyżej) i skopiuj go do schowka. Następnie utwórz nowe zagnieżdżone zapytanie i ponownie naciśnij przycisk Wniosek, wklej tekst z bufora i kliknij OK. W związku z tym usuwamy stare żądanie na najwyższym poziomie. W ten sposób, jeśli zajdzie taka potrzeba, możemy łatwo i na bieżąco tworzyć wielopoziomowe zapytania zagnieżdżone.

Możliwość „ręcznego” pisania tekstu zapytania nigdy nie była „zbędna”, ale wygodniej jest skorzystać z projektanta zapytań.

Komentarz.

Niestety w aplikacji zarządzanej nie można używać projektanta zapytań w przetwarzaniu „Poznaj z zapytaniem”. Możesz go użyć w tym przetwarzaniu, przechodząc do trybu normalnego, ale nie zrobimy tego.

Stwórzmy przetwarzanie „Konstruktor żądań” i zdefiniujmy je w podsystemie „Raporty i przetwarzanie”.

Stwórzmy formularz przetwarzający i dodajmy do niego atrybut formularza „TabDoc” typu „Dokument tabelaryczny” oraz komendę „Uruchom zapytanie” z akcją „Uruchom zapytanie”. Następnie przeciągnij je na formularz.

W module formularza, aby polecenie zadziałało, piszemy procedurę:

&Na kliencie

Procedura Wykonaj zapytanie (polecenie)

Wykonaj serwer żądania();

Koniec procedury

&Na serwerze

Koniec procedury

Wchodzimy do procedury wywoływanej na serwerze i z menu kontekstowego wywołujemy „Konstruktor zapytań z przetwarzaniem wyników” (rysunek 2.65).

Rysunek 2.65 Konstruktor zapytań z przetwarzaniem wyników

Ustaw typ przetwarzania na „Wyjście do dokumentu arkusza kalkulacyjnego” i kliknij przycisk „Dalej” lub zakładkę „Tabele i pola”.

W zakładce „Tabele i pola” projektanta możesz przeglądać aktualnie istniejące w systemie tabele (lewa część nosi tytuł „Baza danych”) (rysunek 2.66).

Rysunek 2.67 Konstruktor zapytań

Tabele, z których zapytanie pobierze dane, przenoszone są do obszaru „Tabele”, natomiast pola wymagane przez zapytanie do obszaru „Pola”. Zróbmy to jak na rysunku 2.68.

Rys. 2.68 Konstruktor zapytań

Tutaj usunęliśmy utworzone domyślne pole widoku - „PREPRESENTACJA (Product ReceiptProducts.Nomenclature)”

W dowolnym momencie pracy z projektantem możesz zobaczyć wynikowy tekst żądania. Aby wykonać to zadanie, należy kliknąć przycisk „Zapytanie” znajdujący się w lewym dolnym rogu formularza projektanta (rysunek 2.69).

Możesz ręcznie edytować tekst żądania, klikając przycisk „Edytuj”.

Ćwiczyć. Kliknij przycisk „OK” i sprawdź nasze przetwarzanie w trybie użytkownika. Jeśli przeanalizujesz dane otrzymane podczas realizacji żądania, możesz znaleźć „powtórzenia” pozycji towaru (jeśli to nie zadziała, możesz skopiować i opublikować dowolny dokument „Odbioru towaru”).

Wracamy do procedury ExecuteRequestServer() w przetwarzaniu „Konstruktor zapytań” i z menu kontekstowego ponownie wywołujemy „Konstruktor zapytań z przetwarzaniem wyników”.

Jeśli chcesz „zwinąć” wynik zapytania, możesz w tym celu skorzystać z zakładki „Grupowanie” projektanta zapytań.

Definiując grupowanie należy przestrzegać następującej zasady: wszystkie pola selekcji zapytań dzielone są na pola, według których dokonywane jest grupowanie (splatanie), pola tabel zagnieżdżonych (pola, które są sumowane względem tych, według których przeprowadza się grupowanie) oraz pola agregujące. Funkcje. Zdefiniujmy grupy (rysunek 2.70).

Rysunek 2.70 Konstruktor zapytań

Jeżeli dane otrzymane w ramach żądania muszą zostać wybrane według jakiegoś warunku, wówczas w takim przypadku konieczne może być skorzystanie z zakładki „Warunki”. Wybierzmy Przyjęcie towaru. Ilość=10 (rysunek 2.71).

Rysunek 2.71 Warunek konstruktora zapytania.

Należy pamiętać, że jeśli warunek zostanie zdefiniowany w taki sam sposób jak na rysunku, żądanie nie zostanie wykonane.

Istnieją dwa sposoby naprawienia sytuacji:

Redefiniując warunek poprzez zaznaczenie flagi „P…”;

Korzystając z możliwości zmiany samej treści żądania (uzyskanej po kliknięciu przycisku „Edytuj żądanie”).

Sama ręczna zmiana będzie polegała na konieczności usunięcia znaku „&” przed cyfrą „10”. Ten symbol w tekście żądania określa parametry żądania, do których należy później (ale przed realizacją żądania) wpisać pewne wartości. Kliknij przycisk „Edytuj zapytanie” i dokonaj edycji (rysunek 2.72).

Rysunek 2.73 Edycja zapytania

Na zakładce „Zaawansowane” możesz sprawdzić szereg flag (związanych ze słowem kluczowym „Select” języka zapytań) oraz określić skład tabel przeznaczonych do zmiany zapytania (rysunek 2.74).

Rysunek 2.74 Dodatkowe funkcje zapytań

W zakładce „Dołączenia/Aliasy” możesz zmienić nazwy pól, ustawiając „Aliasy”, ale nie zrobimy tego.

Na zakładce „Kolejność” możesz określić kolejność sortowania rekordów w wyniku zapytania (rysunek 2.75).

Rysunek 2.75 Porządek sortowania rekordów

Zwróć uwagę na flagę „Auto-order”, można jej użyć do zamówienia według pól typu referencyjnego.

Definiując sekcję „Sumy” należy być przygotowanym na to, że w wyniku zapytania pojawią się „dodatkowe” rekordy sumaryczne. Razem z tymi rekordami wynik zapytania staje się hierarchiczny (rysunek 2.76).

Rysunek 2.76. Wyniki konstruktora zapytań.

Możliwe jest określenie kilku typów sum:

Elementy (wybór wyników zapytania zawiera sumy grupujące i rekordy szczegółowe);

Hierarchia (przy wyborze wyników zapytania w ogólnym przypadku wyróżnia się rekordy podsumowujące według hierarchii, rekordy podsumowujące według grupowania i rekordy szczegółowe);

Tylko hierarchia (w wyborze wyników zapytania, ogólnie rzecz biorąc, istnieją rekordy podsumowujące według hierarchii).

Po kliknięciu przycisku „Ok” konstruktora zostanie wygenerowany „Layout” i zapisany w module formularza kod procedury ExecuteRequestServer():

&Na serwerze

Procedura ExecuteRequestServer()

//((QUERY_CONSTRUCTOR_WITH_RESULT_PROCESSING

// Ten fragment jest budowany przez konstruktora.

// Przy ponownym użyciu konstruktora zmiany wprowadzone ręcznie zostaną utracone!!!

Układ = Processing.QueryConstructor.GetLayout("Układ");

Żądanie = Nowe żądanie;

Żądanie.Tekst =

| Odbiór Towaru Nomenklatura AS Nomenklatura,

| SUMA (Odbiór towaru. Ilość) AS Ilość,

| SUMA(Odbiór towaru.Kwota) JAKO Kwota

| Dokument.Odbiór towaru.Towary

| JAK OTRZYMAĆ PRODUKTY

| Odbiór towaru Towar Ilość > 1

|GRUPUJ WG

| Odbiór Towaru.Nomenklatura Towaru

| ZAMÓW PRZEZ

| Ilość,

| ZMNIEJSZENIE KWOTY

| SUMA(ilość),

| SUMA(Suma)

| HIERARCHIA nomenklatury”;

Wynik = Query.Run();

HeaderArea = Układ.GetArea("Nagłówek");

AreaFooter = Układ.GetArea("Stopka");

TableHeadArea = Układ.GetArea("Nagłówek tabeli");

TableFooterArea = Layout.GetArea("TableFooter");

AreaNomenclatureHierarchy = Layout.GetArea("NomenclatureHierarchy");

AreaNomenclature = Layout.GetArea("Nomenklatura");

TabDoc.Wyczyść();

TabDoc.Output(Nagłówek obszaru);

TabDoc.Output(Obszar nagłówka tabeli);

TabDoc.StartAutoGroupingRows();

SelectionNomenclature = Result.Select(BypassQueryResult.ByGrouping);

Podczas gdy SelectionNomenclature.Next() Pętla

Jeśli SelectionNomenclature.RecordType() = RequestRecordType.TotalByHierarchy Wtedy

Powierzchnia = PowierzchniaNomenklaturyHierarchia;

Region = Nomenklatura Regionu;

koniecJeśli;

Area.Parameters.Fill(Nomenklatura wyboru);

TabDoc.Output(Area, SelectionNomenclature.Level());

Koniec cyklu;

TabDoc.FinishAutoGroupingRows();

TabDoc.Output(Obszar tabeli);

TabDoc.Output(AreaFooter);

//))CONSTRUCTOR_QUERY_WITH_RESULT_PROCESSING