Procedura dettagliata: creazione ed esecuzione di un piano di generazione dati

Articolo
08/11/2011

In questa procedura dettagliata viene illustrato come creare ed eseguire un piano di generazione dati per compilare un database di test con dati generati in modo casuale. Viene descritto innanzitutto come creare un progetto di database e come distribuirlo in un database di test isolato. È possibile utilizzare il database isolato per testare la generazione dei dati senza alterare i dati di produzione o il database.

Prerequisiti

Per completare la procedura dettagliata, è necessario che siano installati i prodotti seguenti:

Visual Studio Premium
SQL Server 2008 oppure SQL Server 2005

Creazione del progetto di database

Creare innanzitutto un progetto di database e importare lo schema da uno script.

Nota

In un ambiente team è possibile estrarre un progetto esistente dal sistema di controllo della versione per utilizzarlo in un progetto di database. Per ulteriori informazioni, vedere Avvio dello sviluppo in team di database.

Per creare lo script di database

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 Transact-SQL seguente e incollarlo nell'editor Transact-SQL.

PRINT N'Creating dbo.Customer...';
GO
CREATE TABLE [dbo].[Customer] (
    [CustomerId] UNIQUEIDENTIFIER NOT NULL,
    [UserId]     UNIQUEIDENTIFIER NOT NULL,
    [UserName]   VARCHAR (256)    NOT NULL
);
GO
PRINT N'Creating dbo.Menu...';
GO
CREATE TABLE [dbo].[Menu] (
    [MenuId]       UNIQUEIDENTIFIER NOT NULL,
    [RestaurantId] UNIQUEIDENTIFIER NOT NULL,
    [StartDate]    DATETIME         NOT NULL,
    [EndDate]      DATETIME         NOT NULL,
    [MenuType]     VARCHAR (50)     NULL
);
GO
PRINT N'Creating dbo.MenuItem...';
GO
CREATE TABLE [dbo].[MenuItem] (
    [MenuItemId]      UNIQUEIDENTIFIER NOT NULL,
    [MenuId]          UNIQUEIDENTIFIER NOT NULL,
    [Name]            VARCHAR (128)    NULL,
    [Description]     VARCHAR (512)    NULL,
    [ImageLocation]   VARCHAR (MAX)    NULL,
    [Price]           MONEY            NULL,
    [PreparationTime] INT              NULL
);
GO
PRINT N'Creating dbo.Order...';
GO
CREATE TABLE [dbo].[Order] (
    [OrderId]          UNIQUEIDENTIFIER NOT NULL,
    [SubmittedDate]    SMALLDATETIME    NOT NULL,
    [CustomerID]       UNIQUEIDENTIFIER NOT NULL,
    [Total]            MONEY            NOT NULL,
    [ContactTelephone] CHAR (20)        NULL,
    [PostalCode]       CHAR (10)        NULL,
    [State]            CHAR (2)         NULL,
    [StreetAddress]    VARCHAR (75)     NULL,
    [City]             VARCHAR (25)     NULL
);
GO
PRINT N'Creating dbo.OrderDetail...';
GO
CREATE TABLE [dbo].[OrderDetail] (
    [OrderDetailId]     UNIQUEIDENTIFIER NOT NULL,
    [OrderId]           UNIQUEIDENTIFIER NOT NULL,
    [RestaurantId]      UNIQUEIDENTIFIER NOT NULL,
    [MenuItemId]        UNIQUEIDENTIFIER NOT NULL,
    [DeliveryId]        UNIQUEIDENTIFIER NOT NULL,
    [Quantity]          INT              NOT NULL,
    [UnitCost]          MONEY            NOT NULL,
    [Status]            NCHAR (20)       NOT NULL,
    [StatusUpdatedTime] SMALLDATETIME    NOT NULL,
    [WorkflowId]        UNIQUEIDENTIFIER NOT NULL,
    [ETA]               SMALLDATETIME    NULL
);
GO
PRINT N'Creating dbo.OrderPayment...';
GO
CREATE TABLE [dbo].[OrderPayment] (
    [PaymentID]        UNIQUEIDENTIFIER NOT NULL,
    [OrderID]          UNIQUEIDENTIFIER NOT NULL,
    [CreditCardNumber] CHAR (4)         NULL,
    [NameOnCard]       VARCHAR (75)     NULL,
    [Address]          VARCHAR (50)     NULL,
    [Country]          VARCHAR (50)     NULL,
    [City]             VARCHAR (50)     NULL,
    [State]            VARCHAR (50)     NULL,
    [PostalCode]       CHAR (10)        NULL,
    [ExpirationDate]   SMALLDATETIME    NULL,
    [CreditCardType]   VARCHAR (50)     NULL
);
GO
PRINT N'Creating dbo.Restaurant...';
GO
CREATE TABLE [dbo].[Restaurant] (
    [RestaurantId]           UNIQUEIDENTIFIER NOT NULL,
    [Name]                   VARCHAR (256)    NULL,
    [Description]            VARCHAR (1024)   NULL,
    [RestaurantCategoryId]   UNIQUEIDENTIFIER NOT NULL,
    [LogoImageLocation]      NVARCHAR (MAX)   NULL,
    [SmallLogoImageLocation] NVARCHAR (MAX)   NULL,
    [BannerImageLocation]    NVARCHAR (MAX)   NULL,
    [MainImageLocation]      NVARCHAR (MAX)   NULL,
    [BackgroundLocation]     NVARCHAR (MAX)   NULL,
    [PostalCode]             VARCHAR (128)    NOT NULL,
    [StreetAddress]          VARCHAR (256)    NULL,
    [City]                   VARCHAR (512)    NULL,
    [State]                  VARCHAR (256)    NULL
);
GO
PRINT N'Creating dbo.RestaurantCategory...';
GO
CREATE TABLE [dbo].[RestaurantCategory] (
    [RestaurantCategoryId] UNIQUEIDENTIFIER NOT NULL,
    [Description]          VARCHAR (255)    NOT NULL
);
GO
PRINT N'Creating dbo.Default_Menu_StartDate...';
GO
ALTER TABLE [dbo].[Menu]
    ADD CONSTRAINT [Default_Menu_StartDate] DEFAULT GETDATE() FOR [StartDate];
