🥇Použitie Zabbixu na sledovanie databázy MS SQL Server

Úvod

Často vzniká potreba v reálnom čase informovať administrátora o problémoch súvisiacich s databázou.

V tomto článku bude opísané, čo je potrebné nastaviť v Zabbixe na sledovanie databázy MS SQL Server.

Upozorňujem, že podrobne o tom, ako nastaviť, sa nebude hovoriť, avšak vzorce a všeobecné odporúčania, ako aj podrobný popis pridania používateľských prvkov údajov cez uložené procedúry, budú uvedené v tomto článku.
Taktiež tu budú zvážené len základné ukazovatele výkonu.

Riešenie

Najprv opíšem všetky ukazovatele výkonu (cez prvky údajov v Zabbixe), ktoré potrebujeme:

Logická jednotka
1. Priemerný čas sekúnd/čítanie
  Zobrazuje vyjadrené v sekundách priemerný čas čítania údajov z disku. Priemerná hodnota ukazovateľa výkonu Avg. Disk sec/Read by nemala presiahnuť 10 milisekúnd. Maximálna hodnota ukazovateľa výkonu Avg. Disk sec/Read by nemala presiahnuť 50 milisekúnd.
  Zabbix: perf_counter[LogicalDisk(_Total)Avg. Disk sec/Read], a je dôležité sledovať požadovaný disk, napríklad takto: perf_counter[LogicalDisk(C:)Avg. Disk sec/Read]
  Príklady spúšťačov:
  {NÁZOV_UZLA:perf_counter[LogicalDisk(_Total)Avg. Disk sec/Read].last()}>0.005, úroveň-vysoká
  a
  {NÁZOV_UZLA:perf_counter[LogicalDisk(_Total)Avg. Disk sec/Read].last()}>0.0025, úroveň-stredná
2. Priemerný čas sekúnd/zápis
  Zobrazuje vyjadrené v sekundách priemerný čas zapisovania údajov na disk. Priemerná hodnota ukazovateľa výkonu Avg. Disk sec/Write by nemala presiahnuť 10 milisekúnd. Maximálna hodnota ukazovateľa výkonu Avg. Disk sec/Write by nemala presiahnuť 50 milisekúnd.
  Zabbix: perf_counter[LogicalDisk(_Total)Avg. Disk sec/Write], a je dôležité sledovať požadovaný disk, napríklad takto: perf_counter[LogicalDisk(C:)Avg. Disk sec/Write]
  Príklady spúšťačov:
  {NÁZOV_UZLA:perf_counter[LogicalDisk(_Total)Avg. Disk sec/Write].last()}>0.005, úroveň-vysoká
  a
  {NÁZOV_UZLA:perf_counter[LogicalDisk(_Total)Avg. Disk sec/Write].last()}>0.0025, úroveň-stredná
3. Priemerná dĺžka disku
  Priemerná dĺžka fronty diskových požiadaviek. Zobrazuje počet požiadaviek na disk, ktoré čakajú na spracovanie v priebehu určitého časového intervalu. Normálne sa považuje fronta nie väčšia ako 2 pre jednotlivý disk. Ak je vo fronte viac ako dve požiadavky, môže byť disk preťažený a nestíha spracovávať prichádzajúce požiadavky. Upresniť, s akými presne operáciami si disk nevie poradiť, možno pomocou čítačov Avg. Disk Read Queue Length (fronta požiadaviek na čítanie) a Avg. Disk Write Queue Length (fronta požiadaviek na zápis).
  Hodnota Avg. Disk Queue Length sa nemeria, ale vypočítava sa podľa zákona Littlea z matematickej teórie front. Podľa tohto zákona je počet požiadaviek, ktoré čakajú na spracovanie, v priemere rovný frekvencii prichádzania požiadaviek vynásobenej časom spracovania požiadavky. Tzn. v našom prípade Avg. Disk Queue Length = (Disk Transfers/sec) * (Avg. Disk sec/Transfer).
  Avg. Disk Queue Length je uvedený ako jeden z hlavných čítačov na určenie zaťaženia diskového subsystému, avšak na jeho adekvátne ohodnotenie je potrebné presne si predstavovať fyzickú štruktúru úložného systému. Napríklad, pre jednotlivý pevný disk je kritickou hodnotou viac ako 2, a ak sa disk nachádza v RAID poli zo 4 diskov, je potrebné sa obávať pri hodnote vyššej ako 4*2=8.
  Zabbix: perf_counter[LogicalDisk(_Total)Avg. Disk Queue Length], a taktiež je dôležité sledovať potrebný disk, napríklad takto: perf_counter[LogicalDisk(C:)Avg. Disk Queue Length]
Pamäť
1. Stránky/sec
  Zobrazuje počet stránok, ktoré SQL Server načítal z disku alebo zapísal na disk, aby mohol spracovať požiadavky na pamäťové stránky, ktoré neboli načítané do RAM v čase požiadavky. Táto hodnota je súčtom hodnôt Pages Input/sec a Pages Output/sec a zohľadňuje stránkovanie (swapovanie) systémovej vyrovnávacej pamäte pre prístup k dátovým súborom aplikácií. Okrem toho sa sem započítava aj swapovanie cacheovaných súborov, ktoré sú priamo mapované do pamäte. Toto je hlavný ukazovateľ, na ktorý by ste mali dávať pozor v prípade, že sledujete vysokú záťaž na využívanie pamäte a s tým spojené nadmerné swapovanie stránok. Tento ukazovateľ charakterizuje výšku swapovania a jeho normálna (nepeaková) hodnota by mala byť blízko nuly. Zvýšené swapovanie naznačuje potrebu zvýšiť RAM alebo znížiť počet aplikácií, ktoré sú na serveri vykonávané.
  Zabbix: perf_counter[MemoryPages/sec]
  Príklad spúšťača:
  {Názov uzla:perf_counter[MemoryPages/sec].min(5m)}>1000, úroveň-informácia
2. Page Faults/sec
  Táto hodnota ukazovateľa chýb stránok. Chyba stránky nastáva, keď proces odkazuje na stránku virtuálnej pamäte, ktorá nie je v pracovnej množine RAM. Tento ukazovateľ zohľadňuje ako tie chyby stránok, ktoré si vyžadujú prístup na disk, tak aj tie, ktoré sú spôsobené tým, že stránka je mimo pracovnej množiny v RAM. Väčšina procesorov môže spracovávať chyby stránok druhého typu bez výrazných oneskorení. Avšak spracovanie chýb stránok prvého typu, ktoré vyžaduje prístup na disk, môže viesť k významným oneskoreniam.
  Zabbix: perf_counter[MemoryPage Faults/sec]
  Príklad spúšťača:
  {Názov uzla:perf_counter[MemoryPage Faults/sec].min(5m)}>1000, úroveň-informácia
3. Dostupné bajty
  Sleduje počet dostupnej pamäte v bajtoch na vykonávanie rôznych procesov. Nízke hodnoty naznačujú nedostatok pamäte. Riešením je zvýšiť pamäť. Tento ukazovateľ by mal väčšinou zostať nad 5000 KB.
  Má zmysel nastaviť prah pre Available Mbytes manuálne z dôvodu:
  •50% voľnej pamäte dostupnej = Výborne
  •25% dostupnej pamäte = Vyžaduje pozornosť
  •10% voľnej = Môžu nastať problémy
  •Menej ako 5% dostupnej pamäte = Kritické pre rýchlosť, potrebná intervencia.
  Zabbix: perf_counter[MemoryAvailable Bytes]
Procesor (celkový): % čas procesora
Tento ukazovateľ zobrazuje percentuálny podiel času, počas ktorého bol procesor zaneprázdnený vykonávaním operácií pre nečinné vlákna (non-Idle thread). Túto hodnotu možno považovať za podiel času venovaného vykonávaniu užitočnej práce. Každému procesoru môže byť priradené nečinné vlákno, ktoré spotrebováva neproduktivné cykly procesora, ktoré nie sú využívané inými vláknami. Pre tento ukazovateľ sú charakteristické krátkodobé vrcholy, ktoré môžu dosiahnuť 100 percent. Ak sa však pozorujú dlhšie obdobia, počas ktorých je vyťaženie procesora vyššie ako 80 percent, systém bude efektívnejší pri použití väčšieho počtu procesorov.
Zabbix: perf_counter[Processor(_Total)% Processor Time], tu môže byť zobrazené podľa jadier
Príklad spúšťača:
{NÁZOV_UZLA:perf_counter[Processor(_Total)% Processor Time].min(5m)}>80, úroveň-informácia
Sieťové rozhranie (*): % Bytes Total/sec
Celkový počet prenesených a prijatých bajtov za sekundu cez všetky rozhrania. Ide o priepustnosť rozhrania (v bajtoch). Je potrebné porovnať hodnotu tohto ukazovateľa s maximálnou priepustnosťou sieťovej karty. Všeobecne by tento ukazovateľ nemal ukazovať viac ako 50 % vyťaženosti priepustnosti sieťového adaptéra.
Zabbix: perf_counter[Network Interface(*)Bytes Sent/sec]
MS SQL Server: Metódy prístupu
Objekt Metódy prístupu (Access Methods) v SQL Server poskytuje ukazovatele, ktoré pomáhajú sledovať prístup k logickým údajom v rámci databázy. Fyzický prístup k stránkam databázy na disku je riadený pomocou ukazovateľov správcu vyrovnávacej pamäte. Sledovanie metód prístupu k údajom v databáze pomáha určiť, či je možné zvýšiť výkon dotazov pridaním alebo zmenou indexov, pridaním alebo premiestnením sekcií, pridaním súborov alebo skupín súborov, defragmentáciou indexov alebo zmenou textu dotazov. Okrem toho, pomocou ukazovateľov objektu Metódy prístupu je možné sledovať veľkosť dát, indexov a voľného miesta v databáze, pričom sa kontroluje objem a fragmentácia pre každý inštanciu servera. Nadmerná fragmentácia indexov môže výrazne znížiť výkon.
1. Rozdelenia stránok/sec
  Počet rozdelení stránok za sekundu, ktoré sa vykonali v dôsledku preplnenia stránok indexu. Vysoká hodnota tohto ukazovateľa znamená, že pri vykonávaní operácií vkladania a zmeny údajov musí SQL Server vykonávať veľké množstvo náročných operácií na rozdelenie stránok a presúvanie časti existujúcej stránky na nové miesto. Týmto operáciám by sa malo, ak je to možné, vyhnúť. Problém sa dá pokúsiť vyriešiť dvoma spôsobmi:
  — vytvorením klastrového indexu pre stĺpce s automatickým zvyšovaním. V tomto prípade nové záznamy nebudú umiestnené do stránok, ktoré sú už obsadené údajmi, ale budú postupne zaberať nové stránky;
  — prebudovaním indexov s vyššou hodnotou parametra Fillfactor. Tento parameter umožňuje rezervovať vo stránkach indexov voľné miesto, ktoré bude použité na umiestnenie nových údajov bez toho, aby sa museli vykonávať operácie rozdelenia stránok.
  Zabbix: perf_counter[„MSSQL$NÁZOV_INŠTANCIE:Access MethodsPage Splits/sec“,30]
  Príklad spúšťača: {NÁZOV_UZLA:perf_counter[„MSSQL$NÁZOV_INŠTANCIE:Access MethodsPage Splits/sec“,30].last()}>{NÁZOV_UZLA:perf_counter[„MSSQL$NÁZOV_INŠTANCIE:SQL StatisticsBatch Requests/sec“,30].last()}/5, úroveň-informácia
