Facal-toisich
Gu math tric feumar innse don rianaire ann an àm fìor mu dhuilgheadasan co-cheangailte ris an stòr-dàta (stòr-dàta).
Bheir an artaigil seo cunntas air na dh'fheumas a bhith air an rèiteachadh ann an Zabbix gus sùil a chumail air stòr-dàta MS SQL Server.
Thoir an aire nach tèid mion-fhiosrachadh mu mar a nì thu rèiteachadh a thoirt seachad, ge-tà, thèid foirmlean agus molaidhean coitcheann, a bharrachd air tuairisgeul mionaideach air cuir ris eileamaidean dàta àbhaisteach tro mhodhan stòraichte a thoirt seachad san artaigil seo.
Cuideachd, cha tèid ach na prìomh chunntair coileanaidh a dheasbad an seo.
co-dhùnadh
An toiseach, bheir mi cunntas air na cunntairean coileanaidh sin (tro eileamaidean dàta ann an Zabbix) a dh’ fheumas sinn:
- Diosg loidsigeach
- Avg diosc diog/Leugh
A’ sealltainn an ùine chuibheasach, air a chuir an cèill ann an diogan, airson dàta a leughadh bhon diosc. Luach cuibheasach cuntair coileanaidh cuibheasach. Cha bu chòir diog diosc / leughaidh a bhith nas àirde na 10 milliseconds. An luach as àirde den chunntair coileanaidh Avg. Cha bu chòir diog diosc / leughaidh a bhith nas àirde na 50 milliseconds.Zabbix: perf_counter[LogicalDisk(_Total)Avg. Diosc diosc / Leugh], agus tha e cudromach cuideachd sùil a chumail air an diosc a tha thu ag iarraidh, mar eisimpleir mar seo: perf_counter[LogicalDisk(C:)Avg. Diosc diosc/Leugh]
Eisimpleirean brosnachaidh:
{NODE_NAME:perf_counter[LogicalDisk(_Total)Avg. Diosc diosc/Leugh].last()}> 0.005, ìre àrd
и
{NODE_NAME:perf_counter[LogicalDisk(_Total)Avg. Diosc diosc/Leugh].last()}> 0.0025, ìre-mheadhanach - Avg diosc diog/Sgrìobh
A’ sealltainn an ùine chuibheasach, air a chuir an cèill ann an diogan, airson dàta a sgrìobhadh gu diosc. Luach cuibheasach cuntair coileanaidh cuibheasach. Cha bu chòir diog diosc / Sgrìobhadh a bhith nas fhaide na 10 milliseconds. An luach as àirde den chunntair coileanaidh Avg. Cha bu chòir diog diosc / Sgrìobhadh a bhith nas àirde na 50 milliseconds.Zabbix: perf_counter[LogicalDisk(_Total)Avg. Diosc diosc / Sgrìobh], agus tha e cudromach cuideachd sùil a chumail air an diosc a tha thu ag iarraidh, mar eisimpleir mar seo: perf_counter[LogicalDisk(C:)Avg. Diosc diosc/Sgrìobh]
Eisimpleirean brosnachaidh:
{NODE_NAME:perf_counter[LogicalDisk(_Total)Avg. Diosc diosc/Sgrìobh].last()}> 0.005, ìre àrd
и
{NODE_NAME:perf_counter[LogicalDisk(_Total)Avg. Diosc diosc/Sgrìobh].last()}> 0.0025, ìre-mheadhanach - Fad ciudha diosc avg
Cuibheasach fad ciudha iarrtasan air an diosg. A’ taisbeanadh an àireamh de dh’iarrtasan diosc a tha a’ feitheamh ri giullachd taobh a-staigh ùine shònraichte. Thathas den bheachd gu bheil ciudha nach eil nas motha na 2 airson aon diosc àbhaisteach. Ma tha barrachd air dà iarrtas anns a’ chiudha, dh’ fhaodadh an diosc a bhith air a luchdachadh cus agus chan urrainn dha iarrtasan a thig a-steach a phròiseasadh. Gheibh thu a-mach dè dìreach na h-obraichean nach urrainn don diosc a làimhseachadh le bhith a’ cleachdadh cunntairean Avg. Diosc Leugh Ciudha Fad agus Avg. Fad ciudha Disk Wright (ciudha airson iarrtasan sgrìobhaidh).
Luach cuibheasach Chan eil fad ciudha diosc air a thomhas, ach tha e air a thomhas a’ cleachdadh lagh Little bho theòiridh matamataigeach ciudha. A rèir an lagh seo, tha an àireamh de dh’iarrtasan a tha a’ feitheamh ri bhith air an giullachd, gu cuibheasach, co-ionann ri tricead iarrtasan air an iomadachadh le ùine giollachd iarrtasan. An fheadhainn sin. nar cùis Avg. Fad ciudha diosc = (Gluasad diosc/diog) * (Avg. diog diosc/Gluasad).Avg. Tha fad ciudha diosc air a thoirt seachad mar aon de na prìomh chunntair airson a bhith a’ dearbhadh an luchd air an fho-shiostam diosc, ach, gus a mheasadh gu h-iomchaidh, feumar structar fiosaigeach an t-siostam stòraidh a riochdachadh gu ceart. Mar eisimpleir, airson aon chlàr cruaidh tha luach nas motha na 2 air a mheas riatanach, agus ma tha an diosc suidhichte air sreath RAID de 4 diosc, bu chòir dhut dragh a ghabhail ma tha an luach nas àirde na 4 * 2 = 8.
Zabbix: perf_counter[LogicalDisk(_Total)Avg. Fad ciudha diosc], agus tha e cudromach cuideachd sùil a chumail air an diosc a tha thu ag iarraidh, mar eisimpleir mar seo: perf_counter[LogicalDisk(C:)Avg. Fad ciudha an diosc]
- Avg diosc diog/Leugh
- memory
- Duilleagan/diog
A’ sealltainn na h-àireimh de dhuilleagan a leugh SQL Server bho dhiosg no a sgrìobh gu diosc gus faighinn seachad air slighean gu duilleagan cuimhne nach deach a luchdachadh a-steach do RAM aig àm an inntrigidh. Is e an luach seo suim Duilleagan a-steach / diog agus Duilleagan Toradh / diog, agus bidh e cuideachd a’ toirt aire do paging (paging / swaping) tasgadan an t-siostaim airson faighinn gu faidhlichean dàta tagraidh. A bharrachd air an sin, tha seo a’ toirt a-steach paging de fhaidhlichean neo-thasgadh a tha air am mapadh gu dìreach mar chuimhne. Is e seo am prìomh chunntair a bu chòir sùil a chumail air ma tha thu a’ faighinn eòlas air cleachdadh cuimhne àrd agus cus paging co-cheangailte ris. Tha an cuntair seo a’ comharrachadh na tha de dh’ iomlaid agus bu chòir a luach àbhaisteach (chan e stùc) a bhith faisg air neoni. Tha àrdachadh ann an iomlaid a’ nochdadh gu bheil feum air RAM àrdachadh no an àireamh de phrògraman tagraidh a tha a’ ruith air an fhrithealaiche a lughdachadh.Zabbix: perf_counter[Duilleagan cuimhne/diog] Eisimpleir brosnachaidh:
{NODE_NAME:perf_counter[MemoryPages/sec].min(5m)}> 1000, fiosrachadh ìre - Sgàinidhean na duilleige/diog
Is e seo luach cunntais locht na duilleige. Bidh locht duilleag a’ tachairt nuair a bhios pròiseas a’ toirt iomradh air duilleag cuimhne brìgheil nach eil san t-seata obrach de RAM. Bidh an cuntair seo a’ gabhail a-steach an dà chuid na sgàinidhean duilleag sin a dh’ fheumas ruigsinneachd diosc, agus an fheadhainn a tha air adhbhrachadh leis gu bheil an duilleag taobh a-muigh an t-seata obrach ann an RAM. Is urrainn don mhòr-chuid de luchd-giullachd sgàinidhean duilleag Seòrsa XNUMX a làimhseachadh gun mòran dàil. Ach, faodaidh làimhseachadh sgàinidhean duilleag seòrsa XNUMX a dh’ fheumas ruigsinneachd diosc dàil mhòr adhbhrachadh.
Zabbix: perf_counter[MemoryPage Sgàinidhean/diog] Eisimpleir brosnachaidh:
{NODE_NAME:perf_counter[MemoryPage Sgàinidhean/diog].min(5m)}> 1000, fiosrachadh ìre - Bytes ri fhaighinn
A’ cumail sùil air na tha de chuimhne ri fhaighinn ann am bytes airson diofar phròiseasan a ruith. Tha leughaidhean ìosal a’ nochdadh cuimhne ìosal. Is e am fuasgladh cuimhne a mheudachadh. Bu chòir don mheatair seo sa mhòr-chuid de chùisean a bhith nas àirde na 5000 kV.
Tha e ciallach an stairsneach airson Mbytes a tha rim faighinn a shuidheachadh le làimh airson na h-adhbharan a leanas:•50% cuimhne saor ri fhaighinn = Sgoinneil
•25% cuimhne ri fhaighinn = Feum air aire
•10% an-asgaidh = Duilgheadasan comasach
• Nas lugha na 5% cuimhne ri fhaighinn = Tha e deatamach airson luaths, feumaidh tu eadar-theachd a dhèanamh.
Zabbix: perf_counter[MemoryAvailable Bytes]
- Duilleagan/diog
- Pròiseasar (Iomlan): % Pròiseasar Ùine
Tha an cuntair seo a’ sealltainn an àireamh sa cheud den ùine a bha am pròiseasar trang a’ dèanamh obair airson snàithleanan neo-dhìomhair. Faodar beachdachadh air an luach seo mar a’ chuibhreann den ùine a thathar a’ caitheamh a’ dèanamh obair fheumail. Faodar snàithlean seòlta a thoirt do gach pròiseasar, a bhios ag ithe cearcallan pròiseasar neo-thorrach nach eil air an cleachdadh le snàithleanan eile. Tha a’ chunntair seo air a chomharrachadh le stùcan goirid a ruigeas 100 sa cheud. Ach, ma tha amannan fada ann far a bheil cleachdadh pròiseasar nas àirde na 80 sa cheud, bidh an siostam nas èifeachdaiche le bhith a’ cleachdadh barrachd phròiseasan.Zabbix: perf_counter[Processor(_Total)% Processor Time], an seo faodar a thaisbeanadh cuideachd le cridhe
Eisimpleir brosnachaidh:
{NODE_NAME:perf_counter[Processor(_Total)% Processor Time].min(5m)}> 80, fiosrachadh ìre - Eadar-aghaidh lìonraidh (*): % Bytes Total/sec
An àireamh iomlan de bytes a chaidh a chuir agus a fhuaireadh gach diog thar gach eadar-aghaidh. Is e seo leud-bann an eadar-aghaidh (ann am bytes). Feumar coimeas a dhèanamh eadar luach a ’chunntair seo leis an leud-bann as àirde den chairt lìonra. San fharsaingeachd, cha bu chòir don chunntair seo sealltainn barrachd air cleachdadh 50% de leud-bann an adapter lìonra.
Zabbix: perf_counter[Eadar-aghaidh lìonraidh(*) Bytes air an cur/diog] - MS SQL Server: Dòighean Ruigsinneachd
Tha an nì Access Methods ann an SQL Server a’ toirt seachad cunntairean gus cuideachadh le bhith a’ lorg ruigsinneachd air dàta loidsigeach taobh a-staigh stòr-dàta. Tha smachd air ruigsinneachd corporra gu duilleagan stòr-dàta air diosc le bhith a’ cleachdadh cunntairean manaidsear bufair. Le bhith a’ cumail sùil air dòighean ruigsinneachd dàta san stòr-dàta cuidichidh sin le bhith a’ dearbhadh an gabh coileanadh ceist a leasachadh le bhith a’ cur ris no ag atharrachadh chlàran-amais, a’ cur ris no a’ gluasad phàirtean, a’ cur fhaidhlichean no buidhnean de fhaidhlichean, a’ milleadh chlàran-amais, no ag atharrachadh teacsa ceiste. A bharrachd air an sin, faodaidh tu cunntairean stuthan Access Methods a chleachdadh gus sùil a chumail air meud dàta, clàran-amais, agus àite an-asgaidh san stòr-dàta agad, a’ cumail sùil air comas agus briseadh airson gach cùis frithealaiche. Faodaidh cus sgaradh clàr-amais coileanadh a lughdachadh gu mòr.- Roinn na duilleige/diog
An àireamh de sgoltadh dhuilleagan gach diog air a choileanadh mar thoradh air cus duilleag clàr-amais. Tha luach àrd airson a’ mheatrach seo a’ ciallachadh, nuair a bhios tu a’ coileanadh obrachaidhean cuir a-steach agus ùrachadh air dàta, gum feum SQL Server àireamh mhòr de ghnìomhachdan a dhèanamh a tha dian air goireasan gus duilleagan a roinn agus pàirt de dhuilleag a tha ann mu thràth a ghluasad gu àite ùr. Bu chòir gnìomhan leithid seo a sheachnadh nuair as urrainnear. Faodaidh tu feuchainn ri fuasgladh fhaighinn air an duilgheadas ann an dà dhòigh:
- cruthaich clàr-amais cruinn airson colbhan àrdachadh fèin-ghluasadach. Anns a 'chùis seo, cha tèid clàran ùra a chur am broinn duilleagan air an robh dàta mar-thà, ach bidh iad a' gabhail thairis duilleagan ùra ann an òrdugh;
- ath-thog clàran-amais le bhith ag àrdachadh luach paramadair Fillfactor. Leigidh an roghainn seo leat àite an-asgaidh a ghlèidheadh ann an duilleagan clàr-amais a thèid a chleachdadh gus gabhail ri dàta ùr, gun fheum air gnìomhachd sgoltadh dhuilleagan.
Zabbix: perf_counter["MSSQL$INSTANCE_NAME:Dòighean-ruigsinneachd Duilleag Splits/sec", 30] Eisimpleir brosnachaidh: {NODE_NAME:perf_counter["MSSQL$INSTANCE_NAME:Dòighean RuigsinneachdPage Splits/sec", 30].last()}>{NODE_NAME:perf_counter["MSSQL$INSTANCE_NAME:SQL StatisticsBatch Requests/sec", 30].last()} /5, ìre-fiosrachaidh - Sganaichean slàn / diog
Àireamh gun chrìoch de sganaidhean slàn gach diog. Tha na gnìomhan sin a’ toirt a-steach sganaidhean prìomh bhùird agus sganaidhean làn chlàr-amais. Dh’ fhaodadh àrdachadh seasmhach san t-slat-tomhais seo a bhith a’ nochdadh crìonadh san t-siostam (cion clàran-amais riatanach, an sgaradh cruaidh aca, fàilligeadh an optimizer clàran-amais gnàthaichte a chleachdadh, làthaireachd chlàran-amais nach deach a chleachdadh). Ach, is fhiach a bhith mothachail nach eil sgrùdadh iomlan ann an clàran beaga an-còmhnaidh dona, oir mas urrainn dhut an clàr gu lèir a chuir ann an RAM, bidh làn scan nas luaithe. Ach anns a 'mhòr-chuid de chùisean, bidh àrdachadh seasmhach anns a' chunntair seo a 'sealltainn gu bheil an siostam ag atharrachadh. Tha seo uile buntainneach a-mhàin airson siostaman OLTP. Ann an siostaman OLAP, tha làn sganaidhean seasmhach àbhaisteach.
Zabbix: perf_counter["MSSQL$INSTANCE_NAME:Faigh cothrom air dòighean-obrach Làn sganaidhean/sec", 30]
- Roinn na duilleige/diog
- MS SQL Server: Manaidsear Bufair
Tha an nì Manaidsear Bufair a’ toirt seachad cunntairean a chuidicheas tu gus sùil a chumail air mar a chleachdas SQL Server na goireasan a leanas:
- cuimhne airson duilleagan dàta a stòradh;
- cunntairean a bhios a’ cumail sùil air I/O corporra mar a bhios SQL Server a’ leughadh agus a’ sgrìobhadh duilleagan stòr-dàta;
- leudachadh amar bufair gus an tasgadan bufair a leudachadh a’ cleachdadh cuimhne luath neo-luaineach, leithid draibhearan stàite cruaidh (SSD);
- Bidh sgrùdadh cuimhne agus cunntairean a bhios SQL Server a’ cleachdadh a ’cuideachadh le bhith a’ faighinn an fhiosrachaidh a leanas;
- a bheil cnapan-starra air adhbhrachadh le dìth cuimhne corporra. Mura h-urrainnear dàta a gheibhear gu tric a stòradh san tasgadan, feumaidh SQL Server a leughadh bhon diosc;
A bheil e comasach coileanadh ceisteachan a leasachadh le bhith ag àrdachadh na tha de chuimhne no a’ riarachadh cuimhne a bharrachd airson dàta a thasgadh no a bhith a’ stòradh structaran SQL Server a-staigh?
- dè cho tric a bhios SQL Server a’ leughadh dàta bhon diosc. An coimeas ri gnìomhachdan eile leithid ruigsinneachd cuimhne, bheir I/O corporra nas fhaide ri chrìochnachadh. Faodaidh lughdachadh I/O coileanadh ceist a leasachadh.- Bhuail Buffer Cache air an rèidio
A’ nochdadh dè an ìre de dhàta a dh’ fhaodas SQL Server a chuir a-steach don bhufair tasgadan. Mar as àirde an luach seo, is ann as fheàrr, oir Airson SQL Server gus faighinn gu duilleagan dàta gu h-èifeachdach, feumaidh iad a bhith ann am bufair tasgadan, agus chan fhaod gnìomhachd cuir a-steach / toradh corporra (I / O) a bhith ann. Ma chì thu crìonadh cunbhalach ann an luach cuibheasach a’ chunntair seo, bu chòir dhut beachdachadh air RAM a chuir ris. Bu chòir an comharra seo a bhith an-còmhnaidh nas àirde na 90% airson siostaman OLTP agus os cionn 50% airson siostaman OLAP.
Zabbix: perf_counter["MSSQL$INSTANCE_NAME:Buffer ManagerBuffer co-mheas bualadh tasgadan", 30] Eisimpleirean brosnachaidh: {NODE_NAME:perf_counter["MSSQL$INSTANCE_NAME:Buffer ManagerBuffer co-mheas bhuail tasgadan", 30].last()}<70, ìre-àrd
и
{NODE_NAME:perf_counter["MSSQL$INSTANCE_NAME:Buffer ManagerBuffer co-mheas bhuail tasgadan", 30].last()}<80, ìre-meadhanach - Dùil-beatha na duilleige
A’ sealltainn dè cho fada ‘s a mhaireas an duilleag gu buan mar chuimhneachan air mar a tha e an-dràsta. Ma chumas an luach a’ dol sìos, tha e a’ ciallachadh gu bheil an siostam a’ dèanamh ana-cainnt air an amar bufair. Mar sin, dh’ fhaodadh coileanadh cuimhne duilgheadasan adhbhrachadh le droch choileanadh. Is fhiach a bhith mothachail nach eil comharradh uile-choitcheann gu h-ìosal far am faod neach a bhith a 'breithneachadh gu soilleir gu bheil an siostam a' dèanamh ana-cainnt air an amar bufair (tha an comharra de 300 diogan seann-fhasanta bho MS SQL Server 2012).
Zabbix: perf_counter["MSSQL$INSTANCE_NAME:Manaidsear BufairDùil beatha", 30] Eisimpleir brosnachaidh: {NODE_NAME:perf_counter["MSSQL$INSTANCE_NAME:Dùil-beatha Manaidsear BufairPage", 30].last()}<5, fiosrachadh ìre
- Bhuail Buffer Cache air an rèidio
- MS SQL Server: Staitistig Coitcheann
Tha an nì Staitistig Coitcheann ann an SQL Server a’ toirt seachad cunntairean a leigeas leat sùil a chumail air gnìomhachd an fhrithealaiche san fharsaingeachd, leithid an àireamh de cheanglaichean co-aontach agus an àireamh de luchd-cleachdaidh gach diog a tha a’ ceangal ris a’ choimpiutair no a’ dì-cheangal bhon choimpiutair mar eisimpleir SQL Server. Tha na meatrach seo feumail ann an siostaman giullachd malairt mòr air-loidhne (OLTP) far a bheil àireamh mhòr de luchd-dèiligidh an-còmhnaidh a’ ceangal agus a’ dì-cheangal bho eisimpleir de SQL Server.- Pròiseas air a bhacadh
An àireamh de phròiseasan a tha air am bacadh an-dràsta.
Zabbix: perf_counter["MSSQL$INSTANCE_NAME:Pròiseasan Staitistearachd Coitcheann air am bacadh", 30] Eisimpleir brosnachaidh: ({NODE_NAME:perf_counter["MSSQL$INSTANCE_NAME:Pròiseasan Staitistearachd Coitcheann air am bacadh", 30].min(2m,0)}>=0)
agus ({NODE_NAME:perf_counter["MSSQL$INSTANCE_NAME:Pròiseasan Staitistearachd Coitcheann air am bacadh", 30].time(0)}>=50000)
agus ({NODE_NAME:perf_counter["MSSQL$INSTANCE_NAME:Pròiseasan Staitistearachd Coitcheann air am bacadh", 30].time(0)}<=230000), ìre fiosrachaidh (an seo tha cuingeachadh chomharran bho 05:00 gu 23:00) - Ceanglaichean luchd-cleachdaidh
An àireamh de luchd-cleachdaidh a tha an-dràsta ceangailte ri SQL Server.
Zabbix: perf_counter["MSSQL$INSTANCE_NAME:Ceanglaichean Cleachdaiche Staitistig Coitcheann", 30]
- Pròiseas air a bhacadh
- MS SQL Server: Glasan
Tha an nì Locks ann am Microsoft SQL Server a’ toirt seachad fiosrachadh mu ghlasan SQL Server a chaidh fhaighinn airson seòrsaichean ghoireasan fa leth. Thèid glasan a chuir a-mach air goireasan SQL Server, leithid sreathan air an leughadh no air an atharrachadh le malairt, gus casg a chuir air grunn ghnothaichean bho bhith a’ cleachdadh a’ ghoireas aig an aon àm. Mar eisimpleir, ma gheibhear glas toirmeasgach (X) le malairt air sreath ann an clàr, chan urrainn do ghnothach sam bith eile an t-sreath sin atharrachadh gus an tèid a’ ghlas a leigeil ma sgaoil. Le bhith a 'lùghdachadh cleachdadh ghlasan a' meudachadh concurrency, a dh'fhaodas coileanadh iomlan a leasachadh. Faodar grunn eisimpleirean den nì Locks a leantainn aig an aon àm, agus bidh gach fear dhiubh a’ riochdachadh glas air seòrsa de ghoireas air leth.- Ùine feitheimh cuibheasach (ms)
An ùine feitheimh cuibheasach (ann am milliseconds) airson a h-uile iarrtas glasaidh a dh’ fheumadh feitheamh. Tha an cuntair seo a’ sealltainn dè cho fada, gu cuibheasach, a dh’ fheumas pròiseasan luchd-cleachdaidh feitheamh ann an ciudha gus glas fhaighinn air goireas. Tha an luach ceadaichte as àirde den chunntair seo gu tur an urra ris a’ ghnìomh agad; tha e duilich luach cuibheasach sam bith a dhearbhadh airson a h-uile tagradh. Ma tha an cuntair seo ro àrd, dh’ fhaodadh e nochdadh gu bheil duilgheadasan glasaidh san stòr-dàta agad.
Zabbix: perf_counter["MSSQL$INSTANCE_NAME: A' glasadh(_Total)Cuibheasach Ùine Feitheimh (ms)", 30] Eisimpleir brosnachaidh: {NODE_NAME:perf_counter["MSSQL$INSTANCE_NAME:Glais(_Total)Am Feitheamh Cuibheasach (ms)", 30].last()}>=500, fiosrachadh ìre - Glasadh àm feitheimh (ms)
Ùine feitheimh glasaidh iomlan (ann am milliseconds) thairis air an diog mu dheireadh.
Zabbix: perf_counter["MSSQL$INSTANCE_NAME: A' glasadh(_Total)Glais Ùine Feitheimh (ms)", 30] - Glasadh Waits / diog
An àireamh de thursan anns an diog mu dheireadh a dh'fheumadh snàithlean feitheamh air sgàth iarrtas glasaidh.
Zabbix: perf_counter["MSSQL$INSTANCE_NAME: Glasan(_Total)Glais a' feitheamh/sec", 30] - Glasadh amannan-ama / diog
An àireamh de thursan nach fhaigh robin cruinn a’ ghlas. Bidh luach paramadair rèiteachaidh snìomh an SQL Server a’ dearbhadh an àireamh de thursan a dh’ fhaodas snàithlean snìomh mus tig e a-mach agus gum fàs an snàithlean neo-ghnìomhach.
Zabbix: perf_counter["MSSQL$INSTANCE_NAME: A' glasadh(_Iomlan)Loc ùine-ghlais/sec", 30] Eisimpleir brosnachaidh: {NODE_NAME:perf_counter["MSSQL$INSTANCE_NAME:Glais(_Total)Glais(_Total)Lock Timeouts/sec", 30].last()}>1000, fiosrachadh ìre - Glasadh iarrtasan / diog
An àireamh de dh'iarrtasan gach diog den t-seòrsa glasaidh ainmichte.
Zabbix: perf_counter["MSSQL$INSTANCE_NAME: Glasadh(_Iomlan)Iarrtasan Glasaidh/sec", 30] Eisimpleir brosnachaidh: {NODE_NAME:perf_counter["MSSQL$INSTANCE_NAME:Glais(_Total)Iarrtasan Glasaidh/sec", 30].last()}>500000, fiosrachadh ìre - Glasadh Àireamh de ghlasan-glasaidh / diog
An àireamh de dh’ iarrtasan glasaidh gach diog a dh’ adhbhraicheas stad-stad. Tha làthaireachd ghlasan-stad a’ nochdadh ceistean air an droch thogail a tha a’ cur bacadh air goireasan co-roinnte.
Zabbix: perf_counter["MSSQL$INSTANCE_NAME:Àireamh de ghlasan-glasaidh/diog", 30] Eisimpleir brosnachaidh: {NODE_NAME:perf_counter["MSSQL$INSTANCE_NAME:Glais(_Total)Àireamh de ghlasan-glasaidh/sec", 30].last()}> 1, ìre-àrd
- Ùine feitheimh cuibheasach (ms)
- MS SQL Server: Manaidsear Cuimhne
Tha an nì Manaidsear Cuimhne ann am Microsoft SQL Server a’ toirt seachad cunntairean gus sùil a chumail air cleachdadh cuimhne air feadh an fhrithealaiche. Le bhith a’ cumail sùil air cleachdadh cuimhne an t-seirbheisiche gu lèir gus measadh a dhèanamh air gnìomhachd luchd-cleachdaidh agus cleachdadh ghoireasan, cuidichidh e le bhith ag aithneachadh cnapan-starra coileanaidh. Faodaidh an sgrùdadh cuimhne a chleachdar le eisimpleir de SQL Server cuideachadh le bhith a’ dearbhadh:
- a bheil gainnead cuimhne corporra gu leòr ann airson dàta a chleachdar gu tric a stòradh san tasgadan. Mura h-eil cuimhne gu leòr ann, feumaidh SQL Server an dàta fhaighinn bhon diosg;
- Co-dhiù am b’ urrainn do choileanadh ceiste leasachadh nan deidheadh cuimhne a chur ris no an deach an ìre de chuimhne a bha ri fhaighinn airson dàta a thasgadh no structaran taobh a-staigh SQL Server a mheudachadh.- Tabhartasan Cuimhne Sònraichte
A’ nochdadh an àireamh iomlan de phròiseasan a fhuair gu soirbheachail cuimhne àite-obrach. Ma tha an comharra a 'tuiteam gu cunbhalach, tha e riatanach a mheudachadh RAM.
Zabbix: perf_counter["MSSQL$INSTANCE_NAME:Manaidsear Cuimhne Tabhartasan Cuimhne gun Sàr", 30] - Tabhartasan Cuimhne ri feitheamh
A’ nochdadh an àireamh iomlan de phròiseasan a tha a’ feitheamh ri cuimhne obrach a bhith air a riarachadh. Le fàs seasmhach den chomharra, feumar RAM àrdachadh.
Zabbix: perf_counter["MSSQL$INSTANCE_NAME:Manaidsear Cuimhne Tabhartasan Cuimhne ri feitheamh", 30]
- Tabhartasan Cuimhne Sònraichte
- MS SQL Server: Staitistig
Tha an nì Staitistig ann am Microsoft SQL Server a’ toirt seachad cunntairean gus sùil a chumail air a’ chruinneachadh agus na seòrsaichean cheistean a chuirear gu eisimpleir de SQL Server. Le bhith a’ cumail sùil air an àireamh de chruinneachaidhean cheistean agus ath-chruinneachaidhean agus an àireamh de bhaidsean a gheibh eisimpleir de SQL Server a’ toirt sealladh dhuinn air cho luath sa bhios SQL Server a’ cur an gnìomh ceistean luchd-cleachdaidh agus dè cho èifeachdach sa bhios an optimization ceist gan làimhseachadh.- Iarrtasan Baidse / diog
An àireamh de phasganan àithne Transact-SQL a fhuaireadh gach diog. Tha buaidh aig crìochan sam bith air na staitistig sin (I/O, àireamh luchd-cleachdaidh, meud tasgadan, iom-fhillteachd ceiste, msaa). Tha àireamh àrd de dh’iarrtasan pacaid a’ nochdadh toradh àrd.
Zabbix: perf_counter["MSSQL$INSTANCE_NAME:SQL StatisticsBatch Requests/sec", 30]
- Iarrtasan Baidse / diog
A bharrachd air a h-uile rud gu h-àrd, faodaidh tu cuideachd eileamaidean dàta eile a rèiteachadh (a bharrachd air brosnachaidhean a chruthachadh orra le fiosan às deidh sin).
1) an uiread de dh 'àite diosg an-asgaidh
2) meudan faidhlichean dàta stòr-dàta agus logaichean
i. d.
Ach, chan eil na taisbeanairean sin uile a 'nochdadh an duilgheadas a thaobh ceistean fìor-ùine.
Gus seo a dhèanamh, feumaidh tu na cunntairean sònraichte agad fhèin a chruthachadh.
Air sgàth adhbharan dìomhaireachd, cha toir mi eisimpleirean de chunntair mar sin. A bharrachd air an sin, tha iad air an rèiteachadh gu sònraichte airson gach siostam. Ach tha mi a’ toirt fa-near, airson siostaman leithid 1C, NAV agus CRM, gum faodar cunntairean sònraichte a chruthachadh còmhla ris an luchd-leasachaidh iomchaidh.
Bheir mi eisimpleir de bhith a’ cruthachadh comharra coitcheann a sheallas cia mheud iarrtas a tha a’ ruith agus cia mheud iarrtas a tha ri feitheamh (air a chuir dheth no air a bhacadh) aig gach àm.
Gus seo a dhèanamh, feumaidh tu modh-obrach glèidhte a chruthachadh:
còd a '
USE [ИМЯ_БАЗЫ_ДАННЫХ]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE PROCEDURE [nav].[ZabbixGetCountRequestStatus]
@Status nvarchar(255)
AS
BEGIN
/*
возвращает кол-во запросов с заданным статусом
*/
SET NOCOUNT ON;
select count(*) as [Count]
from sys.dm_exec_requests ER with(readuncommitted)
where [status]=@Status
END
An ath rud, feumaidh tu a dhol chun phasgan far a bheil Zabbix suidhichte (zabbixconfuserparams.d) agus cruthaich 2 fhaidhle leis an leudachadh ps1 (PowerShell) agus sgrìobh na còdan a leanas anns gach fear dhiubh:
Còd airson ceistean a ruith
$SQLServer = "НАЗВАНИЕ_ЭКЗЕМПЛЯРА";
$uid = "ЛОГИН";
$pwd = "ПАРОЛЬ";
$Status="running";
$connectionString = "Server = $SQLServer; Database=НАЗВАНИЕ_БД; Integrated Security = False; User ID = $uid; Password = $pwd;";
$connection = New-Object System.Data.SqlClient.SqlConnection;
$connection.ConnectionString = $connectionString;
#Создаем запрос непосредственно к MSSQL / Create a request directly to 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;
Còd airson iarrtasan ri thighinn
$SQLServer = "НАЗВАНИЕ_ЭКЗЕМПЛЯРА";
$uid = "ЛОГИН";
$pwd = "ПАРОЛЬ";
$Status="suspended";
$connectionString = "Server = $SQLServer; Database=НАЗВАНИЕ_БД; Integrated Security = False; User ID = $uid; Password = $pwd;";
$connection = New-Object System.Data.SqlClient.SqlConnection;
$connection.ConnectionString = $connectionString;
#Создаем запрос непосредственно к MSSQL / Create a request directly to 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;
A-nis feumaidh tu faidhle a chruthachadh le paramadairean cleachdaiche agus leudachadh .conf (no cuir loidhnichean ri faidhle cleachdaiche mar seo, ma chaidh fear a chruthachadh na bu thràithe) agus cuir a-steach na loidhnichean a leanas:
UserParameter=PARAMETER_NAME_NUMBER_of_QUERIES EXECUTED,shell cumhachd -NoProfile - Seach-rathad Poileasaidh Cur-an-gnìomh -File FULL_PATHzabbixconfuserparams.dFILE_NAME_FOR_EXECUTED_QUERYES.ps1
UserParameter=PARAMETER_NAME_NUMBER_WAITING_REQUESTS,shell cumhachd -NoProfile - Seach-rathad Poileasaidh Cur-an-gnìomh -File FULL_PATHzabbixconfuserparams.dFILE_NAME_FOR_WAITING_REQUESTS.ps1
Às deidh seo, sàbhail am faidhle .conf agus ath-thòisich an neach-ionaid Zabbix.
Às deidh seo, cuiridh sinn dà eileamaid ùr ri Zabbix (sa chùis seo, tha na h-ainmean agus an iuchair mar an ceudna):
PARAMETER_NAME_NUMBER OF_REQUESTS PERFORMED
PARAMETER_NAME_NUMBER OF_WAITING_REQUESTS
Faodaidh tu a-nis grafaichean agus brosnachaidhean a chruthachadh airson nithean dàta gnàthaichte cruthaichte.
Ma tha an àireamh de dh’ iarrtasan ri thighinn a’ dol am meud gu mòr, faodaidh a’ cheist a leanas na h-iarrtasan ruith is feitheamh uile a thaisbeanadh aig àm sònraichte le mion-fhiosrachadh bho càite agus fo dè an logadh a-steach a tha an t-iarrtas air a chur an gnìomh, an teacsa agus plana na ceiste, a bharrachd air mion-fhiosrachadh eile:
còd a '
/*Активные, готовые к выполнению и ожидающие запросы, а также те, что явно блокируют другие сеансы*/
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);
Leig leam cuideachd do chuimhneachadh gum faigh thu na ceistean as duilghe a rèir nan staitistig a chaidh a chruinneachadh:
còd a '
/*
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
Faodaidh tu cuideachd sgrìobhadh airson MySQL. Gus seo a dhèanamh feumaidh tu a stàladh agus an uairsin sgrìobh còd mar seo:
Còd airson iarrtasan ri thighinn
#Задаем переменные для подключение к 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;
thoradh air
Thug an artaigil seo sùil air eisimpleir de chunntair coileanaidh (nithean dàta) ann an Zabbix. Tha an dòigh-obrach seo a’ leigeil le luchd-rianachd fios fhaighinn mu dhiofar dhuilgheadasan ann an àm fìor no às deidh ùine shònraichte. Mar sin, leigidh an dòigh-obrach seo leinn tachartas de dhuilgheadas èiginneach a lughdachadh san àm ri teachd agus stad a chuir air gnìomhachd an DBMS agus an fhrithealaiche, a bhios an uair sin a’ dìon cinneasachadh bho bhith a’ stad pròiseasan obrach.
Artaigil roimhe:
Stòran:
»
»
»
»
»
»
»
»
»
»
Source: www.habr.com