Procedura dettagliata: confronto degli schemi di un database e di un progetto di database

Articolo
08/11/2011

Le informazioni contenute in questo argomento sono valide per:

Visual Studio Ultimate	Visual Studio Premium	Visual Studio Professional	Visual Studio Express

In questa procedura dettagliata, si confronta lo schema di un progetto di database con lo schema di un database tramite Visual Studio. a seconda di come il team utilizza il progetto di database e il database, può essere necessario copiare modifiche dello schema in una direzione o nell'altra. È possibile riscontrare gli scenari tipici seguenti mentre il team procede con il ciclo di vita dello sviluppo del database:

Il progetto è l'origine e il database è la destinazione. È possibile utilizzare un progetto di database per sviluppare o gestire un database. Dopo aver apportato modifiche nello schema del progetto, è possibile copiarle nel database incluso in un server di gestione temporanea. In seguito, il team può distribuire il database su un server di produzione.

Dal confronto eseguito in questa procedura dettagliata viene generato uno script DDL (Data Definition Language) basato sulle differenze tra gli schemi. È quindi possibile utilizzare questo script per applicare tutto o parte del progetto di database al database. Per ulteriori informazioni, vedere Propagare le modifiche dal progetto al database.
Il database è l'origine e il progetto è la destinazione. È possibile che nello schema di un database di produzione venga rilevato un errore o che lo schema diventi obsoleto e richieda un aggiornamento. In questo caso potrebbe essere necessario che il team applichi immediatamente un aggiornamento al database. Per mantenere la sincronizzazione tra il progetto e il database, è possibile importare quindi l'aggiornamento in un progetto di database. Per ulteriori informazioni, vedere Procedura: importare aggiornamenti da un database nel progetto di database.

In questa procedura dettagliata vengono illustrate le seguenti attività:

Fase di impostazione

Creare un progetto di database. Il nuovo progetto all'inizio è vuoto.
Importare uno schema di database da uno script.
Configurare, compilare e distribuire il progetto di database al server database. Il database e il progetto hanno schemi identici.

Fase di produzione

Aggiungere una tabella al progetto di database. Viene aggiunta una tabella con tre colonne denominata InternationalShippers.
Confrontare i due schemi. In questo confronto il progetto di database viene designato come origine e il database come destinazione. Nei risultati la tabella InternationalShippers viene pertanto riportata come nuova tabella nel progetto di database.
Propagare le modifiche dal progetto al database. È possibile propagare la nuova tabella InternationalShippers dal progetto di database al database distribuito. Se si segue questa procedura, alcune parti del database di esempio verranno sovrascritte.

Nota

È inoltre possibile propagare le modifiche da un database a un progetto di database. Per ulteriori informazioni, vedere Procedura: importare aggiornamenti da un database nel progetto di database.

Prerequisiti

Per completare questa procedura dettagliata, è necessario disporre delle applicazioni e delle autorizzazioni seguenti:

SQL Server 2008
Autorizzazioni per la creazione e l'aggiornamento di database nel server database di destinazione
Visual Studio Premium oppure Visual Studio Ultimate

Fase di impostazione

Creare un progetto di database

Per creare un progetto di database

Scegliere Nuovo dal menu File, quindi fare clic su Progetto.

Verrà visualizzata la finestra di dialogo Nuovo progetto.
In Modelli installati espandere il nodo Database, quindi fare clic su SQL Server.
Nell'elenco dei modelli fare clic su Progetto di database di SQL Server 2008.
Digitare CompareProject in Nome, quindi scegliere OK.

Il progetto CompareProject vuoto viene aperto e visualizzato in Esplora soluzioni.

Importare uno schema del database da uno script

Per creare uno script da cui sia possibile importare uno schema

Scegliere Nuovo dal menu File, quindi fare clic su File.

Verrà visualizzata la finestra di dialogo Nuovo file.
Se non è già evidenziato, selezionare Generale nell'elenco Categorie.
Nell'elenco Modelli selezionare File SQL, quindi fare clic su Apri.

