Verify Latest Database Backups – T-SQL

A common challenge is to determine when database backups were taken from our databases. As soon as there are more than three user databases, this task is not that easy to accomplish by opening the database properties dialog in SSMS and checking the Last Full/Log Backup lines on the General tab. Scripting is your friend – as always :)

A very simplistic approach is to just get the time of the latest backups taken.

SELECT d.name as DBName, 
      ISNULL(CONVERT(varchar(16), MAX(bs.backup_finish_date), 120),'------ NEVER') as LastBackup
FROM sys.databases d
LEFT OUTER JOIN msdb.dbo.backupset bs ON bs.database_name = d.name
WHERE d.name != 'tempdb'
GROUP BY d.Name
ORDER BY d.Name;

Ok, that was easy – where’s the catch? Well, what kind of backup was taken of your database at that time? Was it a full, a copy-only or just a transaction log? Oops… So, let’s RTFM and find the magic column in the backupset table: type. Typically, we’re interested in the full, incremental and log backups, when applicable. Version 2:

SELECT d.name as DBName, 
      ISNULL(CONVERT(varchar(16), bs_D.LastBackup, 120),'------ NEVER') as LastFullBackup,
      ISNULL(CONVERT(varchar(16), bs_I.LastBackup, 120),'------ NEVER') as LastDiffBackup,
      CASE WHEN d.recovery_model_desc = 'SIMPLE' THEN 'N/A' ELSE ISNULL(CONVERT(varchar(16), bs_L.LastBackup, 120),'------ NEVER') END as LastTLogBackup
FROM sys.databases d
LEFT OUTER JOIN (select database_name, max(backup_finish_date) LastBackup FROM msdb.dbo.backupset WHERE type = 'D' group by database_name) bs_D ON bs_D.database_name = d.name
LEFT OUTER JOIN (select database_name, max(backup_finish_date) LastBackup FROM msdb.dbo.backupset WHERE type = 'I' group by database_name) bs_I ON bs_I.database_name = d.name
LEFT OUTER JOIN (select database_name, max(backup_finish_date) LastBackup FROM msdb.dbo.backupset WHERE type = 'L' group by database_name) bs_L ON bs_L.database_name = d.name
WHERE d.name != 'tempdb'
ORDER BY d.Name;

Looks a bit more fancy – and useful. If you’re really picky, you may want to check the full backups whether they were copy-only backups, by filtering on the is_copy_only column. Enjoy!

Miért NE kezdjünk tárolt eljárást sp_-sal?

Sok fejlesztő használ naming conventiont (nevezési szokást) az adatbázis objektumainak elnevezésénél. Ez kedves tőlük, mivel kiszámíthatóbbá teszik a karbantartók (beleértve saját magukat) életét. Ámde vannak kevésbé szerencsés naming conventionök, és itt nem csak az akkor jó ötletnek tűnő Systems Hungarian notationre gondolok.

Többször találkoztam az sp_ prefixszel, mint tárolt eljárás jelöléssel, ami jó ötletnek tűnik, a Microsoft is ezt favorizálja, úgyhogy biztos jó. De nem az. Az sp_ ugyanis a Microsoft sajátja, amit befoglaltak kódból: minden sp_ kezdetű tárolt eljárást a master adatbázisban keres először az SQL Server, és ha ott nem találja, akkor nézi meg az aktuális adatbázist. Benne is van a BOL-ban, hogy ne használd, mert ráfázol. És íme, a példa:

use tempdb
go
create procedure sp_password 
AS
print 'De rossz nev ez...'
GO

És próbáljuk meg futtatni a mi kis sp_password SP-nket. Ez sosem fog sikerülni, még ha két- vagy háromtagú nevet adunk meg, akkor se.

EXEC sp_password
-- fail
EXEC tempdb.dbo.sp_password
-- ez is fail
GO

Az egyetlen elfogadható kiút, ha nem a dbo schema alá rakjuk, és legalább kéttagú névvel hivatkozunk rá:

create schema test
GO
create procedure test.sp_password 
AS
print 'De rossz nev ez...'
GO
EXEC test.sp_password

Azért valljuk be, ez így gáz. Használjunk valami jobb nevezéket…

Ha esetleg valakiben felmerülne a kérdés, hogy ez miért jó dolog, akkor gondolja végig a fenti példa esetleges működésének következményeit: Gonosz Géza olyan szép trójai sp_password-öt produkálhat, hogy mindenki csak nézni fog. A security fontos dolog…

Disabled login vs locked out login

Alcím: Hogyan nem tud valaki belépni egy SQL Serverbe? A belépés egy két részből álló folyamat, mint minden rendszer esetében: autentikáció és authorizáció. Az autentikáció mondja meg, hogy kik vagyunk: felhasználónév+jelszó például. Az authorizáció pedig megmondja, hogy mi, akik azok vagyunk, akik, mit tehetünk, mire vagyunk feljogosítva.

Ebból következik, hogy a legegyszerűbb nem-belépés az, ha elbukjuk az autentikációt. De az túl egyszerű. Inkább nézzük meg, hogyan lehet elbukni az authorizációt olyan mértékben, hogy be sem jutunk.

A legegyszerűbb a letiltás:

CREATE LOGIN [SQL01\ddisable] FROM WINDOWS;
ALTER LOGIN [SQL01\ddisable] DISABLE;

Csináltunk egy SQL logint egy domain usernek, majd letiltottuk a logint. Könnyű és nyilvánvaló, pipa.

Egy kicsit régebbi történet a DENY LOGIN:

EXEC sp_denylogin 'SQL01\ddeny';

Ez létrehozza az SQL logint a domain userhez, és annak rögtön meg is tiltja, hogy belogoljon. Erről a tárolt eljárásról egyébként azt írja a BOL, hogy elavult:
This feature will be removed in a future version of Microsoft SQL Server. Avoid using this feature in new development work, and plan to modify applications that currently use this feature. Use ALTER LOGIN instead.

Oké, és hogy használjuk az ALTER LOGIN-t? Hát, lehet DISABLE-t mondani, mint az előbb. De az nem egészen ugyanaz: a disable a sys.server_principals catalog is_disabled mezőjét állítja. A deny login pedig nem. Ő a sys. server_permissions catalog view-t bővíti egy sorral, amiben a CONNECT SQL jogot tiltja. Vagyis a fenti deny login script igazából így néz ki modernül:

CREATE LOGIN [SQL01\ddeny] FROM WINDOWS;
DENY CONNECT SQL TO [SQL01\ddeny];

És hab a tortán: ha ez nem elég, akár még ki is lockolhatunk egy accountot. Mi kell ehhez? egy olyan local account (vagy domain) policy, amiben van account lockout N próbálkozás után, plusz be kell állítanunk, hogy az SQL login ellenőrizze a policyt.

CREATE LOGIN slocked WITH PASSWORD='Password2',  CHECK_POLICY=ON;

Természetesen ez csak SQL loginra igaz, mivel a windows accountok lockoutját a Windows maga végzi. Rontsuk el párszor a jelszavát, és azt fogja mondani a jó jelszóra, hogy ki vagyunk lockolva. Erre két lehetőség van: vagy a jelszó ismeretében az ALTER LOGIN UNLOCK, vagy anélkül az ALTER LOGIN CHECK_POLICY=OFF, majd ON:

ALTER LOGIN slocked WITH PASSWORD='Password2' UNLOCK;
ALTER LOGIN slocked CHECK_POLICY=OFF;
ALTER LOGIN slocked CHECK_POLICY=ON;

Már csak egy kérdés maradt: mi a különbség a disable meg a deny között? Hát, a disable kb. arra jó, mint a Windows account disable: fel lehet vele függeszteni valaki-valami hozzáférését egy időre. A deny viszont azt a problémát tudja orvosolni, amikor egy csoportnak adtunk jogot, de azon belül egy kisebb csoportnak, vagy egyes személyeknek nem akarunk hozzáférést adni mégsem. A deny segítségével “kitakarhatjuk” őket a jogosultak köréből.

Az unlocknak pedig az a varázsa, hogy ha beállítjuk egy alkalmazásusernek, akkor simán ki tudja zárni az alkalmazást bárki az adatbázisból… :)

A count() ára

A count() függvénnyel kapcsolatosan van pár dolog, ami itt ugrál a fejemben már egy ideje, most kiborítom őket.

Először is: van egy komoly vallási kérdés a témában, miszerint vajon a count(1) vagy a count(*) a jobb. Ezt mind Oracle, mind MSSQL platformon keményen nyomják emberek. Legyünk egyszerűek, nézzünk meg egy végrehajtási tervet, és lássuk a valót: pontosan ugyanazt csinálja a szerver mindkét esetben. Lelke mélyén ő tudja, hogy pontosan ugyanaz a kérdés. Na de honnan van a válasz? Mivel azt kérdezzük ilyenkor, hogy hány sor is van a táblában, ez egy index scan lesz. És mivel az SQL Server okos, ezért a legkisebb lapszámú indexet fogja felolvasni. Nézzétek meg sok indexet hordozó táblákon, hogy milyen lehetetlen indexet bök ki. Általában azokat, amiknek nagy a NULL aránya, mivel azok kicsik. Persze filtered indexre nem ugrik.

A másik egy személyes élmény. Azt vettem észre egy szép napon, hogy a szerverek nagyon sok időt töltenek azzal, hogy select count(*) from sysfiles vagy select count(*) from sysobjects lekérdezéseket futtatnak. Hamar rájöttem, hogy ez egy marék Java alkalmazás műve, melyek sok kicsi lekérdezést indítottak, melyek előtt a JDBC driver futtatott egy health check kverit, hogy tudja, hogy jó az adatbáziskapcsolat, amit a poolból vett ki. Történetesen a health check drágább volt, mint sokszor a lekérdezés maga. A masteren a resourcedb miatt még join is van az execution planben. Mi egyszerűen átálltunk az alulmúlhatatlan select 1-re, de ha valakinek van hasonló gondja, inkább azt ajánlom, hogy válasszon egy táblát, és abból kérje le az első sort. Nekem ez sajnos a sok kis adatbázis miatt nem menő, mert senki nem fog mindegyikben táblát keresni, de másnak bejöhet. Nálam ez hatszoros telejsítménykülönbséget jelentett: 0.003 vs 0.018 total subtree costok jelentek meg.

Az utolsó sikeres DBCC

Előzőleg elmondtam ,hogy milyen fontos a DBCC CHECKDB futtatása, és erre gondolom mindenki kedvet kapott arra, hogy megnézze, mikor futott ez le az ő kis adatbázisain utoljára sikeresen. Felütötte mindenki a BOL-t, ééés… nem volt benne. Ja, ez is egyike azon undocumented apróságoknak:

DBCC DBINFO ('master') WITH TABLERESULTS;

Ez visszaad egy recordsetet, és abban select * where field = ‘dbi_dbccLastKnownGood’. Hát ennyi.