GO
PRINT N'Creating dbo.PK_Customer...';
GO
ALTER TABLE [dbo].[Customer]
    ADD CONSTRAINT [PK_Customer] 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 dbo.PK_Menu...';
GO
ALTER TABLE [dbo].[Menu]
    ADD CONSTRAINT [PK_Menu] PRIMARY KEY CLUSTERED ([MenuId] ASC) WITH (ALLOW_PAGE_LOCKS = ON, ALLOW_ROW_LOCKS = ON, PAD_INDEX = OFF, IGNORE_DUP_KEY = OFF, STATISTICS_NORECOMPUTE = OFF);
GO
PRINT N'Creating dbo.PK_MenuItem...';
GO
ALTER TABLE [dbo].[MenuItem]
    ADD CONSTRAINT [PK_MenuItem] PRIMARY KEY CLUSTERED ([MenuItemId] ASC) WITH (ALLOW_PAGE_LOCKS = ON, ALLOW_ROW_LOCKS = ON, PAD_INDEX = OFF, IGNORE_DUP_KEY = OFF, STATISTICS_NORECOMPUTE = OFF);
GO
PRINT N'Creating dbo.PK_Order2...';
GO
ALTER TABLE [dbo].[Order]
   ADD CONSTRAINT [PK_Order2] 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 dbo.PK_OrderDetail...';
GO
ALTER TABLE [dbo].[OrderDetail]
    ADD CONSTRAINT [PK_OrderDetail] PRIMARY KEY CLUSTERED ([OrderDetailId] ASC) WITH (ALLOW_PAGE_LOCKS = ON, ALLOW_ROW_LOCKS = ON, PAD_INDEX = OFF, IGNORE_DUP_KEY = OFF, STATISTICS_NORECOMPUTE = OFF);
GO
PRINT N'Creating dbo.PK_OrderPayment...';
GO
ALTER TABLE [dbo].[OrderPayment]
    ADD CONSTRAINT [PK_OrderPayment] PRIMARY KEY CLUSTERED ([PaymentID] ASC) WITH (ALLOW_PAGE_LOCKS = ON, ALLOW_ROW_LOCKS = ON, PAD_INDEX = OFF, IGNORE_DUP_KEY = OFF, STATISTICS_NORECOMPUTE = OFF);