Verrà aperto l'editor Transact-SQL.

Copiare il codice seguente e incollarlo nell'editor Transact-SQL.

PRINT N'Creating Sales...';
GO
CREATE SCHEMA [Sales]
    AUTHORIZATION [dbo];
GO
PRINT N'Creating Sales.Customer...';
GO
CREATE TABLE [Sales].[Customer] (
    [CustomerID]   INT IDENTITY (1, 1) NOT NULL,
    [CustomerName] NVARCHAR (40) NOT NULL,
    [YTDOrders] INT NOT NULL,
    [YTDSales] INT NOT NULL
);
GO
PRINT N'Creating Sales.Orders...';
GO
CREATE TABLE [Sales].[Orders] (
    [CustomerID] INT NOT NULL,
    [OrderID] INT IDENTITY (1, 1) NOT NULL,
    [OrderDate] DATETIME NOT NULL,
    [FilledDate] DATETIME NULL,
    [Status] CHAR (1) NOT NULL,
    [Amount] INT NOT NULL
);
GO
PRINT N'Creating Sales.Def_Customer_YTDOrders...';
GO
ALTER TABLE [Sales].[Customer]
    ADD CONSTRAINT [Def_Customer_YTDOrders] DEFAULT 0 FOR [YTDOrders];
GO
PRINT N'Creating Sales.Def_Customer_YTDSales...';
GO
ALTER TABLE [Sales].[Customer]
    ADD CONSTRAINT [Def_Customer_YTDSales] DEFAULT 0 FOR [YTDSales];
GO
PRINT N'Creating Sales.Def_Orders_OrderDate...';
GO
ALTER TABLE [Sales].[Orders]
    ADD CONSTRAINT [Def_Orders_OrderDate] DEFAULT GetDate() FOR [OrderDate];
GO
PRINT N'Creating Sales.Def_Orders_Status...';
GO
ALTER TABLE [Sales].[Orders]
    ADD CONSTRAINT [Def_Orders_Status] DEFAULT 'O' FOR [Status];
GO
PRINT N'Creating Sales.PK_Customer_CustID...';
GO
ALTER TABLE [Sales].[Customer]
    ADD CONSTRAINT [PK_Customer_CustID] PRIMARY KEY CLUSTERED ([CustomerID] ASC) WITH (ALLOW_PAGE_LOCKS = ON, ALLOW_ROW_LOCKS = ON, PAD_INDEX = OFF, IGNORE_DUP_KEY = OFF, STATISTICS_NORECOMPUTE = OFF);
GO
PRINT N'Creating Sales.PK_Orders_OrderID...';
GO
ALTER TABLE [Sales].[Orders]
    ADD CONSTRAINT [PK_Orders_OrderID] PRIMARY KEY CLUSTERED ([OrderID] ASC) WITH (ALLOW_PAGE_LOCKS = ON, ALLOW_ROW_LOCKS = ON, PAD_INDEX = OFF, IGNORE_DUP_KEY = OFF, STATISTICS_NORECOMPUTE = OFF);
GO
PRINT N'Creating Sales.FK_Orders_Customer_CustID...';
GO
ALTER TABLE [Sales].[Orders]
    ADD CONSTRAINT [FK_Orders_Customer_CustID] FOREIGN KEY ([CustomerID]) REFERENCES [Sales].[Customer] ([CustomerID]) ON DELETE NO ACTION ON UPDATE NO ACTION;
GO
PRINT N'Creating Sales.CK_Orders_FilledDate...';
GO
ALTER TABLE [Sales].[Orders]
    ADD CONSTRAINT [CK_Orders_FilledDate] CHECK ((FilledDate >= OrderDate) AND (FilledDate < '01/01/2010'));
GO
PRINT N'Creating Sales.CK_Orders_OrderDate...';
GO
ALTER TABLE [Sales].[Orders]
    ADD CONSTRAINT [CK_Orders_OrderDate] CHECK ((OrderDate > '01/01/2005') and (OrderDate < '01/01/2020'));
