Qualche volta capita di dover fare delle query al volo, per ricavare delle informazioni di programmazione, così una tantum. Spesso a me capita di dover verificare quanto sia lunga la dimensione massima delle descrizioni in un campo della tabella.

Ecco allora, al volo, una query per SQL Server, magari anche poco ottimizzata, che supplisce il caso in questione.

SELECT     TOP (1) LEN(NOME_CAMPO) AS A
FROM         NOME_TABELLA
GROUP BY NOME_CAMPO
ORDER BY A DESC

Se vi pongono una domanda apparentemente banale tipo quella di sapere quale è il famoso giorno di deadline, oltre il quale il vostro db salta per aria, la risposta la potrete trovare solo facendo due conticini con la vostra fidata calcolatrice.

La premessa indispensabile è avere un db completo e operativo, cosa che non sempre è possibile, specie in sede di preventivazione, dove si può solo immaginare quale potrà essere la struttura finale del db.

In ogni caso, questo link della Microsoft su come si calconano le dimensioni di una tabella può tornare utile, il tutto con una buona conoscenza delle dimensioni dei tipi di dato, che altrimenti si possono recuperare qui.

SP, in questo caso, sta per Stored Procedure.

Se siete alle prese con un database relazionale Microsoft, SQL Server nello specifico, e avete bisogno di vedere cosa sta succedendo durante l'esecuzione di una query o di una stored procedure, il tool che fa per voi è il Profiler, incluso nelle versioni commerciali (quindi niente SQL Express).

Di default quando si esegue il profiler, questo viene eseguito al minimo, quindi mostra poche informazioni che non sempre sono essenziali; per esempio per poter visionare quali sono i comani eseguiti dall'interno delle vostre procedure bisogna modificare il livello di tracciatura (cioè delle informazioni raccolte).

Questa modifica si può apportare quando si crea un nuovo profilo o mettendo in pausa il profilo corrente; mai mentre il profilo è in esecuzione.

Una volta lanciata la finestra delle proprietà, andando nel tab degli eventi e selezionando la spunta in basso a destra che vi mostra tutti gli eventi, potrete scorrere la griglia fino ad arrivare alla voce Stored Procedure, e al suo interno selezionare SP:StmtCompleted, che permette di visualizzare i comandi uno per  uno dopo la loro esecuzione (per lo starting, invece, selezionare SP:StmtStarted, che indica quando lo statement è stato lanciato).

Se si ha la ncessità di trovare il numero di righe, colonne, dimensioni in byte di tutte le tabelle all'interno di un database senza dover aprire ogni tabella a mano, si può utilizzare lo script qui sotto, che interrogando le tabelle di sistema popola una tabella temporanea con tutti i dati sopra riportati.

CREATE TABLE #temp (
       table_name sysname ,
       row_count int,
       reserved_size varchar(50),
       data_size varchar(50),
       index_size varchar(50),
       unused_size varchar(50))
SET NOCOUNT ON
INSERT     #temp
EXEC       sp_msforeachtable 'sp_spaceused ''?'''
SELECT     a.table_name,
           a.row_count,
           count(*) as col_count,
           a.data_size
FROM       #temp a
INNER JOIN information_schema.columns b
           ON a.table_name collate database_default
                = b.table_name collate database_default
GROUP BY   a.table_name, a.row_count, a.data_size
ORDER BY   CAST(Replace(a.data_size, ' KB', '') as integer) desc
DROP TABLE #temp

L'altro girono ho installato SQL Server 2005, ma non l'ho usato subito perchè stavo finendo di preparare la macchina appena formattata. Solo oggi ho realizzato che il Setup era stato fatto, ma parzialmente, nonostante avessi specificatamente richiesto la sua installazione.

Allora ho aperto di nuovo il setup per verificare, e SQL Management Studio non c'era. Nemmeno la cartella Tools presenteva tracce del software.

Allora ho preso il DVD di SQL Server e fatto partire una nuova installazione (in modo da selezionare il componente mancante), ma uno strano errore diceva di non poter proseguire perchè il Management Studio risultava già installato. Dove, onestamente non saprei.

La soluzione (di un problema che nulla ha a che vedere con la SP2 che non avevo ancora installato, quindi escludo potenziali problemi legati al DVD che contiene lo strumento senza SP)