GO
PRINT N'Creating dbo.PK_Restaurant...';
GO
ALTER TABLE [dbo].[Restaurant]
    ADD CONSTRAINT [PK_Restaurant] PRIMARY KEY CLUSTERED ([RestaurantId] ASC) WITH (ALLOW_PAGE_LOCKS = ON, ALLOW_ROW_LOCKS = ON, PAD_INDEX = OFF, IGNORE_DUP_KEY = OFF, STATISTICS_NORECOMPUTE = OFF);
GO
PRINT N'Creating dbo.PK_RestaurantCategory...';
GO
ALTER TABLE [dbo].[RestaurantCategory]
    ADD CONSTRAINT [PK_RestaurantCategory] PRIMARY KEY CLUSTERED ([RestaurantCategoryId] ASC) WITH (ALLOW_PAGE_LOCKS = ON, ALLOW_ROW_LOCKS = ON, PAD_INDEX = OFF, IGNORE_DUP_KEY = OFF, STATISTICS_NORECOMPUTE = OFF);
GO
PRINT N'Creating dbo.FK_Menu_Restaurant...';
GO
ALTER TABLE [dbo].[Menu]
    ADD CONSTRAINT [FK_Menu_Restaurant] FOREIGN KEY ([RestaurantId]) REFERENCES [dbo].[Restaurant] ([RestaurantId]) ON DELETE NO ACTION ON UPDATE NO ACTION;
GO
PRINT N'Creating dbo.FK_MenuItem_Menu...';
GO
ALTER TABLE [dbo].[MenuItem]
    ADD CONSTRAINT [FK_MenuItem_Menu] FOREIGN KEY ([MenuId]) REFERENCES [dbo].[Menu] ([MenuId]) ON DELETE NO ACTION ON UPDATE NO ACTION;
GO
PRINT N'Creating dbo.FK_Order2_Customer...';
GO
ALTER TABLE [dbo].[Order]
    ADD CONSTRAINT [FK_Order2_Customer] FOREIGN KEY ([CustomerID]) REFERENCES [dbo].[Customer] ([CustomerId]) ON DELETE NO ACTION ON UPDATE NO ACTION;
GO
PRINT N'Creating dbo.FK_OrderDetail_MenuItem...';
GO
ALTER TABLE [dbo].[OrderDetail]
    ADD CONSTRAINT [FK_OrderDetail_MenuItem] FOREIGN KEY ([MenuItemId]) REFERENCES [dbo].[MenuItem] ([MenuItemId]) ON DELETE NO ACTION ON UPDATE NO ACTION;
GO
PRINT N'Creating dbo.FK_OrderDetail_Order2...';
GO
ALTER TABLE [dbo].[OrderDetail]
    ADD CONSTRAINT [FK_OrderDetail_Order2] FOREIGN KEY ([OrderId]) REFERENCES [dbo].[Order] ([OrderId]) ON DELETE CASCADE ON UPDATE CASCADE;
GO
PRINT N'Creating dbo.FK_OrderDetail_Restaurant...';
GO
ALTER TABLE [dbo].[OrderDetail]
    ADD CONSTRAINT [FK_OrderDetail_Restaurant] FOREIGN KEY ([RestaurantId]) REFERENCES [dbo].[Restaurant] ([RestaurantId]) ON DELETE NO ACTION ON UPDATE CASCADE;
GO
PRINT N'Creating dbo.FK_OrderPayment_Order...';
GO
ALTER TABLE [dbo].[OrderPayment]
    ADD CONSTRAINT [FK_OrderPayment_Order] FOREIGN KEY ([OrderID]) REFERENCES [dbo].[Order] ([OrderId]) ON DELETE CASCADE ON UPDATE CASCADE;
GO
PRINT N'Creating dbo.FK_Restaurant_RestaurantCategory...';
GO
ALTER TABLE [dbo].[Restaurant]
    ADD CONSTRAINT [FK_Restaurant_RestaurantCategory] FOREIGN KEY ([RestaurantCategoryId]) REFERENCES [dbo].[RestaurantCategory] ([RestaurantCategoryId]) ON DELETE NO ACTION ON UPDATE NO ACTION;