GO
PRINT N'Creating Sales.uspCancelOrder...';
GO
CREATE PROCEDURE [Sales].[uspCancelOrder]
@OrderID INT
AS
BEGIN
DECLARE @Delta INT, @CustomerID INT
BEGIN TRANSACTION
    SELECT @Delta = [Amount], @CustomerID = [CustomerID]
     FROM [Sales].[Orders] WHERE [OrderID] = @OrderID;

UPDATE [Sales].[Orders]
   SET [Status] = 'X'
WHERE [OrderID] = @OrderID;

UPDATE [Sales].[Customer]
   SET
   YTDOrders = YTDOrders - @Delta
    WHERE [CustomerID] = @CustomerID
COMMIT TRANSACTION
END
GO
PRINT N'Creating Sales.uspFillOrder...';
GO
CREATE PROCEDURE [Sales].[uspFillOrder]
@OrderID INT, @FilledDate DATETIME
AS
BEGIN
DECLARE @Delta INT, @CustomerID INT
BEGIN TRANSACTION
    SELECT @Delta = [Amount], @CustomerID = [CustomerID]
     FROM [Sales].[Orders] WHERE [OrderID] = @OrderID;

UPDATE [Sales].[Orders]
   SET [Status] = 'F',
       [FilledDate] = @FilledDate
WHERE [OrderID] = @OrderID;

UPDATE [Sales].[Customer]
   SET
   YTDSales = YTDSales - @Delta
    WHERE [CustomerID] = @CustomerID
COMMIT TRANSACTION
END
GO
PRINT N'Creating Sales.uspNewCustomer...';
GO
CREATE PROCEDURE [Sales].[uspNewCustomer]
@CustomerName NVARCHAR (40)
AS
BEGIN
INSERT INTO [Sales].[Customer] (CustomerName) VALUES (@CustomerName);
SELECT SCOPE_IDENTITY()
END
GO
PRINT N'Creating Sales.uspPlaceNewOrder...';
GO
CREATE PROCEDURE [Sales].[uspPlaceNewOrder]
@CustomerID INT, @Amount INT, @OrderDate DATETIME, @Status CHAR (1)='O'
AS
BEGIN
DECLARE @RC INT
BEGIN TRANSACTION
INSERT INTO [Sales].[Orders] (CustomerID, OrderDate, FilledDate, Status, Amount) 
     VALUES (@CustomerID, @OrderDate, NULL, @Status, @Amount)
SELECT @RC = SCOPE_IDENTITY();
UPDATE [Sales].[Customer]
   SET
   YTDOrders = YTDOrders + @Amount
    WHERE [CustomerID] = @CustomerID
COMMIT TRANSACTION
RETURN @RC
END
GO

Scegliere Salva SqlQuery_1.sql con nome dal menu File.

Verrà visualizzata la finestra di dialogo Salva file con nome.
Digitare SampleImportScript.sql in Nome oggetto.

È possibile salvare il file in qualsiasi percorso sul computer. Prendere nota del percorso poiché sarà necessario utilizzarlo nella procedura successiva.
Scegliere Salva.
Scegliere Chiudi soluzione dal menu File.

A questo punto, è possibile creare un progetto di database e importare lo schema dallo script creato.

Per importare uno schema di database da uno script

Scegliere Importa schema database dal menu Progetto.
Scegliere Avanti dopo avere letto la schermata iniziale.
Fare clic su Sfoglia e passare al percorso in cui è stato salvato il file SampleImportScript.sql.
Fare doppio clic sul file SampleImportScript.sql, quindi scegliere Fine.

Lo script verrà importato e gli oggetti che vi sono definiti verranno aggiunti al progetto di database.
Esaminare il riepilogo e scegliere quindi Fine.

Configurare, compilare e distribuire il progetto di database

Tramite queste procedure è possibile creare un database con lo schema importato in un ambiente di sviluppo isolato (o sandbox) nel quale è possibile sviluppare e testare il database.