2. Full Scans/sec
  Počet neobmedzených operácií plného skenovania za sekundu. Medzi tieto operácie patrí skenovanie hlavnej tabuľky a plné skenovanie indexu. Stabilný nárast tohto ukazovateľa môže signalizovať degradáciu systému (nedostatok potrebných indexov, ich silná fragmentácia, nevyužívanie existujúcich indexov optimalizátorom, prítomnosť nevyužívaných indexov). Je však potrebné poznamenať, že plné skenovanie v malých tabuľkách nie je vždy zlé, pretože ak sa podarí celú tabuľku umiestniť do RAM, plné skenovanie bude vykonané rýchlejšie. V drvivej väčšine prípadov však stabilný nárast hodnoty tohoto počítadla bude naznačovať degradáciu systému. Všetko toto platí len pre OLTP systémy. V OLAP systémoch sú neustále plné skenovania normálne.
  Zabbix: perf_counter[„MSSQL$NÁZOV_INŠTANCIE:Access MethodsFull Scans/sec“,30]
MS SQL Server: Buffer Manager
Objekt Buffer Manager (správca vyrovnávacej pamäte) poskytuje počítadlá, ktoré umožňujú sledovať, ako SQL Server využíva nasledujúce zdroje:
— pamäť na uchovávanie dátových stránok;
— číslice slúžiace na monitorovanie fyzického vstupu a výstupu, keď SQL Server číta a zapisuje stránky databáz;
— rozšírenie vyrovnávacej pamäte pre rozšírenie vyrovnávacej pamäte s využitím rýchlej nepamäťovej pamäte, ako sú napríklad SSD;
— monitorovanie pamäte a číselníkov používaných SQL Serverom pomáha získať nasledujúce informácie;
— existujú „úzke miesta“ spôsobené nedostatkom fyzickej pamäte. Ak sa často používané dáta nemôžu uchovať v cache, SQL Server je nútený čítať ich z disku;
— je možné zvýšiť efektívnosť vykonávania dotazov zvýšením objemu pamäte alebo pridelením dodatočnej pamäte na caching dát alebo na ukladanie interných štruktúr SQL Servera;
— ako často SQL Server číta dáta z disku. V porovnaní s inými operáciami, ako je prístup k pamäti, sa fyzický vstup a výstup realizuje pomalšie. Zníženie objemu vstupu a výstupu môže zvýšiť výkon vykonávania dotazov.
1. Buffer Cache hit ratio
  Ukazuje, do akej miery môže SQL Server umiestniť dáta do vyrovnávacej pamäte. Čím vyššia je táto hodnota, tým lepšie, pretože na efektívny prístup SQL servera k stránkam dát musia byť v cache a operácie fyzického vstupu a výstupu (I/O) by nemali chýbať. Ak sa pozoruje trvalé znižovanie priemerného hodnoty tohto číselníka, je potrebné zvážiť pridanie RAM. Tento ukazovateľ by mal vždy byť nad 90 % pre OLTP systémy a nad 50 % pre OLAP systémy.
  Zabbix: perf_counter[„MSSQL$NÁZOV_EXEMPLÁRA:Buffer ManagerBuffer cache hit ratio“,30]
  Príklady spúšťačov: {NÁZOV_ uzla:perf_counter[„MSSQL$NÁZOV_EXEMPLÁRA:Buffer ManagerBuffer cache hit ratio“,30].last()}<70, úroveň-vysoký
  a
  {NÁZOV_ uzla:perf_counter[„MSSQL$NÁZOV_EXEMPLÁRA:Buffer ManagerBuffer cache hit ratio“,30].last()}<80, úroveň-stredný
2. Očakávaná životnosť stránky
  Zobrazuje, ako dlho bude stránka neustále v pamäti v súčasnom stave. Ak hodnota neustále klesá, znamená to, že systém zneužíva vyrovnávaciu pamäť. Potenciálne môže správa pamäte spôsobovať problémy, čo vedie k poklesu výkonu. Je dôležité poznamenať, že neexistuje univerzálny ukazovateľ, pod ktorý by sa dalo jednoznačne usúdiť, že systém zneužíva vyrovnávaciu pamäť (ukazovateľ 300 sekúnd je zastaraný od MS SQL Server 2012).
  Zabbix: perf_counter[„MSSQL$NÁZOV_INŠTANCIE:Buffer ManagerPage life expectancy“,30]
  Príklad spúšťača: {NÁZOV_UZLA:perf_counter[„MSSQL$NÁZOV_INŠTANCIE:Buffer ManagerPage life expectancy“,30].last()}<5, úroveň-informácia
MS SQL Server: Všeobecné štatistiky
Objekt Všeobecné štatistiky (General Statistics) v SQL Server poskytuje počítadlá, ktoré umožňujú sledovať celkovú aktivitu servera, napríklad počet súbežných pripojení a počet používateľov za sekundu, ktorí sa pripájajú alebo odpojili od počítača, na ktorom beží inštancia SQL Server. Tieto ukazovatele sú užitočné v rozsiahlych systémoch spracovania transakcií (OLTP), kde sa veľký počet klientov neustále pripája a odpojuje od inštancie SQL Server.
1. Blokovaný proces
  Počet momentálne blokovaných procesov.
  Zabbix: perf_counter[„MSSQL$NÁZOV_INŠTANCIE:Všeobecné štatistikyBlokované procesy“,30]
  Príklad spúšťača: ({NÁZOV_UZLA:perf_counter[„MSSQL$NÁZOV_INŠTANCIE:Všeobecné štatistikyBlokované procesy“,30].min(2m,0)}>=0)
  a ({NÁZOV_UZLA:perf_counter[„MSSQL$NÁZOV_INŠTANCIE:Všeobecné štatistikyBlokované procesy“,30].time(0)}>=50000)
  a ({NÁZOV_UZLA:perf_counter[„MSSQL$NÁZOV_INŠTANCIE:Všeobecné štatistikyBlokované procesy“,30].time(0)}<=230000), úroveň-informácia (tu ide obmedzenie podľa upozornenia od 05:00 do 23:00)
2. Používateľské pripojenia
  Počet používateľov momentálne pripojených k serveru SQL Server.
  Zabbix: perf_counter[„MSSQL$NÁZOV_INŠTANCIE:Všeobecné štatistikyPoužívateľské pripojenia“,30]
MS SQL Server: Zámky
Objekt Locks (Zamknutia) v Microsoft SQL Server poskytuje informácie o zamknutiach SQL Server, ktoré boli získané pre jednotlivé typy zdrojov. Zamknutia sa vydávajú na také zdroje SQL Server, ako sú čítané alebo zmenené riadky v transakciách, aby sa zabránilo súbežnému používaniu zdrojov viacerými transakciami. Napríklad, ak je výhradné (X) zamknutie získané transakciou na riadok v tabuľke, žiadna iná transakcia nebude môcť zmeniť tento riadok, kým nebude zamknutie uvoľnené. Minimalizácia používania zamknutí zvyšuje paralelizmus, čo môže zlepšiť celkový výkon. Môže byť sledovaných viacero inštancií objektu Locks, z ktorých každá predstavuje zamknutie samostatného typu zdroja.
1. Priemerný čas čakania (ms)
  Priemerný čas čakania (v milisekundách) pre všetky požiadavky na zamknutie, pri ktorých bolo potrebné čakať. Tento čítač ukazuje, koľko priemerne procesom používateľov trvá, kým sa dostanú do fronty, aby mohli naniesť zamknutie na zdroj. Maximálna prijateľná hodnota tohto čítača závisí úplne od vašej úlohy, nejaké priemerné hodnoty pre všetky aplikácie je ťažké tu určiť. Príliš vysoká hodnota tohto čítača môže naznačovať problémy so zamknutiami vo vašej databáze.
  Zabbix: perf_counter[„MSSQL$NÁZOV_INŠTANCIE:Locks(_Total)Priemerný čas čakania (ms)“,30]
  Príklad spúšťača: {NÁZOV_UZLA:perf_counter[„MSSQL$NÁZOV_INŠTANCIE:Locks(_Total)Priemerný čas čakania (ms)“,30].last()}>=500, úroveň-informácia
2. Čas čakania na zamknutie (ms)
  Celkový čas čakania na zamknutia (v milisekundách) za poslednú sekundu.
  Zabbix: perf_counter[„MSSQL$NÁZOV_INŠTANCIE:Locks(_Total)Čas čakania na zamknutie (ms)“,30]
3. Požiadavky na zamknutie\/s
  Počet prípadov za poslednú sekundu, keď musel proces čakať kvôli požiadavke na zamknutie.
  Zabbix: perf_counter[„MSSQL$NÁZOV_INŠTANCIE:Locks(_Total)Požiadavky na zamknutie\/s“,30]
4. Časové obmedzenia zamknutia\/s
  Počet opakovaní, keď sa nepodarilo získať zamknutie prostredníctvom cyklického volania. Hodnota konfiguračného parametra SQL Server spin counter určuje, koľko 'otočení' procesora (spins) sa vykoná, skôr než vyprší časový limit a procesor prejde do neaktívneho stavu.
  Zabbix: perf_counter[„MSSQL$NÁZOV_INŠTANCIE:Locks(_Total)Časové obmedzenia zamknutia\/s“,30]
  Príklad spúšťača: {NÁZOV_UZLA:perf_counter[„MSSQL$NÁZOV_INŠTANCIE:Locks(_Total)Locks(_Total)Časové obmedzenia zamknutia\/s“,30].last()} >1000, úroveň-informácia
5. Požiadavky na zamknutie\/s
  Počet požiadaviek za sekundu na daný typ zablokovania.
  Zabbix: perf_counter[„MSSQL$NÁZOV_EXEMPLÁRA:Locks(_Total)Lock Requests/sec“,30]
  Príklad spúšťača: {NÁZOV_UZLA:perf_counter[„MSSQL$NÁZOV_EXEMPLÁRA:Locks(_Total)Lock Requests/sec“,30].last()}>500000, úroveň-informácie
6. Počet zablokovaní za sekundu
  Počet zablokovaní v sekundách vedúcich k vzájomnému zablokovaniu. Prítomnosť vzájomných zablokovaní naznačuje nesprávne zostavené dotazy, ktoré zablokujú zdieľané zdroje.
  Zabbix: perf_counter[„MSSQL$NÁZOV_EXEMPLÁRA:Number of Deadlocks/sec“,30]
  Príklad spúšťača: {NÁZOV_UZLA:perf_counter[„MSSQL$NÁZOV_EXEMPLÁRA:Locks(_Total)Number of Deadlocks/sec“,30].last()}>1, úroveň-vysoká
MS SQL Server: Správa pamäte
Objekt Správa pamäte v Microsoft SQL Server poskytuje počítadlá na monitorovanie využívania pamäte celým serverom. Monitorovanie využívania pamäte celým serverom na vyhodnotenie činností používateľa a využívania zdrojov môže pomôcť identifikovať nedostatky vo výkonnosti. Monitorovanie pamäte používané inštanciou SQL Server môže pomôcť určiť:
— existujú nedostatky v nedostatočnej fyzickej pamäti na uchovávanie často používaných údajov v cache. Ak je pamäť nedostatočná, SQL Server musí načítať údaje z disku;
— môže byť výkonnosť dotazu zlepšená, ak sa pridá pamäť alebo zvýši objem dostupnej pamäte na cacheovanie údajov alebo interných štruktúr SQL Server.
1. Čakanie na udelenie pamäte
  Ukazuje celkový počet procesov, ktoré úspešne získali pamäť pracovnej oblasti. Pri stabilnom poklese ukazovateľa je potrebné zvýšiť RAM.
  Zabbix: perf_counter[„MSSQL$NÁZOV_EXEMPLÁRA:Memory ManagerMemory Grants Outstanding“,30]