1. Pannello di controllo, Installa applicazione, SQL Server 2005 e scegliere di rimuovere i workstation components
2. Rinominare la cartella tools in C:\Program Files\Microsoft SQL Server\90
3. Andare nel DVD di SQL Server (es. D:\ENGLISH\SQL2005\DEVELOPER\SQL Server x86\Tools) e lanciare il setup.exe, scegliere i componenti che vi occorrono e concludere l'installazione

Sapere "utilizzare" un database da un punto di vista di amministratore, significa anche saperlo mantenere. L'utilizzo eccessivo del db, provoca a lungo andare una frammentazione dei dati nelle pagine, e si rileva quindi necessario riorganizzare o reindicizzare una o più tabelle al fine di ripristinare una buona performance sia in lettura che in scrittura.

Normalmente la percentuale di frammentazione dovrebbe attestarsi non oltre il 35% (Microsoft dice anche il 25%), limite oltre il quale le performance della tabella o del db iniziano a scemare.

Per verificare la percentuale di frammentazione si può ricorrere a questa istruzione:

DECLARE @object_name VARCHAR(20);
SET @object_name = 'TableName'

DBCC SHOWCONTIG (@object_name) WITH TABLERESULTS, ALL_INDEXES

valida per SQL 2000 e SQL 2005 oppure una più elegante

DECLARE @db_id SMALLINT;
DECLARE @object_id INT;

SET @db_id = DB_ID(N'DBName');
SET @object_id = OBJECT_ID(N'TableName');

SELECT * FROM sys.dm_db_index_physical_stats(@db_id, @object_id, NULL, NULL , 'SAMPLED');

valida per il solo SQL 2005.

Nel primo caso la colonna di riferimento sarà la "LogicalFragmentation" nel secondo "avg_fragmentation_in_percent".

Quando questo valore è al di sopra della soglia, si rende necessaria la reindicizzazione. Come?

Un sistema veloce e rapido per reindicizzare tutte le tabelle presenti in SQL Server 2005 grazie all'usilio della SP "nascosta" MSForEachTable può essere questo mostrato qui sotto.

EXECUTE sp_MSForEachTable @command1 =’ALTER INDEX ALL ON ? REBUILD WITH (FILLFACTOR = 90, SORT_IN_TEMPDB = ON, STATISTICS_NORECOMPUTE = OFF, ONLINE = OFF);’

Questo comando cicla tutte le tabelle e reindicizza tutti gli indici ricostruendoli.

Se invece si vuole essere più specifici e reindicizzare la singola tabella allora si può utilizzare quest'altro comando:

DBCC DBREINDEX ('NomeTabella', '', ValoreDiFrammentazione)

valido per SQL 2000 e SQL 2005.

Si tenga tuttavia presente che la ricostruzione degli indici porta via tempo macchina prezioso durante il quale le performance si fanno sentire. Quindi se non è proprio necessaria la ricostruzione, è meglio ipotizzare una semplice riorganizzazione.

A tal proposito all'interno del BOL, sotto la voce sys.dm_db_index_physical_stats c'è un bellissimo esempio che in base la percentuale di frammentazione sceglie se riscotruire o riorganizzare.

Ok, diciamo che questa soluzione l'ho scritta nel 2001, all'epoca non facevo uso di blogs, quindi me la sono tenuta per me e per qualche - forse - post negli apposti NG, ma nulla di più.
Oggi stavo mettendo le mani su di un mezzo programmino che mi sto scrivendo per uso interno, e cercavo un sistema elegante per sapere se la mia Identity Column con la prossima insert mi sfora il valore massimo consentito. Beh, gira che rigira, o ho cercato male io o effettivamente nulla di più elegante non ci sta.
Pure cercando nel mio account di SQL Magazine non ho trovato nulla, solo un post del 2001 di Moran ma che lascia forti dubbi e tutto dipende da quanto si usa il DB.
Non mi ritengo un DBA ... questo no, e forse questa soluzione verrà castrata immediatamente, però la ritengo semplice e funzionale. Quindi a vostra disposizione.

Velocemente commento con il fatto che, ovviamente, la tabella deve avere una colonna di tipo identity e che quello che ritorna è il valore massimo a seconda della scala di precisione adottata.

Con questo valore di ritorno, semplicemente facendo una cosa del tipo

Possiamo sapere se stiamo nei limiti oppure se con qualche altro check dobbiamo fare altro.