Per configurare e compilare il progetto di database

Fare clic sul progetto CompareProject in Esplora soluzioni.
Scegliere Proprietà CompareProject nel menu Progetto.

Verranno visualizzate le proprietà del progetto CompareProject.
Fare clic sulla scheda Distribuisci.
Nell'elenco Azione di distribuzione fare clic su Crea uno script di distribuzione (.sql) e distribuisci nel database.
Da Impostazioni database di destinazione scegliere Modifica.
Nella finestra di dialogo Proprietà connessione impostare le proprietà di connessione per il database che si desidera utilizzare, quindi fare clic su OK.

Nella casella Connessione di destinazione verrà visualizzata la stringa di connessione corretta.

Attenzione

È consigliabile creare il database in un server di test, in un server di sviluppo o nel computer locale. Non utilizzare un server di produzione.
Digitare CompareProjectDB nella casella di testo Nome database di destinazione.
Scegliere Salva tutto dal menu File.
Scegliere Compila soluzione dal menu Compila.

Lo script di distribuzione verrà compilato in base alle proprietà del progetto appena impostate. Lo stato della compilazione verrà visualizzato nella finestra Output e nell'ultima riga viene visualizzato il messaggio Compilazione: 1 completate o aggiornate.

Attenzione
È consigliabile creare il database in un server di test, in un server di sviluppo o nel computer locale. Non utilizzare un server di produzione.

Per distribuire il progetto di database

Fare clic sul progetto CompareProject in Esplora soluzioni.
Scegliere Distribuisci CompareProject dal menu Compila.

In alternativa è possibile fare clic con il pulsante destro del mouse sul progetto in Esplora soluzioni e scegliere quindi Distribuisci.

Attenzione

È consigliabile eseguire questa distribuzione in un server di test, in un server di sviluppo o nel computer locale. Non utilizzare il server di produzione.

Il progetto di database viene distribuito in un nuovo database. Lo stato della distribuzione viene visualizzato nella finestra Output e nell'ultima riga viene visualizzato il messaggio Distribuzione completata.

Attenzione
È consigliabile eseguire questa distribuzione in un server di test, in un server di sviluppo o nel computer locale. Non utilizzare il server di produzione.

Fase di produzione

Aggiungere una tabella al progetto di database

Per aggiungere una tabella al progetto

Scegliere Visualizzazione schema database dal menu Visualizza.

Verrà aperta la Visualizzazione schema con lo schema del progetto CompareProject.
In Visualizzazione schema espandere il nodo CompareProject e il nodo Schemi.
Fare clic con il pulsante destro del mouse su Sales, scegliere Aggiungi e quindi Tabella.

Verrà visualizzata la finestra di dialogo Aggiungi nuovo elemento - CompareProject.
In Modelli fare clic su Tabella.
Digitare InternationalShippers nella casella Nome e fare clic su Aggiungi.

Una tabella denominata InternationalShippers verrà aggiunta al progetto CompareProject. La definizione della tabella verrà visualizzata nell'editor Transact-SQL.

Modificare lo script SQL nel file InternationalShippers.table.sql in base alle istruzioni seguenti:

CREATE TABLE [Sales].[InternationalShippers]
(
[ShipperID] [int] NOT NULL IDENTITY(1,1),
[CompanyName] [nvarchar] (40) NOT NULL,
[Region] [nvarchar] (40) NOT NULL,
[Phone] [nvarchar] (24) NULL
) ON [PRIMARY]

Fare clic su Salva InternationalShippers.table.sql.
In Visualizzazione schema fare clic con il pulsante destro del mouse sulla tabella InternationalShippers, quindi scegliere Visualizza file in Esplora soluzioni.

Il file InternationalShippers.sql verrà evidenziato in Esplora soluzioni.
Premere F4.