GO
PRINT N'Creating dbo.CK_Menu_EndDate...';
GO
ALTER TABLE [dbo].[Menu]
    ADD CONSTRAINT [CK_Menu_EndDate] CHECK (([EndDate] > '01/01/2000') AND ([EndDate] >= [StartDate]));
GO
PRINT N'Creating dbo.CK_Menu_StartDate...';
GO
ALTER TABLE [dbo].[Menu]
    ADD CONSTRAINT [CK_Menu_StartDate] CHECK ([StartDate] > '01/01/2000');
GO
PRINT N'Creating AutoCreatedLocal...';
GO
CREATE ROUTE [AutoCreatedLocal]
    AUTHORIZATION [dbo]
    WITH ADDRESS = N'LOCAL';
GO
PRINT N'Creating dbo.Menu.EndDate.ExtProp_Menu_EndDate_Description...';
GO
EXECUTE sp_addextendedproperty @name = N'ExtProp_Menu_EndDate_Description', @value = 'Date the menu expired. Must be > 01/01/2000 and must be after the StartDate', @level0type = N'SCHEMA', @level0name = N'dbo', @level1type = N'TABLE', @level1name = N'Menu', @level2type = N'COLUMN', @level2name = N'EndDate';
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.
Fare clic su Salva.
Scegliere Chiudi soluzione dal menu File.

A questo punto, è possibile procedere alla creazione di un progetto di database e all'importazione dello schema dallo script creato.

Per creare un progetto di database

Scegliere Nuovo dal menu File, quindi Progetto.

Verrà visualizzata la finestra di dialogo Nuovo progetto.
In Modelli installati espandere il nodo Database, quindi fare clic su SQL Server.

Nota

Se si utilizza Visual Studio Professional, in Modelli installati espandere il nodo Database e il nodo SQL Server, quindi fare clic su Avanzate.
Nell'elenco dei modelli fare clic su Progetto di database di SQL Server 2008.

Nota

Se si desidera distribuire a un server diverso da SQL Server 2008, fare clic sul modello che corrisponde all'ambiente di distribuzione di destinazione desiderato.
In Nome digitare WalkthroughDataGenerator e fare clic su OK.

Verrà creata una soluzione contenente il progetto di database vuoto WalkthroughDataGenerator . Nessun altro può accedere al progetto di database mentre è utilizzato dall'utente che lo ha creato.
In Esplora soluzioni fare clic su WalkthroughDataGenerator.
Scegliere Importa script dal menu Progetto.
Nella finestra di dialogo Importa file di script SQL fare clic su Avanti.
In Nome file digitare il percorso e il nome del file di script creato in precedenza durante questa procedura dettagliata.

In alternativa, è possibile fare clic su Sfoglia per individuare il file di script.
Scegliere Fine.

Verrà importato lo script che contiene la definizione della struttura del database.
Dopo avere importato lo schema, fare clic su Fine.

Lo schema del database viene importato nel progetto di database. Gli elementi di progetto che corrispondono agli oggetti del database vengono visualizzati nel progetto di database in Esplora soluzioni e in Visualizzazione schema. A questo punto, è possibile procedere alla configurazione, la compilazione e la distribuzione del progetto nell'ambiente di sviluppo locale.

Distribuzione in un ambiente di sviluppo isolato

Distribuire il progetto in un nuovo database. Questa procedure illustra come creare un database con uno schema importato non contenente dati. Questo database si trova in un ambiente di sviluppo isolato, o sandbox, in cui è possibile svilupparlo e testarlo.

Per compilare il progetto di database

In Esplora soluzioni fare clic sul progetto di database WalkthroughDataGenerator.
Scegliere Proprietà di WalkthroughDataGenerator dal menu Progetto.

Verrà visualizzata la finestra delle proprietà del progetto.
Fare clic sulla scheda Distribuisci.
Nell'elenco Azione di distribuzione fare clic su Crea uno script di distribuzione (.sql) e distribuisci nel database.
In Impostazione database di destinazione, fare clic su Modifica per visualizzare la finestra di dialogo Proprietà connessione.
Impostare le proprietà di connessione per il database che si desidera utilizzare, quindi scegliere OK.

La casella Connessione di destinazione verrà compilata con la stringa di connessione corretta.

