Scripts

Una delle necessità tipica degli sviluppatori è quella di inserire una riga oppure aggiornarne i valori se la riga è già presente. MySQL supporta il comando REPLACE:

http://dev.mysql.com/doc/refman/5.0/en/replace.html

oppure l’opzione INSERT . ON DUPLICATE KEY UPDATE:

http://dev.mysql.com/doc/refman/5.0/en/insert-on-duplicate.html

Con SQL Server si può ottenre lo stesso funzionamento, in modo più standard, usando il comando MERGE ed i Row Constructors.

Partendo da questo esempio:

CREATE TABLE dbo.MyTargetTable 
( 
    id INT NOT NULL PRIMARY KEY IDENTITY, 
    alternate_key VARCHAR(50) UNIQUE, 
    col_1 INT, 
    col_2 INT, 
    col_3 INT, 
    col_4 INT, 
    col_5 INT 
) 
GO

INSERT [dbo].[MyTargetTable] VALUES 
('GUQNH', 10, 100, 1000, 10000, 100000), 
('UJAHL', 20, 200, 2000, 20000, 200000), 
('YKXVW', 30, 300, 3000, 30000, 300000), 
('SXMOJ', 40, 400, 4000, 40000, 400000), 
('JTPGM', 50, 500, 5000, 50000, 500000), 
('ZITKS', 60, 600, 6000, 60000, 600000), 
('GGEYD', 70, 700, 7000, 70000, 700000), 
('UFXMS', 80, 800, 8000, 80000, 800000), 
('BNGGP', 90, 900, 9000, 90000, 900000), 
('AMUKO', 100, 1000, 10000, 100000, 1000000) 
GO

Per inserire o aggiornare una riga basta eseguire questo statement:

Script per identificare le porte TCP sulla quale è in ascolto SQL Server

------------------------------------------------------------------------
-- Version: 1
-- Release Date: 2012-08-01
-- Author: Davide Mauri (SolidQ)
-- License: Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Italy License.
------------------------------------------------------------------------
use tempdb
go

declare @is_named_instance bit;
declare @key nvarchar(1024)
declare @tcp_port nvarchar(1024);
declare @tcp_enabled bit;

declare @Protocols table (Value1 nvarchar(1024) null, Value2 nvarchar(1024) null, Data nvarchar(1024) null);

set @is_named_instance = case when @@servicename <> 'MSSQLSERVER' then 1 else 0 end; 

if (@is_named_instance = 1)
begin
    set @key = 'SOFTWARE\MICROSOFT\Microsoft SQL Server\'+@@servicename+'\MSSQLServer\Supersocketnetlib'
end
else
begin
    set @key = 'SOFTWARE\MICROSOFT\MSSQLServer\MSSQLServer\Supersocketnetlib'
end
;

insert into @Protocols exec master..xp_regread @rootkey='HKEY_LOCAL_MACHINE', @key=@key, @value_name='ProtocolList';

if exists(select * from @Protocols where Value2 = 'tcp') set @tcp_enabled = 1 else set @tcp_enabled = 0;

set @key = @key + '\TCP';
exec master..xp_regread @rootkey='HKEY_LOCAL_MACHINE', @key=@key, @value_name='TcpPort', @value=@tcp_port OUTPUT

select
    server_name = @@SERVERNAME,
    instance_name = @@SERVICENAME,
    tcp_enabled = @tcp_enabled,
    tcp_port = @tcp_port
;

Attenzione, lo script suddetto fa uso della stored procedure non documentata xp_regread! Con SQL Server 2012, invece, è sufficiente usare la DMV

Ola Hallengren ha rilasciato un aggiornamento degli script T-SQL che ha implementato per eseguire le più frequenti attività di manutenzione database; quelle attività che ogni DBA è chiamato ad eseguire e monitorare.

Si tratta di una soluzione basata su stored procedure, user-defined function, sqlcmd e job di SQL Server Agent che permette di eseguire Backups, Database Integrity Check, Index Optimization con Reorganize o Rebuild in funzione della configurazione specificata.

La soluzione di Ola Hallengren viene già utilizzata su diverse installazioni (critiche) di SQL Server e da diverse organizzazioni in tutto il mondo; è raccomandata da SQL Server community experts, è stata citata da Gianluca Hotz nella sessione Database Administration by Examples tenuta alla SQL Conference 2011… ed è pure gratuita!!

Capita, di frequente, di avere la necessità di stabilire quale sia stata la cronologia delle modifiche effettuate agli oggetti di un database, ad esempio alle Stored Procedure.
Lo script restituisce la cronologia di modifica a tutti gli oggetti o, a particolari tipologie di oggetti. Se si vuole ottenere la cronologia di modifica delle SP basta inserire nella sezione di assegnazione delle variabili l’istruzione SET @obj_type=‘P’.
Se il database in esame prevede l’uso degli oggetti di supporto per il diagramming l’elenco delle SP include anche SP come sp_creatediagram etc., che appartengono, di default, allo schema dbo.
Viene adottato un criterio di ordinamento per data modifica e tipo oggetto, ma il criterio è personalizzabile cambiando il valore di @sqlord.