2. Čakanie na udelenie pamäte
  Ukazuje celkový počet procesov, ktoré čakajú na udelenie pamäte pracovnej pamäte. Pri stabilnom raste ukazovateľa je potrebné zvýšiť RAM.
  Zabbix: perf_counter[„MSSQL$NÁZOV_EXEMPLÁRA:Memory ManagerMemory Grants Pending“,30]
MS SQL Server: Štatistiky
Objekt Štatistiky v Microsoft SQL Server zabezpečuje fungovanie počítadiel na sledovanie kompilácie a typov požiadaviek, ktoré sú zasielané inštancii SQL Server. Sledovanie počtu kompilácií a opätovných kompilácií požiadaviek a počtu paketov prijatých inštanciou SQL Server poskytuje predstavu o tom, ako rýchlo SQL Server vykonáva požiadavky používateľov a ako efektívne ich spracúva optimalizátor požiadaviek.
1. Požiadavky na dávku za sekundu
  Počet príkazových paketov Transact-SQL prijatých za sekundu. Na túto štatistiku vplývajú akékoľvek obmedzenia (vstup/výstup, počet používateľov, veľkosť cache, zložitosti dotazov a pod.). Vysoký počet príkazových paketov naznačuje vysokú priepustnosť.
  Zabbix: perf_counter[„MSSQL$NÁZOV_EXEMPLÁRA:SQL StatisticsBatch Requests/sec“,30]

Okrem vyššie uvedeného je možné nastaviť aj ďalšie prvky údajov (a vytvoriť na nich spúšťače s následným upozornením). Napríklad:
1) veľkosť voľného miesta na disku
2) veľkosti databázových súborov a súboru protokolu
a pod.
Avšak, všetky tieto ukazovatele neukazujú problém s dotazmi v reálnom čase.
Na to je potrebné vytvoriť svoje špeciálne počítadlá.
Z dôvodov ochrany osobných údajov nebudem uvádzať príklady takýchto počítadiel. O to viac, že sa nastavujú jedinečne pre každý systém. Ale zdôrazním, že pre systémy ako 1C, NAV a CRM je možné vytvoriť špecializované počítadlá spolu s príslušnými vývojármi.
Uvediem príklad vytvorenia zjednodušeného ukazovateľa, ktorý ukazuje, koľko dotazov sa vykonáva a koľko dotazov čaká na vykonanie (pozastavené alebo zablokované) v každom momente.
Na to je potrebné vytvoriť uloženú procedúru:
Kód

USE [NÁZOV_BAZY_DÁT]
GO

SET ANSI_NULLS ON
GO

SET QUOTED_IDENTIFIER ON
GO

CREATE PROCEDURE [nav].[ZabbixGetCountRequestStatus]
	@Status nvarchar(255)
AS
BEGIN
	
	/*
		vracia počet dotazov s daným stavom
	*/
	SET NOCOUNT ON;

	select count(*) as [Count]
	from sys.dm_exec_requests ER with(readuncommitted)
	where [status]=@Status
END

Ďalej je potrebné ísť do složky, kde sa nachádza Zabbix (zabbixconfuserparams.d) a vytvoriť 2 súbory s príponou ps1 (PowerShell) a napísať v každom z nich nasledujúce kódy:
Kód pre vykonávajúce sa dotazy

$SQLServer = "NÁZOV_EXEMPLÁRA";
$uid = "PRIHLÁSENIE"; 
$pwd = "HESLO";
$Status="running";

$connectionString = "Server = $SQLServer; Database=NÁZOV_DB; Integrated Security = False; User ID = $uid; Password = $pwd;";

$connection = New-Object System.Data.SqlClient.SqlConnection;
$connection.ConnectionString = $connectionString;

#Vytvárame požiadavku priamo na MSSQL
$SqlCmd = New-Object System.Data.SqlClient.SqlCommand;
$SqlCmd.CommandType = [System.Data.CommandType]::StoredProcedure;  
$SqlCmd.CommandText = "nav.ZabbixGetCountRequestStatus";
$SqlCmd.Connection = $Connection;

$paramStatus=$SqlCmd.Parameters.Add("@Status" , [System.Data.SqlDbType]::VarChar);
$paramStatus.Value = $Status;

$connection.Open();
$SqlAdapter = New-Object System.Data.SqlClient.SqlDataAdapter;
$SqlAdapter.SelectCommand = $SqlCmd;
$DataSet = New-Object System.Data.DataSet;
$SqlAdapter.Fill($DataSet) > $null;
$connection.Close();

$result = $DataSet.Tables[0].Rows[0]["Count"];

write-host $result;

Kód pre čakajúce požiadavky

$SQLServer = "NÁZOV_EXEMPLÁRA";
$uid = "PRIHLÁSENIE"; 
$pwd = "HESLO";
$Status="suspended";

$connectionString = "Server = $SQLServer; Database=NÁZOV_DB; Integrated Security = False; User ID = $uid; Password = $pwd;";

$connection = New-Object System.Data.SqlClient.SqlConnection;
$connection.ConnectionString = $connectionString;

#Vytvárame požiadavku priamo na MSSQL
$SqlCmd = New-Object System.Data.SqlClient.SqlCommand;
$SqlCmd.CommandType = [System.Data.CommandType]::StoredProcedure;  
$SqlCmd.CommandText = "nav.ZabbixGetCountRequestStatus";
$SqlCmd.Connection = $Connection;

$paramStatus=$SqlCmd.Parameters.Add("@Status" , [System.Data.SqlDbType]::VarChar);
$paramStatus.Value = $Status;

$connection.Open();
$SqlAdapter = New-Object System.Data.SqlClient.SqlDataAdapter;
$SqlAdapter.SelectCommand = $SqlCmd;
$DataSet = New-Object System.Data.DataSet;
$SqlAdapter.Fill($DataSet) > $null;
$connection.Close();

$result = $DataSet.Tables[0].Rows[0]["Count"];

write-host $result;

Teraz je potrebné vytvoriť súbor s používateľskými parametrami a príponou .conf (alebo pridať riadky do existujúceho súboru, ak bol predtým vytvorený) a vložiť nasledujúce riadky:
UserParameter=NÁZOV_PARAMETRA_KOLIČEŇ_VYKONÁVANÝCH_POŽIADAVIEK,powershell -NoProfile -ExecutionPolicy Bypass -File PLNÝ_CESTA/zabbixconfuserparams.d/NÁZOV_SÚBORU_PRE_VYKONÁVANÉ_POŽIADAVKY.ps1
UserParameter=NÁZOV_PARAMETRA_KOLIČEŇ_OČAKÁVAJÚCICH_POŽIADAVIEK,powershell -NoProfile -ExecutionPolicy Bypass -File PLNÝ_CESTA/zabbixconfuserparams.d/NÁZOV_SÚBORU_PRE_OČAKÁVAJÚCE_POŽIADAVKY.ps1
Po tom uložte súbor .conf a reštartujte agenta Zabbix.
Následne pridajte do Zabbixu dve nové položky (v tomto prípade názvy a kľúč sú rovnaké):
NÁZOV_PARAMETRA_KOLIČEŇ_VYKONÁVANÝCH_POŽIADAVIEK
NÁZOV_PARAMETRA_KOLIČEŇ_OČAKÁVAJÚCICH_POŽIADAVIEK
Teraz môžete vytvárať grafy a spúšťacie podmienky pre vytvorené používateľské prvky údajov.

Ak počet čakajúcich požiadaviek náhle vzrastie, nasledujúca požiadavka môže zobraziť všetky prebiehajúce a čakajúce požiadavky v danom okamihu s podrobnosťami o tom, odkiaľ a pod akým prihlásením je požiadavka vykonávaná, text a plán požiadavky, ako aj ďalšie podrobnosti:
Kód