Attenzione

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

Quando si compila il progetto, viene verificato che sia possibile creare il file con estensione dbschema senza errori. Lo stato della compilazione è visibile nella finestra Output e l'ultima riga dovrebbe riportare Compilazione: 1 completate o aggiornate.

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

Per distribuire il progetto di database

In Esplora soluzioni fare clic sul progetto di database WalkthroughDataGenerator.
Scegliere Distribuisci WalkthroughDataGenerator dal menu Compila. È inoltre possibile fare clic con il pulsante destro del mouse sul progetto in Esplora soluzioni e scegliere 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 è visibile nella finestra Output e l'ultima riga dovrebbe riportare Distribuzione: 1 completata.

Nota

Se la finestra Output non è visualizzata, scegliere Output dal menu Visualizza.

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.

Creazione del piano di generazione dati

A questo punto, è possibile procedere alla creazione del piano di generazione dati, in cui è indicato quali tabelle e colonne compilare con i dati. Per ulteriori informazioni, vedere Procedura: creare piani di generazione dati.

Per creare il piano di generazione dati

In Esplora soluzioni fare clic con il pulsante destro del mouse sul nodo Piani di generazione dati, scegliere Aggiungi, quindi Piano di generazione dati.

Verrà visualizzata la finestra di dialogo Aggiungi nuovo elemento.
Nella casella di testo Nome digitare PartialDGenPlan.dgen.
Fare clic su Aggiungi.

Verrà creato il piano di generazione dati. Verranno visualizzati il piano di generazione dati e la finestra Anteprima di generazione dati. La finestra del piano di generazione dati è suddivisa in due riquadri orizzontali. Nel riquadro superiore sono elencate le tabelle definite nello schema del progetto di database. Nel riquadro inferiore sono indicati i dettagli delle colonne della tabella evidenziata nel riquadro superiore.

Nota

Se la finestra Anteprima di generazione dati è chiusa, è possibile visualizzarla aprendo il menu Dati, scegliendo Generazione dati e quindi facendo clic su Anteprima generazione dati. Per impostazione predefinita, la finestra Anteprima generazione dati è ancorata e suddivisa in schede nella parte inferiore della finestra del piano di generazione dati. Per espandere la visualizzazione, fare clic sulla finestra e quindi scegliere Ancora come Documento a schede dal menu Finestra. È inoltre possibile fare clic con il pulsante destro del mouse sulla barra del titolo e quindi scegliere Ancora come Documento a schede.
Nella finestra di progettazione di PartialDGenPlan.dgen deselezionare le caselle di controllo di tutte le tabelle.

Nota

È possibile selezionare o deselezionare tutte le caselle di controllo delle tabelle tramite i comandi Includi tutte le tabelle nella generazione dei dati ed Escludi tutte le tabelle dalla generazione dei dati. Tali comandi sono accessibili facendo clic con il pulsante destro del mouse su qualsiasi riga nella finestra del piano di generazione dati oppure scegliendo Generatore di dati dal menu Dati.
Nella finestra di progettazione di PartialDGenPlan.dgen selezionare la casella di controllo relativa alla tabella dbo.Restaurant.

La casella di controllo relativa alla tabella dbo.RestaurantCategory viene selezionata automaticamente. Poiché la tabella Restaurant dispone di una chiave esterna con la tabella RestaurantCategory, è necessario compilare quest'ultima per compilare la prima. Per ulteriori informazioni, vedere Procedura: specificare le tabelle per la generazione di dati.
Scegliere Salva tutto dal menu File.

Definizione dei dettagli per la generazione dei dati

A questo punto, è possibile definire la modalità di compilazione delle colonne con i dati. Per ulteriori informazioni, vedere Specificare i dettagli di generazione dati per una colonna.

Per definire i dettagli per la generazione dei dati