Verrà visualizzata la finestra di dialogo Proprietà con le proprietà del file InternationalShippers.table.sql. La proprietà Build Action viene impostata su Compilazione, vale a dire che il file deve essere analizzato e convalidato e che vi è inclusa la definizione per un oggetto di database.

Confrontare i due schemi

Per confrontare i due schemi

Scegliere Confronto schema dal menu Dati, quindi Nuovo confronto schema.
Verrà visualizzata la finestra di dialogo Nuovo confronto schema.
Nell'elenco Schema di destinazione selezionare Database e specificare una connessione al database distribuito precedentemente in questa procedura dettagliata, quindi fare clic su OK.

Lo schema del database viene confrontato con lo schema del progetto modificato e i risultati vengono visualizzati nella finestra Confronto schema. Nella colonna CompareProject verrà visualizzata la tabella [Sales].[InternationalShippers]. Lo stato della tabella è Nuovo, mentre l'azione di aggiornamento è Crea. Se le modifiche vengono propagate in questa fase, la tabella verrà creata nel database di destinazione. Per ulteriori informazioni, vedere la procedura seguente.

Per rivedere e ignorare le differenze previste

Nell'elenco di risultati del confronto scorrere fino al nodo File SQL.

Per il database di destinazione, nell'elenco vengono visualizzate due righe il cui stato è impostato su Mancante: una riga per il file del gruppo di file e una riga per il file di log.
Fare clic nella colonna Azione di aggiornamento di ogni riga per impostare l'azione su Ignora.

Quando si aggiorna uno schema di database, non si modifica in genere il file del gruppo di file o il file di log associato al database di destinazione. Impostando l'azione su Ignora, nel database di destinazione continueranno a essere utilizzati i file correnti.

Se lo si desidera, successivamente è possibile aggiornare il database di destinazione in modo che corrisponda al database di origine.

Propagare le modifiche dal progetto al database

Per propagare le modifiche al database di destinazione

Nella finestra Confronto schema fare clic su Scrivi aggiornamenti.

Nota

Il pulsante Scrivi aggiornamenti potrebbe essere disabilitato se nel progetto sono presenti uno o più errori. In questo caso viene visualizzato un messaggio nella barra di stato di Confronto schema.

Verranno eseguite le azioni elencate nella finestra Confronto schema, tra cui l'azione Crea per la tabella InternationalShippers. Questa sincronizzazione consente di modificare lo schema del database in modo che corrisponda al progetto di database. Una volta completata l'operazione di aggiornamento, gli schemi vengono confrontati nuovamente e i risultati vengono aggiornati.

Durante l'aggiornamento dello schema di destinazione è possibile annullare l'operazione scegliendo Confronto schema dal menu Dati e facendo clic su Interrompi scrittura sulla destinazione.

Attenzione
Poiché alcune modifiche dello schema non possono essere eseguite nell'ambito di una transazione, è possibile che si verifichi una perdita di dati se si annulla un'operazione di aggiornamento. Una tabella nel database di destinazione, ad esempio, potrebbe essere stata eliminata in vista della relativa nuova creazione. Se si annulla l'aggiornamento in quel momento, è possibile che la tabella vada persa. Nel caso si verifichi questo tipo di perdita di dati, è consigliabile ripetere il confronto degli schemi.

Poiché alcune modifiche dello schema non possono essere eseguite nell'ambito di una transazione, è possibile che si verifichi una perdita di dati se si annulla un'operazione di aggiornamento. Una tabella nel database di destinazione, ad esempio, potrebbe essere stata eliminata in vista della relativa nuova creazione. Se si annulla l'aggiornamento in quel momento, è possibile che la tabella vada persa. Nel caso si verifichi questo tipo di perdita di dati, è consigliabile ripetere il confronto degli schemi.

Vedere anche

Attività

Procedura: confrontare gli schemi di database

Procedura: confrontare e sincronizzare i dati di due database

Concetti

Confrontare e sincronizzare gli schemi di database

Confrontare e sincronizzare i dati in una o più tabelle e i dati di un database di riferimento

Condividi tramite