/*Активные, готовые к выполнению и ожидающие запросы, а также те, что явно блокируют другие сеансы*/
with tbl0 as (
	select ES.[session_id]
	      ,ER.[blocking_session_id]
		  ,ER.[request_id]
	      ,ER.[start_time]
	      ,ER.[status]
		  ,ES.[status] as [status_session]
	      ,ER.[command]
		  ,ER.[percent_complete]
		  ,DB_Name(coalesce(ER.[database_id], ES.[database_id])) as [DBName]
	      ,(select top(1) [text] from sys.dm_exec_sql_text(ER.[sql_handle])) as [TSQL]
		  ,(select top(1) [objectid] from sys.dm_exec_sql_text(ER.[sql_handle])) as [objectid]
		  ,(select top(1) [query_plan] from sys.dm_exec_query_plan(ER.[plan_handle])) as [QueryPlan]
	      ,ER.[wait_type]
	      ,ES.[login_time]
		  ,ES.[host_name]
		  ,ES.[program_name]
	      ,ER.[wait_time]
	      ,ER.[last_wait_type]
	      ,ER.[wait_resource]
	      ,ER.[open_transaction_count]
	      ,ER.[open_resultset_count]
	      ,ER.[transaction_id]
	      ,ER.[context_info]
	      ,ER.[estimated_completion_time]
	      ,ER.[cpu_time]
	      ,ER.[total_elapsed_time]
	      ,ER.[scheduler_id]
	      ,ER.[task_address]
	      ,ER.[reads]
	      ,ER.[writes]
	      ,ER.[logical_reads]
	      ,ER.[text_size]
	      ,ER.[language]
	      ,ER.[date_format]
	      ,ER.[date_first]
	      ,ER.[quoted_identifier]
	      ,ER.[arithabort]
	      ,ER.[ansi_null_dflt_on]
	      ,ER.[ansi_defaults]
	      ,ER.[ansi_warnings]
	      ,ER.[ansi_padding]
	      ,ER.[ansi_nulls]
	      ,ER.[concat_null_yields_null]
	      ,ER.[transaction_isolation_level]
	      ,ER.[lock_timeout]
	      ,ER.[deadlock_priority]
	      ,ER.[row_count]
	      ,ER.[prev_error]
	      ,ER.[nest_level]
	      ,ER.[granted_query_memory]
	      ,ER.[executing_managed_code]
	      ,ER.[group_id]
	      ,ER.[query_hash]
	      ,ER.[query_plan_hash]
		  ,EC.[most_recent_session_id]
	      ,EC.[connect_time]
	      ,EC.[net_transport]
	      ,EC.[protocol_type]
	      ,EC.[protocol_version]
	      ,EC.[endpoint_id]
	      ,EC.[encrypt_option]
	      ,EC.[auth_scheme]
	      ,EC.[node_affinity]
	      ,EC.[num_reads]
	      ,EC.[num_writes]
	      ,EC.[last_read]
	      ,EC.[last_write]
	      ,EC.[net_packet_size]
	      ,EC.[client_net_address]
	      ,EC.[client_tcp_port]
	      ,EC.[local_net_address]
	      ,EC.[local_tcp_port]
	      ,EC.[parent_connection_id]
	      ,EC.[most_recent_sql_handle]
		  ,ES.[host_process_id]
		  ,ES.[client_version]
		  ,ES.[client_interface_name]
		  ,ES.[security_id]
		  ,ES.[login_name]
		  ,ES.[nt_domain]
		  ,ES.[nt_user_name]
		  ,ES.[memory_usage]
		  ,ES.[total_scheduled_time]
		  ,ES.[last_request_start_time]
		  ,ES.[last_request_end_time]
		  ,ES.[is_user_process]
		  ,ES.[original_security_id]
		  ,ES.[original_login_name]
		  ,ES.[last_successful_logon]
		  ,ES.[last_unsuccessful_logon]
		  ,ES.[unsuccessful_logons]
		  ,ES.[authenticating_database_id]
		  ,ER.[sql_handle]
	      ,ER.[statement_start_offset]
	      ,ER.[statement_end_offset]
	      ,ER.[plan_handle]
		  ,ER.[dop]
	      ,coalesce(ER.[database_id], ES.[database_id]) as [database_id]
	      ,ER.[user_id]
	      ,ER.[connection_id]
	from sys.dm_exec_requests ER with(readuncommitted)
	right join sys.dm_exec_sessions ES with(readuncommitted)
	on ES.session_id = ER.session_id 
	left join sys.dm_exec_connections EC  with(readuncommitted)
	on EC.session_id = ES.session_id
)
, tbl as (
	select [session_id]
	      ,[blocking_session_id]
		  ,[request_id]
	      ,[start_time]
	      ,[status]
		  ,[status_session]
	      ,[command]
		  ,[percent_complete]
		  ,[DBName]
		  ,OBJECT_name([objectid], [database_id]) as [object]
	      ,[TSQL]
		  ,[QueryPlan]
	      ,[wait_type]
	      ,[login_time]
		  ,[host_name]
		  ,[program_name]
	      ,[wait_time]
	      ,[last_wait_type]
	      ,[wait_resource]
	      ,[open_transaction_count]
	      ,[open_resultset_count]
	      ,[transaction_id]
	      ,[context_info]
	      ,[estimated_completion_time]
	      ,[cpu_time]
	      ,[total_elapsed_time]
	      ,[scheduler_id]
	      ,[task_address]
	      ,[reads]
	      ,[writes]
	      ,[logical_reads]
	      ,[text_size]
	      ,[language]
	      ,[date_format]
	      ,[date_first]
	      ,[quoted_identifier]
	      ,[arithabort]
	      ,[ansi_null_dflt_on]
	      ,[ansi_defaults]
	      ,[ansi_warnings]
	      ,[ansi_padding]
	      ,[ansi_nulls]
	      ,[concat_null_yields_null]
	      ,[transaction_isolation_level]
	      ,[lock_timeout]
	      ,[deadlock_priority]
	      ,[row_count]
	      ,[prev_error]
	      ,[nest_level]
	      ,[granted_query_memory]
	      ,[executing_managed_code]
	      ,[group_id]
	      ,[query_hash]
	      ,[query_plan_hash]
		  ,[most_recent_session_id]
	      ,[connect_time]
	      ,[net_transport]
	      ,[protocol_type]
	      ,[protocol_version]
	      ,[endpoint_id]
	      ,[encrypt_option]
	      ,[auth_scheme]
	      ,[node_affinity]
	      ,[num_reads]
	      ,[num_writes]
	      ,[last_read]
	      ,[last_write]
	      ,[net_packet_size]
	      ,[client_net_address]
	      ,[client_tcp_port]
	      ,[local_net_address]
	      ,[local_tcp_port]
	      ,[parent_connection_id]
	      ,[most_recent_sql_handle]
		  ,[host_process_id]
		  ,[client_version]
		  ,[client_interface_name]
		  ,[security_id]
		  ,[login_name]
		  ,[nt_domain]
		  ,[nt_user_name]
		  ,[memory_usage]
		  ,[total_scheduled_time]
		  ,[last_request_start_time]
		  ,[last_request_end_time]
		  ,[is_user_process]
		  ,[original_security_id]
		  ,[original_login_name]
		  ,[last_successful_logon]
		  ,[last_unsuccessful_logon]
		  ,[unsuccessful_logons]
		  ,[authenticating_database_id]
		  ,[sql_handle]
	      ,[statement_start_offset]
	      ,[statement_end_offset]
	      ,[plan_handle]
		  ,[dop]
	      ,[database_id]
	      ,[user_id]
	      ,[connection_id]
	from tbl0
	where [status] in ('suspended', 'running', 'runnable')
)
, tbl_group as (
	select [blocking_session_id]
	from tbl
	where [blocking_session_id]<>0
	group by [blocking_session_id]
)
, tbl_res_rec as (
	select [session_id]
	      ,[blocking_session_id]
		  ,[request_id]
	      ,[start_time]
	      ,[status]
		  ,[status_session]
	      ,[command]
		  ,[percent_complete]
		  ,[DBName]
		  ,[object]
	      ,[TSQL]
		  ,[QueryPlan]
	      ,[wait_type]
	      ,[login_time]
		  ,[host_name]
		  ,[program_name]
	      ,[wait_time]
	      ,[last_wait_type]
	      ,[wait_resource]
	      ,[open_transaction_count]
	      ,[open_resultset_count]
	      ,[transaction_id]
	      ,[context_info]
	      ,[estimated_completion_time]
	      ,[cpu_time]
	      ,[total_elapsed_time]
	      ,[scheduler_id]
	      ,[task_address]
	      ,[reads]
	      ,[writes]
	      ,[logical_reads]
	      ,[text_size]
	      ,[language]
	      ,[date_format]
	      ,[date_first]
	      ,[quoted_identifier]
	      ,[arithabort]
	      ,[ansi_null_dflt_on]
	      ,[ansi_defaults]
	      ,[ansi_warnings]
	      ,[ansi_padding]
	      ,[ansi_nulls]
	      ,[concat_null_yields_null]
	      ,[transaction_isolation_level]
	      ,[lock_timeout]
	      ,[deadlock_priority]
	      ,[row_count]
	      ,[prev_error]
	      ,[nest_level]
	      ,[granted_query_memory]
	      ,[executing_managed_code]
	      ,[group_id]
	      ,[query_hash]
	      ,[query_plan_hash]
		  ,[most_recent_session_id]
	      ,[connect_time]
	      ,[net_transport]
	      ,[protocol_type]
	      ,[protocol_version]
	      ,[endpoint_id]
	      ,[encrypt_option]
	      ,[auth_scheme]
	      ,[node_affinity]
	      ,[num_reads]
	      ,[num_writes]
	      ,[last_read]
	      ,[last_write]
	      ,[net_packet_size]
	      ,[client_net_address]
	      ,[client_tcp_port]
	      ,[local_net_address]
	      ,[local_tcp_port]
	      ,[parent_connection_id]
	      ,[most_recent_sql_handle]
		  ,[host_process_id]
		  ,[client_version]
		  ,[client_interface_name]
		  ,[security_id]
		  ,[login_name]
		  ,[nt_domain]
		  ,[nt_user_name]
		  ,[memory_usage]
		  ,[total_scheduled_time]
		  ,[last_request_start_time]
		  ,[last_request_end_time]
		  ,[is_user_process]
		  ,[original_security_id]
		  ,[original_login_name]
		  ,[last_successful_logon]
		  ,[last_unsuccessful_logon]
		  ,[unsuccessful_logons]
		  ,[authenticating_database_id]
		  ,[sql_handle]
	      ,[statement_start_offset]
	      ,[statement_end_offset]
	      ,[plan_handle]
		  ,[dop]
	      ,[database_id]
	      ,[user_id]
	      ,[connection_id]
		  , 0 as [is_blocking_other_session]
from tbl
union all
select tbl0.[session_id]
	      ,tbl0.[blocking_session_id]
		  ,tbl0.[request_id]
	      ,tbl0.[start_time]
	      ,tbl0.[status]
		  ,tbl0.[status_session]
	      ,tbl0.[command]
		  ,tbl0.[percent_complete]
		  ,tbl0.[DBName]
		  ,OBJECT_name(tbl0.[objectid], tbl0.[database_id]) as [object]
	      ,tbl0.[TSQL]
		  ,tbl0.[QueryPlan]
	      ,tbl0.[wait_type]
	      ,tbl0.[login_time]
		  ,tbl0.[host_name]
		  ,tbl0.[program_name]
	      ,tbl0.[wait_time]
	      ,tbl0.[last_wait_type]
	      ,tbl0.[wait_resource]
	      ,tbl0.[open_transaction_count]
	      ,tbl0.[open_resultset_count]
	      ,tbl0.[transaction_id]
	      ,tbl0.[context_info]
	      ,tbl0.[estimated_completion_time]
	      ,tbl0.[cpu_time]
	      ,tbl0.[total_elapsed_time]
	      ,tbl0.[scheduler_id]
	      ,tbl0.[task_address]
	      ,tbl0.[reads]
	      ,tbl0.[writes]
	      ,tbl0.[logical_reads]
	      ,tbl0.[text_size]
	      ,tbl0.[language]
	      ,tbl0.[date_format]
	      ,tbl0.[date_first]
	      ,tbl0.[quoted_identifier]
	      ,tbl0.[arithabort]
	      ,tbl0.[ansi_null_dflt_on]
	      ,tbl0.[ansi_defaults]
	      ,tbl0.[ansi_warnings]
	      ,tbl0.[ansi_padding]
	      ,tbl0.[ansi_nulls]
	      ,tbl0.[concat_null_yields_null]
	      ,tbl0.[transaction_isolation_level]
	      ,tbl0.[lock_timeout]
	      ,tbl0.[deadlock_priority]
	      ,tbl0.[row_count]
	      ,tbl0.[prev_error]
	      ,tbl0.[nest_level]
	      ,tbl0.[granted_query_memory]
	      ,tbl0.[executing_managed_code]
	      ,tbl0.[group_id]
	      ,tbl0.[query_hash]
	      ,tbl0.[query_plan_hash]
		  ,tbl0.[most_recent_session_id]
	      ,tbl0.[connect_time]
	      ,tbl0.[net_transport]
	      ,tbl0.[protocol_type]
	      ,tbl0.[protocol_version]
	      ,tbl0.[endpoint_id]
	      ,tbl0.[encrypt_option]
	      ,tbl0.[auth_scheme]
	      ,tbl0.[node_affinity]
	      ,tbl0.[num_reads]
	      ,tbl0.[num_writes]
	      ,tbl0.[last_read]
	      ,tbl0.[last_write]
	      ,tbl0.[net_packet_size]
	      ,tbl0.[client_net_address]
	      ,tbl0.[client_tcp_port]
	      ,tbl0.[local_net_address]
	      ,tbl0.[local_tcp_port]
	      ,tbl0.[parent_connection_id]
	      ,tbl0.[most_recent_sql_handle]
		  ,tbl0.[host_process_id]
		  ,tbl0.[client_version]
		  ,tbl0.[client_interface_name]
		  ,tbl0.[security_id]
		  ,tbl0.[login_name]
		  ,tbl0.[nt_domain]
		  ,tbl0.[nt_user_name]
		  ,tbl0.[memory_usage]
		  ,tbl0.[total_scheduled_time]
		  ,tbl0.[last_request_start_time]
		  ,tbl0.[last_request_end_time]
		  ,tbl0.[is_user_process]
		  ,tbl0.[original_security_id]
		  ,tbl0.[original_login_name]
		  ,tbl0.[last_successful_logon]
		  ,tbl0.[last_unsuccessful_logon]
		  ,tbl0.[unsuccessful_logons]
		  ,tbl0.[authenticating_database_id]
		  ,tbl0.[sql_handle]
	      ,tbl0.[statement_start_offset]
	      ,tbl0.[statement_end_offset]
	      ,tbl0.[plan_handle]
		  ,tbl0.[dop]
	      ,tbl0.[database_id]
	      ,tbl0.[user_id]
	      ,tbl0.[connection_id]
		  , 1 as [is_blocking_other_session]
	from tbl_group as tg
	inner join tbl0 on tg.blocking_session_id=tbl0.session_id
)
,tbl_res_rec_g as (
	select [plan_handle],
		   [sql_handle],
		   cast([start_time] as date) as [start_time]
	from tbl_res_rec
	group by [plan_handle],
			 [sql_handle],
			 cast([start_time] as date)
)
,tbl_rec_stat_g as (
	select qs.[plan_handle]
		  ,qs.[sql_handle]
		  --,cast(qs.[last_execution_time] as date)	as [last_execution_time]
		  ,min(qs.[creation_time])					as [creation_time]
		  ,max(qs.[execution_count])				as [execution_count]
		  ,max(qs.[total_worker_time])				as [total_worker_time]
		  ,min(qs.[last_worker_time])				as [min_last_worker_time]
		  ,max(qs.[last_worker_time])				as [max_last_worker_time]
		  ,min(qs.[min_worker_time])				as [min_worker_time]
		  ,max(qs.[max_worker_time])				as [max_worker_time]
		  ,max(qs.[total_physical_reads])			as [total_physical_reads]
		  ,min(qs.[last_physical_reads])			as [min_last_physical_reads]
		  ,max(qs.[last_physical_reads])			as [max_last_physical_reads]
		  ,min(qs.[min_physical_reads])				as [min_physical_reads]
		  ,max(qs.[max_physical_reads])				as [max_physical_reads]
		  ,max(qs.[total_logical_writes])			as [total_logical_writes]
		  ,min(qs.[last_logical_writes])			as [min_last_logical_writes]
		  ,max(qs.[last_logical_writes])			as [max_last_logical_writes]
		  ,min(qs.[min_logical_writes])				as [min_logical_writes]
		  ,max(qs.[max_logical_writes])				as [max_logical_writes]
		  ,max(qs.[total_logical_reads])			as [total_logical_reads]
		  ,min(qs.[last_logical_reads])				as [min_last_logical_reads]
		  ,max(qs.[last_logical_reads])				as [max_last_logical_reads]
		  ,min(qs.[min_logical_reads])				as [min_logical_reads]
		  ,max(qs.[max_logical_reads])				as [max_logical_reads]
		  ,max(qs.[total_clr_time])					as [total_clr_time]
		  ,min(qs.[last_clr_time])					as [min_last_clr_time]
		  ,max(qs.[last_clr_time])					as [max_last_clr_time]
		  ,min(qs.[min_clr_time])					as [min_clr_time]
		  ,max(qs.[max_clr_time])					as [max_clr_time]
		  ,max(qs.[total_elapsed_time])				as [total_elapsed_time]
		  ,min(qs.[last_elapsed_time])				as [min_last_elapsed_time]
		  ,max(qs.[last_elapsed_time])				as [max_last_elapsed_time]
		  ,min(qs.[min_elapsed_time])				as [min_elapsed_time]
		  ,max(qs.[max_elapsed_time])				as [max_elapsed_time]
		  ,max(qs.[total_rows])						as [total_rows]
		  ,min(qs.[last_rows])						as [min_last_rows]
		  ,max(qs.[last_rows])						as [max_last_rows]
		  ,min(qs.[min_rows])						as [min_rows]
		  ,max(qs.[max_rows])						as [max_rows]
		  ,max(qs.[total_dop])						as [total_dop]
		  ,min(qs.[last_dop])						as [min_last_dop]
		  ,max(qs.[last_dop])						as [max_last_dop]
		  ,min(qs.[min_dop])						as [min_dop]
		  ,max(qs.[max_dop])						as [max_dop]
		  ,max(qs.[total_grant_kb])					as [total_grant_kb]
		  ,min(qs.[last_grant_kb])					as [min_last_grant_kb]
		  ,max(qs.[last_grant_kb])					as [max_last_grant_kb]
		  ,min(qs.[min_grant_kb])					as [min_grant_kb]
		  ,max(qs.[max_grant_kb])					as [max_grant_kb]
		  ,max(qs.[total_used_grant_kb])			as [total_used_grant_kb]
		  ,min(qs.[last_used_grant_kb])				as [min_last_used_grant_kb]
		  ,max(qs.[last_used_grant_kb])				as [max_last_used_grant_kb]
		  ,min(qs.[min_used_grant_kb])				as [min_used_grant_kb]
		  ,max(qs.[max_used_grant_kb])				as [max_used_grant_kb]
		  ,max(qs.[total_ideal_grant_kb])			as [total_ideal_grant_kb]
		  ,min(qs.[last_ideal_grant_kb])			as [min_last_ideal_grant_kb]
		  ,max(qs.[last_ideal_grant_kb])			as [max_last_ideal_grant_kb]
		  ,min(qs.[min_ideal_grant_kb])				as [min_ideal_grant_kb]
		  ,max(qs.[max_ideal_grant_kb])				as [max_ideal_grant_kb]
		  ,max(qs.[total_reserved_threads])			as [total_reserved_threads]
		  ,min(qs.[last_reserved_threads])			as [min_last_reserved_threads]
		  ,max(qs.[last_reserved_threads])			as [max_last_reserved_threads]
		  ,min(qs.[min_reserved_threads])			as [min_reserved_threads]
		  ,max(qs.[max_reserved_threads])			as [max_reserved_threads]
		  ,max(qs.[total_used_threads])				as [total_used_threads]
		  ,min(qs.[last_used_threads])				as [min_last_used_threads]
		  ,max(qs.[last_used_threads])				as [max_last_used_threads]
		  ,min(qs.[min_used_threads])				as [min_used_threads]
		  ,max(qs.[max_used_threads])				as [max_used_threads]
	from tbl_res_rec_g as t
	inner join sys.dm_exec_query_stats as qs with(readuncommitted) on t.[plan_handle]=qs.[plan_handle] 
																  and t.[sql_handle]=qs.[sql_handle] 
																  and t.[start_time]=cast(qs.[last_execution_time] as date)
	group by qs.[plan_handle]
			,qs.[sql_handle]
			--,qs.[last_execution_time]
)
select t.[session_id] --Сессия
	      ,t.[blocking_session_id] --Сессия, которая явно блокирует сессию [session_id]
		  ,t.[request_id] --Идентификатор запроса. Уникален в контексте сеанса
	      ,t.[start_time] --Метка времени поступления запроса
		  ,DateDiff(second, t.[start_time], GetDate()) as [date_diffSec] --Сколько в сек прошло времени от момента поступления запроса
	      ,t.[status] --Состояние запроса
		  ,t.[status_session] --Состояние сессии
	      ,t.[command] --Тип выполняемой в данный момент команды
		  , COALESCE(
						CAST(NULLIF(t.[total_elapsed_time] / 1000, 0) as BIGINT)
					   ,CASE WHEN (t.[status_session] <> 'running' and isnull(t.[status], '')  <> 'running') 
								THEN  DATEDIFF(ss,0,getdate() - nullif(t.[last_request_end_time], '1900-01-01T00:00:00.000'))
						END
					) as [total_time, sec] --Время всей работы запроса в сек
		  , CAST(NULLIF((CAST(t.[total_elapsed_time] as BIGINT) - CAST(t.[wait_time] AS BIGINT)) / 1000, 0 ) as bigint) as [work_time, sec] --Время работы запроса в сек без учета времени ожиданий
		  , CASE WHEN (t.[status_session] <> 'running' AND ISNULL(t.[status],'') <> 'running') 
		  			THEN  DATEDIFF(ss,0,getdate() - nullif(t.[last_request_end_time], '1900-01-01T00:00:00.000'))
			END as [sleep_time, sec] --Время сна в сек
		  , NULLIF( CAST((t.[logical_reads] + t.[writes]) * 8 / 1024 as numeric(38,2)), 0) as [IO, MB] --операций чтения и записи в МБ
		  , CASE  t.transaction_isolation_level
			WHEN 0 THEN 'Unspecified'
			WHEN 1 THEN 'ReadUncommited'
			WHEN 2 THEN 'ReadCommited'
			WHEN 3 THEN 'Repetable'
			WHEN 4 THEN 'Serializable'
			WHEN 5 THEN 'Snapshot'
			END as [transaction_isolation_level_desc] --уровень изоляции транзакции (расшифровка)
		  ,t.[percent_complete] --Процент завершения работы для следующих команд
		  ,t.[DBName] --БД
		  ,t.[object] --Объект
		  , SUBSTRING(
						t.[TSQL]
					  , t.[statement_start_offset]/2+1
					  ,	(
							CASE WHEN ((t.[statement_start_offset]<0) OR (t.[statement_end_offset]<0))
									THEN DATALENGTH (t.[TSQL])
								 ELSE t.[statement_end_offset]
							END
							- t.[statement_start_offset]
						)/2 +1
					 ) as [CURRENT_REQUEST] --Текущий выполняемый запрос в пакете
	      ,t.[TSQL] --Запрос всего пакета
		  ,t.[QueryPlan] --План всего пакета
	      ,t.[wait_type] --Если запрос в настоящий момент блокирован, в столбце содержится тип ожидания (sys.dm_os_wait_stats)
	      ,t.[login_time] --Время подключения сеанса
		  ,t.[host_name] --Имя клиентской рабочей станции, указанное в сеансе. Для внутреннего сеанса это значение равно NULL
		  ,t.[program_name] --Имя клиентской программы, которая инициировала сеанс. Для внутреннего сеанса это значение равно NULL
		  ,cast(t.[wait_time]/1000 as decimal(18,3)) as [wait_timeSec] --Если запрос в настоящий момент блокирован, в столбце содержится продолжительность текущего ожидания (в секундах)
	      ,t.[wait_time] --Если запрос в настоящий момент блокирован, в столбце содержится продолжительность текущего ожидания (в миллисекундах)
	      ,t.[last_wait_type] --Если запрос был блокирован ранее, в столбце содержится тип последнего ожидания
	      ,t.[wait_resource] --Если запрос в настоящий момент блокирован, в столбце указан ресурс, освобождения которого ожидает запрос
	      ,t.[open_transaction_count] --Число транзакций, открытых для данного запроса
	      ,t.[open_resultset_count] --Число результирующих наборов, открытых для данного запроса
	      ,t.[transaction_id] --Идентификатор транзакции, в которой выполняется запрос
	      ,t.[context_info] --Значение CONTEXT_INFO сеанса
		  ,cast(t.[estimated_completion_time]/1000 as decimal(18,3)) as [estimated_completion_timeSec] --Только для внутреннего использования. Не допускает значение NULL
	      ,t.[estimated_completion_time] --Только для внутреннего использования. Не допускает значение NULL
		  ,cast(t.[cpu_time]/1000 as decimal(18,3)) as [cpu_timeSec] --Время ЦП (в секундах), затраченное на выполнение запроса
	      ,t.[cpu_time] --Время ЦП (в миллисекундах), затраченное на выполнение запроса
		  ,cast(t.[total_elapsed_time]/1000 as decimal(18,3)) as [total_elapsed_timeSec] --Общее время, истекшее с момента поступления запроса (в секундах)
	      ,t.[total_elapsed_time] --Общее время, истекшее с момента поступления запроса (в миллисекундах)
	      ,t.[scheduler_id] --Идентификатор планировщика, который планирует данный запрос
	      ,t.[task_address] --Адрес блока памяти, выделенного для задачи, связанной с этим запросом
	      ,t.[reads] --Число операций чтения, выполненных данным запросом
	      ,t.[writes] --Число операций записи, выполненных данным запросом
	      ,t.[logical_reads] --Число логических операций чтения, выполненных данным запросом
	      ,t.[text_size] --Установка параметра TEXTSIZE для данного запроса
	      ,t.[language] --Установка языка для данного запроса
	      ,t.[date_format] --Установка параметра DATEFORMAT для данного запроса
	      ,t.[date_first] --Установка параметра DATEFIRST для данного запроса
	      ,t.[quoted_identifier] --1 = Параметр QUOTED_IDENTIFIER для запроса включен (ON). В противном случае — 0
	      ,t.[arithabort] --1 = Параметр ARITHABORT для запроса включен (ON). В противном случае — 0
	      ,t.[ansi_null_dflt_on] --1 = Параметр ANSI_NULL_DFLT_ON для запроса включен (ON). В противном случае — 0
	      ,t.[ansi_defaults] --1 = Параметр ANSI_DEFAULTS для запроса включен (ON). В противном случае — 0
	      ,t.[ansi_warnings] --1 = Параметр ANSI_WARNINGS для запроса включен (ON). В противном случае — 0
	      ,t.[ansi_padding] --1 = Параметр ANSI_PADDING для запроса включен (ON)
	      ,t.[ansi_nulls] --1 = Параметр ANSI_NULLS для запроса включен (ON). В противном случае — 0
	      ,t.[concat_null_yields_null] --1 = Параметр CONCAT_NULL_YIELDS_NULL для запроса включен (ON). В противном случае — 0
	      ,t.[transaction_isolation_level] --Уровень изоляции, с которым создана транзакция для данного запроса
		  ,cast(t.[lock_timeout]/1000 as decimal(18,3)) as [lock_timeoutSec] --Время ожидания блокировки для данного запроса (в секундах)
		  ,t.[lock_timeout] --Время ожидания блокировки для данного запроса (в миллисекундах)
	      ,t.[deadlock_priority] --Значение параметра DEADLOCK_PRIORITY для данного запроса
	      ,t.[row_count] --Число строк, возвращенных клиенту по данному запросу
	      ,t.[prev_error] --Последняя ошибка, происшедшая при выполнении запроса
	      ,t.[nest_level] --Текущий уровень вложенности кода, выполняемого для данного запроса
	      ,t.[granted_query_memory] --Число страниц, выделенных для выполнения поступившего запроса (1 страница-это примерно 8 КБ)
	      ,t.[executing_managed_code] --Указывает, выполняет ли данный запрос в настоящее время код объекта среды CLR (например, процедуры, типа или триггера).
									  --Этот флаг установлен в течение всего времени, когда объект среды CLR находится в стеке, даже когда из среды вызывается код Transact-SQL
	      
		  ,t.[group_id]	--Идентификатор группы рабочей нагрузки, которой принадлежит этот запрос
	      ,t.[query_hash] --Двоичное хэш-значение рассчитывается для запроса и используется для идентификации запросов с аналогичной логикой.
						  --Можно использовать хэш запроса для определения использования статистических ресурсов для запросов, которые отличаются только своими литеральными значениями
	      
		  ,t.[query_plan_hash] --Двоичное хэш-значение рассчитывается для плана выполнения запроса и используется для идентификации аналогичных планов выполнения запросов.
							   --Можно использовать хэш плана запроса для нахождения совокупной стоимости запросов со схожими планами выполнения
		  
		  ,t.[most_recent_session_id] --Представляет собой идентификатор сеанса самого последнего запроса, связанного с данным соединением
	      ,t.[connect_time] --Отметка времени установления соединения
	      ,t.[net_transport] --Содержит описание физического транспортного протокола, используемого данным соединением
	      ,t.[protocol_type] --Указывает тип протокола передачи полезных данных
	      ,t.[protocol_version] --Версия протокола доступа к данным, связанного с данным соединением
	      ,t.[endpoint_id] --Идентификатор, описывающий тип соединения. Этот идентификатор endpoint_id может использоваться для запросов к представлению sys.endpoints
	      ,t.[encrypt_option] --Логическое значение, указывающее, разрешено ли шифрование для данного соединения
	      ,t.[auth_scheme] --Указывает схему проверки подлинности (SQL Server или Windows), используемую с данным соединением
	      ,t.[node_affinity] --Идентифицирует узел памяти, которому соответствует данное соединение
	      ,t.[num_reads] --Число пакетов, принятых посредством данного соединения
	      ,t.[num_writes] --Число пакетов, переданных посредством данного соединения
	      ,t.[last_read] --Отметка времени о последнем полученном пакете данных
	      ,t.[last_write] --Отметка времени о последнем отправленном пакете данных
	      ,t.[net_packet_size] --Размер сетевого пакета, используемый для передачи данных
	      ,t.[client_net_address] --Сетевой адрес удаленного клиента
	      ,t.[client_tcp_port] --Номер порта на клиентском компьютере, который используется при осуществлении соединения
	      ,t.[local_net_address] --IP-адрес сервера, с которым установлено данное соединение. Доступен только для соединений, которые в качестве транспорта данных используют протокол TCP
	      ,t.[local_tcp_port] --TCP-порт сервера, если соединение использует протокол TCP
	      ,t.[parent_connection_id] --Идентифицирует первичное соединение, используемое в сеансе MARS
	      ,t.[most_recent_sql_handle] --Дескриптор последнего запроса SQL, выполненного с помощью данного соединения. Постоянно проводится синхронизация между столбцом most_recent_sql_handle и столбцом most_recent_session_id
		  ,t.[host_process_id] --Идентификатор процесса клиентской программы, которая инициировала сеанс. Для внутреннего сеанса это значение равно NULL
		  ,t.[client_version] --Версия TDS-протокола интерфейса, который используется клиентом для подключения к серверу. Для внутреннего сеанса это значение равно NULL
		  ,t.[client_interface_name] --Имя библиотеки или драйвер, используемый клиентом для обмена данными с сервером. Для внутреннего сеанса это значение равно NULL
		  ,t.[security_id] --Идентификатор безопасности Microsoft Windows, связанный с именем входа
		  ,t.[login_name] --SQL Server Имя входа, под которой выполняется текущий сеанс.
						  --Чтобы узнать первоначальное имя входа, с помощью которого был создан сеанс, см. параметр original_login_name.
						  --Может быть SQL Server проверка подлинности имени входа или имени пользователя домена, прошедшего проверку подлинности Windows
		  
		  ,t.[nt_domain] --Домен Windows для клиента, если во время сеанса применяется проверка подлинности Windows или доверительное соединение.
						 --Для внутренних сеансов и пользователей, не принадлежащих к домену, это значение равно NULL
		  
		  ,t.[nt_user_name] --Имя пользователя Windows для клиента, если во время сеанса используется проверка подлинности Windows или доверительное соединение.
							--Для внутренних сеансов и пользователей, не принадлежащих к домену, это значение равно NULL
		  
		  ,t.[memory_usage] --Количество 8-килобайтовых страниц памяти, используемых данным сеансом
		  ,t.[total_scheduled_time] --Общее время, назначенное данному сеансу (включая его вложенные запросы) для исполнения, в миллисекундах
		  ,t.[last_request_start_time] --Время, когда начался последний запрос данного сеанса. Это может быть запрос, выполняющийся в данный момент
		  ,t.[last_request_end_time] --Время завершения последнего запроса в рамках данного сеанса
		  ,t.[is_user_process] --0, если сеанс является системным. В противном случае значение равно 1
		  ,t.[original_security_id] --Microsoft Идентификатор безопасности Windows, связанный с параметром original_login_name
		  ,t.[original_login_name] --SQL Server Имя входа, которую использует клиент создал данный сеанс.
								   --Это может быть имя входа SQL Server, прошедшее проверку подлинности, имя пользователя домена Windows, 
								   --прошедшее проверку подлинности, или пользователь автономной базы данных.
								   --Обратите внимание, что после первоначального соединения для сеанса может быть выполнено много неявных или явных переключений контекста.
								   --Например если EXECUTE AS используется
		  
		  ,t.[last_successful_logon] --Время последнего успешного входа в систему для имени original_login_name до запуска текущего сеанса
		  ,t.[last_unsuccessful_logon] --Время последнего неуспешного входа в систему для имени original_login_name до запуска текущего сеанса
		  ,t.[unsuccessful_logons] --Число неуспешных попыток входа в систему для имени original_login_name между временем last_successful_logon и временем login_time
		  ,t.[authenticating_database_id] --Идентификатор базы данных, выполняющей проверку подлинности участника.
										  --Для имен входа это значение будет равно 0.
										  --Для пользователей автономной базы данных это значение будет содержать идентификатор автономной базы данных
		  
		  ,t.[sql_handle] --Хэш-карта текста SQL-запроса
	      ,t.[statement_start_offset] --Количество символов в выполняемом в настоящий момент пакете или хранимой процедуре, в которой запущена текущая инструкция.
									  --Может применяться вместе с функциями динамического управления sql_handle, statement_end_offset и sys.dm_exec_sql_text
									  --для извлечения исполняемой в настоящий момент инструкции по запросу
	      
		  ,t.[statement_end_offset] --Количество символов в выполняемом в настоящий момент пакете или хранимой процедуре, в которой завершилась текущая инструкция.
									--Может применяться вместе с функциями динамического управления sql_handle, statement_end_offset и sys.dm_exec_sql_text
									--для извлечения исполняемой в настоящий момент инструкции по запросу
	      
		  ,t.[plan_handle] --Хэш-карта плана выполнения SQL
	      ,t.[database_id] --Идентификатор базы данных, к которой выполняется запрос
	      ,t.[user_id] --Идентификатор пользователя, отправившего данный запрос
	      ,t.[connection_id] --Идентификатор соединения, по которому поступил запрос
		  ,t.[is_blocking_other_session] --1-сессия явно блокирует другие сессии, 0-сессия явно не блокирует другие сессии
		  ,coalesce(t.[dop], mg.[dop]) as [dop] --Степень параллелизма запроса
		  ,mg.[request_time] --Дата и время обращения запроса за предоставлением памяти
		  ,mg.[grant_time] --Дата и время, когда запросу была предоставлена память. Возвращает значение NULL, если память еще не была предоставлена
		  ,mg.[requested_memory_kb] --Общий объем запрошенной памяти в килобайтах
		  ,mg.[granted_memory_kb] --Общий объем фактически предоставленной памяти в килобайтах.
								  --Может быть значение NULL, если память еще не была предоставлена.
								  --Обычно это значение должно быть одинаковым с requested_memory_kb.
								  --Для создания индекса сервер может разрешить дополнительное предоставление по требованию памяти,
								  --объем которой выходит за рамки изначально предоставленной памяти
		  
		  ,mg.[required_memory_kb] --Минимальный объем памяти в килобайтах (КБ), необходимый для выполнения данного запроса.
								   --Значение requested_memory_kb равно этому объему или больше его
		  
		  ,mg.[used_memory_kb] --Используемый в данный момент объем физической памяти (в килобайтах)
		  ,mg.[max_used_memory_kb] --Максимальный объем используемой до данного момента физической памяти в килобайтах
		  ,mg.[query_cost] --Ожидаемая стоимость запроса
		  ,mg.[timeout_sec] --Время ожидания данного запроса в секундах до отказа от обращения за предоставлением памяти
		  ,mg.[resource_semaphore_id] --Неуникальный идентификатор семафора ресурса, которого ожидает данный запрос
		  ,mg.[queue_id] --Идентификатор ожидающей очереди, в которой данный запрос ожидает предоставления памяти.
						 --Значение NULL, если память уже предоставлена
		  
		  ,mg.[wait_order] --Последовательный порядок ожидающих запросов в указанной очереди queue_id.
						   --Это значение может изменяться для заданного запроса, если другие запросы отказываются от предоставления памяти или получают ее.
						   --Значение NULL, если память уже предоставлена
		  
		  ,mg.[is_next_candidate] --Является следующим кандидатом на предоставление памяти (1 = да, 0 = нет, NULL = память уже предоставлена)
		  ,mg.[wait_time_ms] --Время ожидания в миллисекундах. Значение NULL, если память уже предоставлена
		  ,mg.[pool_id] --Идентификатор пула ресурсов, к которому принадлежит данная группа рабочей нагрузки
		  ,mg.[is_small] --Значение 1 означает, что для данной операции предоставления памяти используется малый семафор ресурса.
						 --Значение 0 означает использование обычного семафора
		  
		  ,mg.[ideal_memory_kb] --Объем, в килобайтах (КБ), предоставленной памяти, необходимый для размещения всех данных в физической памяти.
								--Основывается на оценке количества элементов
		  
		  ,mg.[reserved_worker_count] --Число рабочих процессов, зарезервированной с помощью параллельных запросов, а также число основных рабочих процессов, используемых всеми запросами
		  ,mg.[used_worker_count] --Число рабочих процессов, используемых параллельных запросов
		  ,mg.[max_used_worker_count] --???
		  ,mg.[reserved_node_bitmap] --???
		  ,pl.[bucketid] --Идентификатор сегмента хэша, в который кэшируется запись.
						 --Значение указывает диапазон от 0 до значения размера хэш-таблицы для типа кэша.
						 --Для кэшей SQL Plans и Object Plans размер хэш-таблицы может достигать 10007 на 32-разрядных версиях систем и 40009 — на 64-разрядных.
						 --Для кэша Bound Trees размер хэш-таблицы может достигать 1009 на 32-разрядных версиях систем и 4001 на 64-разрядных.
						 --Для кэша расширенных хранимых процедур размер хэш-таблицы может достигать 127 на 32-разрядных и 64-разрядных версиях систем
		  
		  ,pl.[refcounts] --Число объектов кэша, ссылающихся на данный объект кэша.
						  --Значение refcounts для записи должно быть не меньше 1, чтобы размещаться в кэше
		  
		  ,pl.[usecounts] --Количество повторений поиска объекта кэша.
						  --Остается без увеличения, если параметризованные запросы обнаруживают план в кэше.
						  --Может быть увеличен несколько раз при использовании инструкции showplan
		  
		  ,pl.[size_in_bytes] --Число байтов, занимаемых объектом кэша
		  ,pl.[memory_object_address] --Адрес памяти кэшированной записи.
									  --Это значение можно использовать с представлением sys.dm_os_memory_objects,
									  --чтобы проанализировать распределение памяти кэшированного плана, 
									  --и с представлением sys.dm_os_memory_cache_entries для определения затрат на кэширование записи
		  
		  ,pl.[cacheobjtype] --Тип объекта в кэше. Значение может быть одним из следующих
		  ,pl.[objtype] --Тип объекта. Значение может быть одним из следующих
		  ,pl.[parent_plan_handle] --Родительский план
		  
		  --данные из sys.dm_exec_query_stats брались за сутки, в которых была пара (запрос, план)
		  ,qs.[creation_time] --Время компиляции плана
		  ,qs.[execution_count] --Количество выполнений плана с момента последней компиляции
		  ,qs.[total_worker_time] --Общее время ЦП, затраченное на выполнение плана с момента компиляции, в микросекундах (но с точностью до миллисекунды)
		  ,qs.[min_last_worker_time] --Минимальное время ЦП, затраченное на последнее выполнение плана, в микросекундах (но с точностью до миллисекунды)
		  ,qs.[max_last_worker_time] --Максимальное время ЦП, затраченное на последнее выполнение плана, в микросекундах (но с точностью до миллисекунды)
		  ,qs.[min_worker_time] --Минимальное время ЦП, когда-либо затраченное на выполнение плана, в микросекундах (но с точностью до миллисекунды)
		  ,qs.[max_worker_time] --Максимальное время ЦП, когда-либо затраченное на выполнение плана, в микросекундах (но с точностью до миллисекунды)
		  ,qs.[total_physical_reads] --Общее количество операций физического считывания при выполнении плана с момента его компиляции.
									 --Значение всегда равно 0 при запросе оптимизированной для памяти таблицы
		  
		  ,qs.[min_last_physical_reads] --Минимальное количество операций физического считывания за время последнего выполнения плана.
										--Значение всегда равно 0 при запросе оптимизированной для памяти таблицы
		  
		  ,qs.[max_last_physical_reads] --Максимальное количество операций физического считывания за время последнего выполнения плана.
										--Значение всегда равно 0 при запросе оптимизированной для памяти таблицы
		  
		  ,qs.[min_physical_reads] --Минимальное количество операций физического считывания за одно выполнение плана.
								   --Значение всегда равно 0 при запросе оптимизированной для памяти таблицы
		  
		  ,qs.[max_physical_reads] --Максимальное количество операций физического считывания за одно выполнение плана.
								   --Значение всегда равно 0 при запросе оптимизированной для памяти таблицы
		  
		  ,qs.[total_logical_writes] --Общее количество операций логической записи при выполнении плана с момента его компиляции.
									 --Значение всегда равно 0 при запросе оптимизированной для памяти таблицы
		  
		  ,qs.[min_last_logical_writes] --Минимальное количество страниц в буферном пуле, загрязненных во время последнего выполнения плана.
										--Если страница уже является «грязной» (т. е. измененной), операции записи не учитываются.
										--Значение всегда равно 0 при запросе оптимизированной для памяти таблицы
		  
		  ,qs.[max_last_logical_writes] --Максимальное количество страниц в буферном пуле, загрязненных во время последнего выполнения плана.
										--Если страница уже является «грязной» (т. е. измененной), операции записи не учитываются.
										--Значение всегда равно 0 при запросе оптимизированной для памяти таблицы
		  
		  ,qs.[min_logical_writes] --Минимальное количество операций логической записи за одно выполнение плана.
								   --Значение всегда равно 0 при запросе оптимизированной для памяти таблицы
		  
		  ,qs.[max_logical_writes] --Максимальное количество операций логической записи за одно выполнение плана.
								   --Значение всегда равно 0 при запросе оптимизированной для памяти таблицы
		  
		  ,qs.[total_logical_reads] --Общее количество операций логического считывания при выполнении плана с момента его компиляции.
									--Значение всегда равно 0 при запросе оптимизированной для памяти таблицы
		  
		  ,qs.[min_last_logical_reads] --Минимальное количество операций логического считывания за время последнего выполнения плана.
									   --Значение всегда равно 0 при запросе оптимизированной для памяти таблицы
		  
		  ,qs.[max_last_logical_reads] --Максимальное количество операций логического считывания за время последнего выполнения плана.
									   --Значение всегда равно 0 при запросе оптимизированной для памяти таблицы
		  
		  ,qs.[min_logical_reads]	   --Минимальное количество операций логического считывания за одно выполнение плана.
									   --Значение всегда равно 0 при запросе оптимизированной для памяти таблицы
		  
		  ,qs.[max_logical_reads]	--Максимальное количество операций логического считывания за одно выполнение плана.
									--Значение всегда равно 0 при запросе оптимизированной для памяти таблицы
		  
		  ,qs.[total_clr_time]	--Время, в микросекундах (но с точностью до миллисекунды),
								--внутри Microsoft .NET Framework общеязыковая среда выполнения (CLR) объекты при выполнении плана с момента его компиляции.
								--Объекты среды CLR могут быть хранимыми процедурами, функциями, триггерами, типами и статистическими выражениями
		  
		  ,qs.[min_last_clr_time] --Минимальное время, в микросекундах (но с точностью до миллисекунды),
								  --затраченное внутри .NET Framework объекты среды CLR во время последнего выполнения плана.
								  --Объекты среды CLR могут быть хранимыми процедурами, функциями, триггерами, типами и статистическими выражениями
		  
		  ,qs.[max_last_clr_time] --Максимальное время, в микросекундах (но с точностью до миллисекунды),
								  --затраченное внутри .NET Framework объекты среды CLR во время последнего выполнения плана.
								  --Объекты среды CLR могут быть хранимыми процедурами, функциями, триггерами, типами и статистическими выражениями
		  
		  ,qs.[min_clr_time] --Минимальное время, когда-либо затраченное на выполнение плана внутри объектов .NET Framework среды CLR,
							 --в микросекундах (но с точностью до миллисекунды).
							 --Объекты среды CLR могут быть хранимыми процедурами, функциями, триггерами, типами и статистическими выражениями
		  
		  ,qs.[max_clr_time] --Максимальное время, когда-либо затраченное на выполнение плана внутри среды CLR .NET Framework,
							 --в микросекундах (но с точностью до миллисекунды).
							 --Объекты среды CLR могут быть хранимыми процедурами, функциями, триггерами, типами и статистическими выражениями
		  
		  --,qs.[total_elapsed_time] --Общее время, затраченное на выполнение плана, в микросекундах (но с точностью до миллисекунды)
		  ,qs.[min_last_elapsed_time] --Минимальное время, затраченное на последнее выполнение плана, в микросекундах (но с точностью до миллисекунды)
		  ,qs.[max_last_elapsed_time] --Максимальное время, затраченное на последнее выполнение плана, в микросекундах (но с точностью до миллисекунды)
		  ,qs.[min_elapsed_time] --Минимальное время, когда-либо затраченное на выполнение плана, в микросекундах (но с точностью до миллисекунды)
		  ,qs.[max_elapsed_time] --Максимальное время, когда-либо затраченное на выполнение плана, в микросекундах (но с точностью до миллисекунды)
		  ,qs.[total_rows] --Общее число строк, возвращаемых запросом. Не может иметь значение null.
						   --Значение всегда равно 0, если скомпилированная в собственном коде хранимая процедура запрашивает оптимизированную для памяти таблицу
		  
		  ,qs.[min_last_rows] --Минимальное число строк, возвращенных последним выполнением запроса. Не может иметь значение null.
							  --Значение всегда равно 0, если скомпилированная в собственном коде хранимая процедура запрашивает оптимизированную для памяти таблицу
		  
		  ,qs.[max_last_rows] --Максимальное число строк, возвращенных последним выполнением запроса. Не может иметь значение null.
							  --Значение всегда равно 0, если скомпилированная в собственном коде хранимая процедура запрашивает оптимизированную для памяти таблицу
		  
		  ,qs.[min_rows] --Минимальное количество строк, когда-либо возвращенных по запросу во время выполнения один
						 --Значение всегда равно 0, если скомпилированная в собственном коде хранимая процедура запрашивает оптимизированную для памяти таблицу
		  
		  ,qs.[max_rows] --Максимальное число строк, когда-либо возвращенных по запросу во время выполнения один
						 --Значение всегда равно 0, если скомпилированная в собственном коде хранимая процедура запрашивает оптимизированную для памяти таблицу
		  
		  ,qs.[total_dop] --Общую сумму по степени параллелизма плана используется с момента его компиляции.
						  --Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[min_last_dop] --Минимальная степень параллелизма, если время последнего выполнения плана.
							 --Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[max_last_dop] --Максимальная степень параллелизма, если время последнего выполнения плана.
							 --Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[min_dop] --Минимальная степень параллелизма этот план когда-либо используется во время одного выполнения.
						--Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[max_dop] --Максимальная степень параллелизма этот план когда-либо используется во время одного выполнения.
						--Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[total_grant_kb] --Общий объем зарезервированной памяти в КБ предоставить этот план, полученных с момента его компиляции.
							   --Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[min_last_grant_kb] --Минимальный объем зарезервированной памяти предоставляет в КБ, когда время последнего выполнения плана.
								  --Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[max_last_grant_kb] --Максимальный объем зарезервированной памяти предоставляет в КБ, когда время последнего выполнения плана.
								  --Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[min_grant_kb] --Минимальный объем зарезервированной памяти в КБ предоставить никогда не получено в ходе одного выполнения плана.
							 --Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[max_grant_kb] --Максимальный объем зарезервированной памяти в КБ предоставить никогда не получено в ходе одного выполнения плана.
							 --Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[total_used_grant_kb] --Общий объем зарезервированной памяти в КБ предоставить этот план, используемый с момента его компиляции.
									--Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[min_last_used_grant_kb] --Минимальная сумма предоставления используемой памяти в КБ, если время последнего выполнения плана.
									   --Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[max_last_used_grant_kb] --Максимальная сумма предоставления используемой памяти в КБ, если время последнего выполнения плана.
									   --Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[min_used_grant_kb] --Минимальный объем используемой памяти в КБ предоставить никогда не используется при выполнении одного плана.
								  --Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[max_used_grant_kb] --Максимальный объем используемой памяти в КБ предоставить никогда не используется при выполнении одного плана.
								  --Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[total_ideal_grant_kb] --Общий объем идеальный память в КБ, оценка плана с момента его компиляции.
									 --Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[min_last_ideal_grant_kb] --Минимальный объем памяти, идеальным предоставляет в КБ, когда время последнего выполнения плана.
										--Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[max_last_ideal_grant_kb] --Максимальный объем памяти, идеальным предоставляет в КБ, когда время последнего выполнения плана.
										--Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[min_ideal_grant_kb] --Минимальный объем памяти идеальный предоставления в этот план когда-либо оценка во время выполнения один КБ.
								   --Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[max_ideal_grant_kb] --Максимальный объем памяти идеальный предоставления в этот план когда-либо оценка во время выполнения один КБ.
								   --Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[total_reserved_threads] --Общая сумма по зарезервированным параллельного потоков этот план когда-либо использовавшегося с момента его компиляции.
									   --Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[min_last_reserved_threads] --Минимальное число зарезервированных параллельных потоков, когда время последнего выполнения плана.
										  --Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[max_last_reserved_threads] --Максимальное число зарезервированных параллельных потоков, когда время последнего выполнения плана.
										  --Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[min_reserved_threads] --Минимальное число зарезервированных параллельного потоков, когда-либо использовать при выполнении одного плана.
									 --Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[max_reserved_threads] --Максимальное число зарезервированных параллельного потоков никогда не используется при выполнении одного плана.
									 --Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[total_used_threads] --Общая сумма используется параллельных потоков этот план когда-либо использовавшегося с момента его компиляции.
								   --Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[min_last_used_threads] --Минимальное число используемых параллельных потоков, когда время последнего выполнения плана.
									  --Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[max_last_used_threads] --Максимальное число используемых параллельных потоков, когда время последнего выполнения плана.
									  --Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[min_used_threads] --Минимальное число используемых параллельных потоков, при выполнении одного плана использовали.
								 --Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
		  
		  ,qs.[max_used_threads] --Максимальное число используемых параллельных потоков, при выполнении одного плана использовали.
								 --Он всегда будет равно 0 для запроса к таблице, оптимизированной для памяти