Impostare il numero di righe di dati da generare eseguendo le operazioni seguenti:
1. Nella finestra di progettazione di PartialDGenPlan.dgen fare clic sulla riga della tabella Restaurant.
2. Fare clic sulla colonna Tabella correlata e utilizzare la freccia a discesa per specificare la tabella RestaurantCategories.
3. Fare clic sulla colonna Rapporto a tabella correlata e digitare 10:1.
In base a questo operazione, verranno generati 10 ristoranti per ogni categoria creata. Per ulteriori informazioni, vedere Procedura: specificare il numero di righe da generare.
Impostare il numero di righe dati NULL da generare eseguendo le operazioni seguenti:
1. Nella finestra di progettazione di PartialDGenPlan.dgen fare clic sulla riga della tabella Restaurant.
2. Nel riquadro dei dettagli delle colonne fare clic sulla riga relativa alla colonna Description.
3. Nella finestra Proprietà impostare la proprietà Null percentuale su 10.
In base a queste impostazioni, il 10% dei dati generati nella colonna Description conterrà NULL. È possibile aprire la finestra Anteprima di generazione dati e verificare che la colonna Descrizione contenga alcuni valori Null.
Impostare il testo dei dati generati eseguendo le seguenti operazioni:
1. Nella finestra di progettazione di PartialDGenPlan.dgen fare clic sulla riga della tabella Restaurant.
2. Nel riquadro dei dettagli delle colonne fare clic sulla riga relativa alla colonna Name.
3. Fare clic sulla colonna Generatore e utilizzare la freccia a discesa per specificare il generatore di dati RegularExpression.
4. Nella finestra Proprietà impostare la proprietà Expression su:
```
(Delicious|Golden|Family|Sweet|Dancing|Magic|Thai) (Ginger|Duck|Flower|Potato|Pumpkin|Kitchen|Grill|Onion|Corral)
```
I dati generati nella colonna ProductName conterranno nomi di due parole. È possibile aprire la finestra Anteprima di generazione dati e verificare che la colonna Name contenga nomi di ristoranti generati in modo casuale. Per ulteriori informazioni, vedere Generatore di espressioni regolari.
Scegliere Salva tutto dal menu File.

Esecuzione del piano per generare dati

È infine possibile eseguire il piano di generazione dati. Dopo avere generato i dati, è possibile utilizzare un altro strumento per accedere al database e verificare i nuovi dati.

Per eseguire il piano per generare i dati

In Esplora soluzioni fare doppio clic su PartialDGenPlan.dgen.

Nota

Il piano di generazione dati deve essere aperto. Se il piano non è aperto, non è possibile generare dati.
Scegliere Generatore di dati dal menu Dati e quindi Genera dati.

Verrà visualizzata la finestra di dialogo Connetti al database.
Nell'elenco Informazioni di connessione per la generazione dati, specificare una connessione al database distribuito precedentemente in questa procedura dettagliata, quindi fare clic su OK.
Scegliere Sì quando viene richiesto di cancellare il contenuto delle tabelle prima di inserire nuove righe.

I dati verranno generati. Nella finestra Popolazione la colonna dello stato viene aggiornata con lo stato della generazione dati. Sulla barra di stato viene riepilogata la generazione dati per tutte le tabelle.
(Facoltativo) Utilizzare un altro strumento per accedere al database. È possibile utilizzare l'editor Transact-SQL disponibile in Visual Studio Premium per questo passaggio. Per ulteriori informazioni, vedere Modifica degli oggetti e degli script di database con l'Editor Transact-SQL sul sito Web Microsoft. Visualizzare i nuovi dati eseguendo la query seguente:
```
use DinnerNowDataGenerator

select * from [dbo].[RestaurantCategory]
select * from [dbo].[Restaurant]
```
Verificare che il numero di righe generate per la tabella Restaurant corrisponda a quello della tabella RestaurantCategory. Verificare che la colonna Description della tabella Restaurant contenga valori NULL. Verificare che la colonna Name nella tabella Restaurant contenga dati che corrispondono all'espressione regolare specificata.

Passaggi successivi

A questo punto, è possibile configurare la generazione dati per altre colonne e tabelle nel database. Al termine della configurazione, è possibile rendere disponibile il progetto al team archiviandolo, con il piano di generazione dati, nel controllo della versione. Per ulteriori informazioni, vedere Aggiungere file al controllo della versione.

Vedere anche

Concetti

Generazione di dati di test per i database tramite generatori di dati

Specificare i dettagli di generazione dati per una colonna

Verifica del codice del database tramite unit test

Generare dati di test specializzati con un generatore di dati personalizzato

Condividi tramite