Ci si può trovare nella situazione di dover eliminare e ricreare (successivamente) le dipendenze (FOREIGN KEY) da una tabella alterando gli oggetti che dipendono da essa.

Pensiamo, ad esempio, alla necessità di eliminare e ricreare una tabella che ha integrità referenziale con altre, uno degli step necessari è appunto l’eliminazione delle dipendenze (FOREIGN KEY) sugli oggetti che dipendono dalla tabella da ricreare.

Il seguente comando T-SQL permette di individuare facilmente i comandi di eliminazione e ripristino delle FOREIGN KEY sulle tabelle che dipendono dalla tabella citata nella clausola WHERE del comando.

Qual è il rischio in cui si può incorrere quando un progetto viene sviluppato da più persone, ovvero quando un database viene modellato da più mani?

Creare un indice che esiste già! :-(

SQL Server non fa nulla per venirci in aiuto o, almeno, non fa nulla in automatico.
Con questo script è possibile ottenere una lista degli indici identici / duplicati.

;WITH tIndex AS (
SELECT    object_id AS id ,    index_id AS indid ,    type,     name ,    (        SELECT            colid as colPosition        FROM sys.sysindexkeys        WHERE id = I.object_id AND indid = I.index_id            AND keyno > 0        FOR XML PATH      ) AS cols ,    (        SELECT includedCol FROM        (            SELECT                CASE keyno WHEN 0 THEN colid ELSE NULL END AS includedCol            FROM sys.sysindexkeys            WHERE id = I.object_id AND indid = I.index_id        ) T0        order by includedCol        FOR XML PATH    ) AS inc
FROM sys.indexes AS I )
SELECT    object_schema_name ( T1.id ) + ‘.’ + object_name ( T1.id ) as tableName,    T1.name AS indexName,    T2.name AS duplicateIndex,    S.used_page_count * 8 indexSizeKB
FROM tIndex AS T1
JOIN tIndex AS T2 ON     T1.type = T2.type AND    T1.id = T2.id AND     T1.indid < T2.indid AND    T1.cols = T2.cols AND    T1.inc = T2.inc
JOIN sys.dm_db_partition_stats  AS S ON    S.[object_id] = T2.id AND S.index_id = T2.indId
ORDER BY object_schema_name ( T1.id ) + ‘.’ + object_name ( T1.id ), T1.name
go

Possiamo facilmente immaginare l’inefficienza introdotta dalla doppia indicizzazione (ugualmente ordinata) di un attributo: SQL Server dovrà mantenere aggiornati due indici, organizzati in strutture B-Tree letteralmente identiche, senza trarre alcun beneficio da una delle due.

La stored procedure dbo.usp_drop_double_more_index, definita di seguito, permette di individuare ed eliminare i casi di doppia (tripla, ecc…) indicizzazione dei medesimi attributi.

use [AdventureWorks] go

if object_id(‘usp_drop_double_more_index’) is not null   drop procedure dbo.usp_drop_double_more_index go

create procedure dbo.usp_drop_double_more_index (   @mode tinyint,   @object_name varchar(4000),   @table_type varchar(10),   @index_name_prefix_order varchar(8),   @debug tinyint ) as begin   /*     Descrizione:       Individua ed elimina i casi di doppia (tripla, ecc..)       indicizzazione sui medesimi attributi

L’aggiornamento dei dati di una tabella pivot in Microsoft Excel, viene tipicamente configurato per essere eseguito in modo automatico all’apertura del documento stesso. In alcune situazioni, però, potrebbe essere richiesto un aggiornamento automatico ogni X minuti oppure al verificarsi di un determinato evento senza dover necessariamente aprire il file Excel che contiene la tabella pivot.

La stored procedure dbo.USP_DMO_Excel_Pivot_RefreshTable, definita di seguito, utilizza OLE Automation Stored Procedures per aggiornare i dati esposti su una tabella pivot di un determinato file Excel.

Come posso conoscere la data e l’ora dell’ultimo UPDATE eseguito su una tabella da parte di un utente ?

Una delle DMVs (Index Related Dynamic Management Views and Functions), disponibili dalla versione 2005 di SQL Server, ci permette di rispondere a questa domanda.

Possiamo infatti utilizzare la DMV sys.dm_db_index_usage_stats che con i sui differenti contatori, basati sulle operazioni eseguite sugli indici, ci permette di conoscere, ad esempio, la data e l’ora dell’ultimo comando UPDATE eseguito su una determinata tabella.

Una relazione tra le tabelle di un database è espressa nei valori dei dati attraverso una chiave primaria (Primary Key) ed una chiave esterna (Foreign Key).

La chiave primaria è rappresenta da una o più colonne di una tabella i cui valori identificano in modo univoco ogni riga della tabella stessa. La chiave esterna è rappresenta da una o più colonne i cui valori sono gli stessi della chiave primaria.