from tbl_res_rec as t
left outer join sys.dm_exec_query_memory_grants as mg on t.[plan_handle]=mg.[plan_handle] and t.[sql_handle]=mg.[sql_handle]
left outer join sys.dm_exec_cached_plans as pl on t.[plan_handle]=pl.[plan_handle]
left outer join tbl_rec_stat_g as qs on t.[plan_handle]=qs.[plan_handle] and t.[sql_handle]=qs.[sql_handle] --and qs.[last_execution_time]=cast(t.[start_time] as date);

Takisto pripomínam, že zozbierané štatistiky môžu poskytnúť najnáročnejšie požiadavky:
Kód

/*
creation_time - Время, когда запрос был скомпилирован. Поскольку при старте сервера кэш пустой, данное время всегда больше либо равно моменту запуска сервиса. Если время, указанное в этом столбце позже, чем предполагаемое (первое использование процедуры), это говорит о том, что запрос по тем или иным причинам был рекомпилирован.
last_execution_time - Момент фактического последнего выполнения запроса.
execution_count - Сколько раз запрос был выполнен с момента компиляции
Количество выполнений позволяет найти ошибки в алгоритмах - часто в наиболее выполняемых запросах оказываются те, которые находятся внутри каких-либо циклов однако могут быть выполнены перед самим циклом один раз. Например, получение каких-либо параметров из базы данных, не меняющихся внутри цикла.
CPU - Суммарное время использования процессора в миллисекундах. Если запрос обрабатывается параллельно, то это время может превысить общее время выполнения запроса, поскольку суммируется время использования запроса каждым ядром. Во время использования процессора включается только фактическая нагрузка на ядра, в нее не входят ожидания каких-либо ресурсов.
Очевидно, что данный показатель позволяет выявлять запросы, наиболее сильно загружающие процессор.
AvgCPUTime - Средняя загрузка процессора на один запрос. 
TotDuration - Общее время выполнения запроса, в миллисекундах.
Данный параметр может быть использован для поиска тех запросов, которые, независимо от причины выполняются "наиболее долго". Если общее время выполнения запроса существенно ниже времени CPU (с поправкой на параллелизм) - это говорит о том, что при выполнения запроса были ожидания каких-либо ресурсов. В большинстве случаев это связано с дисковой активностью или блокировками, но также это может быть сетевой интерфейс или другой ресурс. 
Полный список типов ожиданий можно посмотреть в описании представления sys.dm_os_wait_stats.
AvgDur - Среднее время выполнения запроса в миллисекундах.
Reads - Общее количество чтений.
Это пожалуй лучший агрегатный показатель, позволяющий выявить наиболее нагружающие сервер запросы.
Логическое чтение - это разовое обращение к странице данных, физические чтения не учитываются.
В рамках выполнения одного запроса, могут происходить неоднократные обращения к одной и той же странице.
Чем больше обращений к страницам, тем больше требуется дисковых чтений, памяти и, если речь идет о повторных обращениях, большее время требуется удерживать страницы в памяти.
Writes - Общее количество изменений страниц данных.
Характеризует то, как запрос "нагружает" дисковую систему операциями записи.
Следует помнить, что этот показатель может быть больше 0 не только у тех запросов, которые явно меняют данные, но также и у тех, которые сохраняют промежуточные данные в tempdb.
AggIO - Общее количество логических операций ввода-вывода (суммарно)
Как правило, количество логических чтений на порядки превышает количество операций записи, поэтому этот показатель сам по себе для анализа применим в редких случаях.
AvgIO - Среднее количество логических дисковых операций на одно выполнение запроса.
Значение данного показателя можно анализировать из следующих соображений:
Одна страница данных - это 8192 байта. Можно получить среднее количество байт данных, "обрабатываемых" данным запросом. Если этот объем превышает реальное количество данных, которые обрабатывает запрос (суммарный объем данных в используемых в запросе таблицах), это говорит о том, что был выбран заведомо плохой план выполнения и требуется заняться оптимизацией данного запроса.
Я встречал случай, когда один запрос делал количество обращений, эквивалентных объему в 5Тб, при этом общий объем данных в это БД был 300Гб, а объем данных в таблицах, задействованных в запросе не превышал 10Гб.
В общем можно описать одну причину такого поведения сервера - вместо использования индекса сервер предпочитает сканировать таблицу или наоборот.
Если объем логических чтений в разы превосходит общие объем данных, то это вызвано повторным обращениям к одним и тем же страницам данных. Помимо того, что в одном запросе таблица может быть использована несколько раз, к одним и тем же страницам сервер обращается например в случаях, когда используется индекс и по результатам поиска по нему, найденные некоторые строки данных лежат на одной и той же странице. Конечно, в таком случае предпочтительным могло бы быть сканирование таблицы - в этом случае сервер обращался бы к каждой странице данных только один раз. Однако этому часто мешают... попытки оптимизации запросов, когда разработчик явно указывает, какой индекс или тип соединения должен быть использован.
Обратный случай - вместо использования индекса было выбрано сканирование таблицы. Как правило, это связано с тем, что статистика устарела и требуется её обновление. Однако и в этом случае причиной неудачно выбранного плана вполне могут оказаться подсказки оптимизатору запросов.
query_text - Текст самого запроса
database_name - Имя базы данных, в находится объект, содержащий запрос. NULL для системных процедур
object_name - Имя объекта (процедуры или функции), содержащего запрос.
*/
with s as (
	select  creation_time,
			last_execution_time,
			execution_count,
			total_worker_time/1000 as CPU,
			convert(money, (total_worker_time))/(execution_count*1000)as [AvgCPUTime],
			qs.total_elapsed_time/1000 as TotDuration,
			convert(money, (qs.total_elapsed_time))/(execution_count*1000)as [AvgDur],
			total_logical_reads as [Reads],
			total_logical_writes as [Writes],
			total_logical_reads+total_logical_writes as [AggIO],
			convert(money, (total_logical_reads+total_logical_writes)/(execution_count + 0.0))as [AvgIO],
			[sql_handle],
			plan_handle,
			statement_start_offset,
			statement_end_offset
	from sys.dm_exec_query_stats as qs with(readuncommitted)
	where convert(money, (qs.total_elapsed_time))/(execution_count*1000)>=100 --выполнялся запрос не менее 100 мс
)
select
	s.creation_time,
	s.last_execution_time,
	s.execution_count,
	s.CPU,
	s.[AvgCPUTime],
	s.TotDuration,
	s.[AvgDur],
	s.[Reads],
	s.[Writes],
	s.[AggIO],
	s.[AvgIO],
	--st.text as query_text,
	case 
		when sql_handle IS NULL then ' '
		else(substring(st.text,(s.statement_start_offset+2)/2,(
			case
				when s.statement_end_offset =-1 then len(convert(nvarchar(MAX),st.text))*2      
				else s.statement_end_offset    
			end - s.statement_start_offset)/2  ))
	end as query_text,
	db_name(st.dbid) as database_name,
	object_schema_name(st.objectid, st.dbid)+'.'+object_name(st.objectid, st.dbid) as [object_name],
	sp.[query_plan],
	s.[sql_handle],
	s.plan_handle
from s
cross apply sys.dm_exec_sql_text(s.[sql_handle]) as st
cross apply sys.dm_exec_query_plan(s.[plan_handle]) as sp

Takisto je možné napísať aj pre MySQL. Na to je potrebné nainštalovať mysql-connector-net a potom napísať približne takýto kód:
Kód pre čakajúce požiadavky

#Задаем переменные для подключение к MySQL и само подключение
[string]$sMySQLUserName = 'UserName'
[string]$sMySQLPW = 'UserPassword'
[string]$sMySQLDB = 'db'
[string]$sMySQLHost = 'IP-address'
[void][System.Reflection.Assembly]::LoadWithPartialName("MySql.Data");
[string]$sConnectionString = "server="+$sMySQLHost+";port=3306;uid=" + $sMySQLUserName + ";pwd="+"'" + $sMySQLPW +"'"+ ";database="+$sMySQLDB;

#Open a Database connection
$oConnection = New-Object MySql.Data.MySqlClient.MySqlConnection($sConnectionString)
$Error.Clear()
try
{
    $oConnection.Open()
}
catch
{
    write-warning ("Could not open a connection to Database $sMySQLDB on Host $sMySQLHost. Error: "+$Error[0].ToString())
}

#The first query
# Get an instance of all objects need for a SELECT query. The Command object
$oMYSQLCommand = New-Object MySql.Data.MySqlClient.MySqlCommand;
# DataAdapter Object
$oMYSQLDataAdapter = New-Object MySql.Data.MySqlClient.MySqlDataAdapter;
# And the DataSet Object
$oMYSQLDataSet = New-Object System.Data.DataSet;
# Assign the established MySQL connection
$oMYSQLCommand.Connection=$oConnection;
# Define a SELECT query
$oMYSQLCommand.CommandText='query';

$oMYSQLDataAdapter.SelectCommand=$oMYSQLCommand;
# Execute the query
$count=$oMYSQLDataAdapter.Fill($oMYSQLDataSet, "data");

$result = $oMYSQLDataSet.Tables[0].Rows[0]["Count"];

write-host $result;

Výsledok

V tomto článku bol poskytnutý príklad výkonových čítačov (dátových prvkov) v Zabbixe. Tento prístup umožňuje informovať administrátorov o rôznych problémoch v reálnom čase alebo po určitom čase. Takto tento prístup umožňuje minimalizovať budúce zachytenie kritických problémov a zastavenie prevádzky DBMS a servera, čo zase chráni výrobu pred zastavením pracovných procesov.
Predchádzajúci článok: Plánované práce s databázou informačného systému 24×7 v MS SQL Server