Procedura dettagliata: modifica dei progetti di database mediante il modello di automazione di Visual Studio

Articolo
09/12/2008

Aggiornamento: novembre 2007

A livello di codice è possibile modificare i progetti di database utilizzando il supporto di estensibilità in Visual Studio. I progetti di database in Visual Studio Team System Database Editionsupportano il modello di automazione Visual Studio, conosciuto anche col nome Design-Time Extensibility (DTE), in modo coerente con i progetti Visual C# e Visual Basic. Per ulteriori informazioni su questo modello, vedere Estensione dell'ambiente Visual Studio. In questa procedura dettagliata, è possibile creare macro Visual Studio che utilizzano il modello di automazione per portare a termine due attività:

Attivare e disattivare l'azione di compilazione di tutti i trigger in un progetto di database. Se i trigger sono impostati su "Compilazione", la macro li modifica in "Non incluso nella compilazione". Se i trigger sono impostati su "Non incluso nella compilazione", la macro li modifica in "Compilazione".
Aggiungere tutti i file script di una directory a una cartella in un progetto di database. Se la cartella non esiste, verrà creata. Verranno aggiunti solo i file script con determinate estensioni.

È anche possibile eseguire queste attività in un componente aggiuntivo Visual Studio scritto in Visual C# o Visual Basic. Per semplicità, questa procedura dettagliata utilizza macro.

Nelle procedure descritte di seguito, si desidera:

Creare un progetto di database organizzato per tipo di oggetto e importare lo schema del database AdventureWorks.
Avviare Esplora macro e creare dei moduli per contenere le macro e il codice di supporto.
Creare una macro per attivare e disattivare l'azione di compilazione per tutti i trigger in un progetto di database nella soluzione aperta.
Creare una macro e un codice di supporto per aggiungere script al progetto di database.
Eseguire la macro ToggleTriggers da Finestra di comando.
Eseguire la macro AddScriptsInDirectory da Esplora macro.

Prerequisiti

Per completare questa procedura dettagliata è necessario avere installato Database Edition. In questa procedura dettagliata si presuppone che sia stata installata una copia del database di esempio AdventureWorks in un server database con Microsoft SQL Server 2005. È possibile sostituire qualsiasi progetto di database organizzato per tipo di oggetto. È necessario avere uno o più file con estensione sql in una directory per la quale si dispone dell'accesso.

Per creare un progetto di database

Avviare Visual Studio se questa operazione non è già stata eseguita.
Scegliere Nuovo dal menu File, quindi fare clic su Progetto.

Verrà visualizzata la finestra di dialogo Nuovo progetto.
Nell'elenco Tipi progetto espandere il nodo Progetti di database e fare clic su Microsoft SQL Server.
Nell'elenco Modelli scegliere SQL Server 2005.
Nella casella Nome digitare MyAdvWorks e accettare i valori predefiniti per Percorso e Nome soluzione.
Selezionare la casella di controllo Crea directory per soluzione se non è già selezionata per impostazione predefinita, quindi scegliere OK.

Verrà creata una soluzione contenente il progetto di database vuoto MyAdvWorks.

Avviare quindi il processo Importa schema database e specificare una stringa di connessione per il database di origine.

Per importare lo schema di database dal database Adventure Works esistente

Scegliere Visualizzazione schema dal menu Visualizza.

Se non è già visualizzata, verrà visualizzata la finestra Visualizzazione schema.
In Visualizzazione schema fare clic su MyAdvWorks.
Scegliere Importa schema database dal menu Progetto.

Nota:

È anche possibile fare clic con il pulsante destro del mouse su MyAdvWorks e scegliere Importa schema database.

Verrà aperta l'Importazione guidata database.
Nella connessione Database di origine, fare clic sulla connessione corrispondente al database AdventureWorks esistente. Se la connessione al database non è ancora stata stabilita, è necessario prima effettuare questa operazione. Per ulteriori informazioni, vedere Procedura: creare una connessione al database.
Scegliere Fine.

Quando lo schema viene importato, gli elementi di progetto che corrispondono agli oggetti contenuti nel database verranno visualizzati nel progetto di database in Esplora soluzioni. In Visualizzazione schema verranno visualizzati gli oggetti definiti nel progetto di database.

Nota:
È anche possibile fare clic con il pulsante destro del mouse su MyAdvWorks e scegliere Importa schema database.

Per avviare Esplora macro e creare dei moduli

Scegliere Altre finestre dal menu Visualizza, quindi Esplora macro.

Verrà visualizzataEsplora macro .
In Esplora macro, fare clic con il pulsante destro del mouse sul nodo MyMacros e scegliere Nuovo modulo.

Verrà visualizzata la finestra di dialogo Aggiungi modulo.
In Nome, digitare BuildActionExample.
Scegliere Aggiungi.
In Esplora macro, fare clic con il pulsante destro del mouse sul nodo MyMacros e scegliere Nuovo modulo.

Verrà visualizzata la finestra di dialogo Aggiungi modulo.
In Nome, digitare ImportScriptsExample.
Scegliere Aggiungi.

Creare una macro per attivare e disattivare l'azione di compilazione di tutti i trigger Data Manipulation Language (DML) in un database specificato.

Creare la macro ToggleTriggers

La macro ToggleTriggers prende un parametro opzionale che è il nome del progetto di database che contiene i trigger da aggiornare. Se non si specifica un nome di progetto, la macro richiederà di farlo. È possibile modificare la macro per identificare il tipo di ciascun progetto nella soluzione e aggiornare tutti i progetti di database. Tuttavia, tale approccio è al di fuori dell'ambito di questa procedura dettagliata.

Per creare la macro ToggleTriggers

In Esplora macro, fare clic con il pulsante destro del mouse sul modulo BuildActionExample e scegliere Modifica.

Verrà visualizzata la finestra Microsoft Visual Studio Macro. Questa finestra mostra il contenuto del modulo BuildActionExample.

Sostituire il contenuto del modulo con il seguente codice VBScript:

Imports System
Imports System.ComponentModel
Imports EnvDTE
Imports EnvDTE80
Imports System.Diagnostics

Public Module BuildActionExample

    ' Macro to toggle the BuildAction for all DML triggers
    ' in a database project.
    ' Before running this macro, you must:
    ' 1) Ensure that a solution file is open and saved to disk.
    ' 2) Pass in the name of a database project contained in the
    '    open solution in the dbProjName parameter. 
    Sub ToggleTriggers(Optional ByVal dbProjName As String = "")
        Dim project As Project

        ' if the database project name was not passed in, prompt the user for it.
        If (String.IsNullOrEmpty(dbProjName)) Then
            dbProjName = InputBox("Type the database project name.")
            If (String.IsNullOrEmpty(dbProjName)) Then
                Return
            End If
        End If

        ' Loop through each project until we find the one we want
        For Each project In DTE.Solution
            Dim projectItem As EnvDTE.ProjectItem
            'Look for a project whose name matches the parameter
            If (dbProjName.Equals(project.Name)) Then
                'Then loop through the project items, looking for
                'the Schema Objects folder.
                For Each projectItem In project.ProjectItems()
                    If (projectItem.Name = "Schema Objects") Then
                        ' loop through the subfolders and list the files, looking for the Tables sub-folder
                        Dim subItem As EnvDTE.ProjectItem
                        For Each subItem In projectItem.ProjectItems()
                            If (subItem.Name = "Tables") Then
                                ' loop through looking for the Triggers subfolder
                                Dim subsubItem As EnvDTE.ProjectItem
                                For Each subsubItem In subItem.ProjectItems()
                                    If (subsubItem.Name = "Triggers") Then
                                        ' okay, we're in the right folder, now set the build actions
                                        Dim triggerItem As EnvDTE.ProjectItem
                                        For Each triggerItem In subsubItem.ProjectItems()
                                            'MsgBox(" trigger: " + triggerItem.Name)
                                            Dim buildAction As EnvDTE.Property
                                            buildAction = triggerItem.Properties.Item("DBProjectBuildAction")

                                            ' here we toggle the build action. If it was NotInBuild(0),
                                            ' we set it to Build(1). If it was Build(1), then we set it
                                            ' to NotInBuild(0).
                                            If (buildAction.Value = 0) Then
                                                buildAction.Value = 1
                                            ElseIf (buildAction.Value = 1) Then
                                                buildAction.Value = 0
                                            End If
                                        Next
                                    End If
                                Next
                            End If
                        Next
                    End If
                Next
            End If
        Next
    End Sub
End Module

La macro scorre il contenuto della soluzione fino a quando non trova il progetto di database il cui nome corrisponde a quello specificato. Dopo che la macro ha identificato il progetto, scorre gli elementi del progetto per cercare la cartella Elementi di soluzione. Nella cartella Elementi di soluzione, la macro cerca la cartella Tabelle e al suo interno la cartella Trigger. La macro recupera quindi il valore della proprietà DBProjectBuildAction per ciascun trigger. Se il valore è 1 (Compilazione) viene impostato su 0 (Non incluso nella compilazione). Allo stesso modo, se il valore è 0 viene passato a 1. Anche se il nome della proprietà nella finestra Proprietà è Operazione di compilazione, il nome della proprietà sottostante è DBProjectBuildAction.

Nella finestra delle macro, aprire il menu File e fare clic su Salva MyMacros.

Creare la macro che aggiunge i file script di una directory al progetto di database specificato.

Creare la macro AddScriptsInDirectory

La macro AddScriptsInDirectory prende tre parametri: il nome del progetto di database a cui si desidera aggiungere i file script, il nome della cartella nel progetto di database dove si desidera aggiungere gli script e il percorso che contiene i file script che la macro importerà. Se quando si esegue la macro questi parametri non vengono specificati, la macro richiederà di farlo. Se non si specifica il nome di una cartella del progetto in risposta al prompt, i file saranno aggiunti alla cartella degli Script.

Questa macro è più complessa della precedente. Per semplicità, si compila la macro AddScriptsInDirectory creando le due seguenti funzioni e subroutine:

Funzione IsFileIncluded Questa funzione verifica se l'estensione di un nome file specificato è nell'elenco delle estensioni dei file da trattare come script e da aggiungere al progetto di database.
Funzione GetOutputWindowPane Questa funzione restituisce la finestra di output in modo da fornire il messaggio di stato.
AddScriptsInDirectory2 sub Questa subroutine prende una cartella del progetto, un percorso e aggiunge tutti i file le cui estensioni corrispondono all'elenco di estensioni dello script.
Sub AddScriptsInDirectory La routine di immissione per questa macro. Questa subroutine elabora i parametri eseguiti, esegue la convalida e infine crea la cartella di destinazione oppure la trova nel progetto di database se la cartella esiste già. La subroutine chiama quindi AddScriptsInDirectory2 per aggiungere i file alla cartella.

Per creare la macro AddScriptsInDirectory

In Esplora macro fare clic con il pulsante destro del mouse sul modulo ImportScriptsExample e scegliere Modifica.

Verrà visualizzata la finestra Microsoft Visual Studio Macro. In questa finestra viene mostrato il contenuto del modulo ImportScriptsExample.

Sostituire il contenuto del modulo con il seguente codice VBScript:

Imports System
Imports EnvDTE
Imports EnvDTE80
Imports System.Diagnostics

Public Module ImportScriptsExample
    ' A list of folder names, file names, and extensions that we want to add
    '  to the solution.
    Dim outputWindowPaneTitle As String = "Add scripts to a project folder report"
    Dim includedExtensions As New System.Collections.Specialized.StringCollection

    ' Function to filter out folder names, file names, and extensions that we do not 
    '  want to add to the solution.
    Function IsFileIncluded(ByVal filePath As String) As Boolean
        Dim extension As String
        Dim fileName As String

        extension = System.IO.Path.GetExtension(filePath)
        extension = extension.ToLower()

        fileName = System.IO.Path.GetFileName(filePath)
        fileName = fileName.ToLower()

        If (includedExtensions.Contains(extension)) Then
            Return True
        Else
            If (includedExtensions.Contains(fileName)) Then
                Return True
            Else
                Return False
            End If
        End If
    End Function

    ' This function retrieves the output window pane
    Function GetOutputWindowPane(ByVal Name As String, Optional ByVal show As Boolean = True) As OutputWindowPane
        Dim window As Window
        Dim outputWindow As OutputWindow
        Dim outputWindowPane As OutputWindowPane

        window = DTE.Windows.Item(EnvDTE.Constants.vsWindowKindOutput)
        If show Then window.Visible = True
        outputWindow = window.Object
        Try
            outputWindowPane = outputWindow.OutputWindowPanes.Item(Name)
        Catch e As System.Exception
            outputWindowPane = outputWindow.OutputWindowPanes.Add(Name)
        End Try
        outputWindowPane.Activate()
        Return outputWindowPane
    End Function

    ' Given a folder within the solution and a folder on disk, add all files whose extensions
    ' are on a list of "good" extensions to the folder in the solution.
    Sub AddScriptsInDirectory2(ByVal newScriptFolder As ProjectItem, ByVal startFolder As String)
        Dim files As String()
        Dim file As String
        Dim folder As String

        ' get a list of files in the specified folder
        files = System.IO.Directory.GetFiles(startFolder)

        ' get the output window pane so we can report status
        Dim outputWindowPane As EnvDTE.OutputWindowPane
        outputWindowPane = GetOutputWindowPane(outputWindowPaneTitle, True)

        ' Examine all the files within the folder.
        For Each file In files
            ' if this file's extension is one we want to include...
            If (IsFileIncluded(file)) Then
                ' try to add it to the folder
                Dim projItem As ProjectItem
                Try
                    projItem = newScriptFolder.ProjectItems().AddFromFile(file)
                    outputWindowPane.OutputString("The item """ + file + """ was added" + vbLf)

                    If (Not (projItem Is Nothing)) Then
                        If (Not (projItem.Document Is Nothing)) Then
                            projItem.Document.Close(vsSaveChanges.vsSaveChangesNo)
                        End If
                    End If
                Catch
                    ' if an error occurs, report the failure
                    outputWindowPane.OutputString("The item """ + file + """may have not been added to the solution." + vbLf)
                End Try
            End If
        Next
    End Sub

    ' creates a new subfolder within the Scripts folder in the specified database project
    ' then adds all files in the specified path to the newly created scripts sub-folder.
    Sub AddScriptsInDirectory(Optional ByVal dbProjName As String = "", Optional ByVal scriptFolderName As String = "", Optional ByVal startFolder As String = "")
        If (String.IsNullOrEmpty(dbProjName)) Then
            dbProjName = InputBox("Type the name of the database project to which you want the scripts to be imported.")
            If (String.IsNullOrEmpty(dbProjName)) Then
                Return
            End If
        End If

        If (String.IsNullOrEmpty(scriptFolderName)) Then
            scriptFolderName = InputBox("Type the script folder name.")
            If (String.IsNullOrEmpty(scriptFolderName)) Then
                scriptFolderName = "Scripts"
            End If
        End If

        If (String.IsNullOrEmpty(startFolder)) Then
            startFolder = InputBox("Type the folder path to import.")
            If (String.IsNullOrEmpty(startFolder)) Then
                Return
            End If
        End If

        If (System.IO.Directory.Exists(startFolder) = False) Then
            MsgBox("The specified folder could not be found.")
            Return
        End If

        GetOutputWindowPane(outputWindowPaneTitle, True).Clear()

        If System.IO.Directory.Exists(startFolder) = False Then
            Dim outputWindowPane As EnvDTE.OutputWindowPane
            outputWindowPane = GetOutputWindowPane(outputWindowPaneTitle, True)
            outputWindowPane.OutputString("The path entered could not be found" + vbLf)
            Exit Sub
        End If

        includedExtensions = New System.Collections.Specialized.StringCollection
        ' If you do not want a file with a particular extension or name
        '  to be added, then add that extension or name to this list:
        includedExtensions.Add(".sql")
        includedExtensions.Add(".tsql")

        Dim newScriptFolder As ProjectItem
        Dim project As Project

        ' now check to see if the desired folder in the project already exists
        For Each project In DTE.Solution
            Dim projectItem As EnvDTE.ProjectItem

            If (dbProjName.Equals(project.Name)) Then
                Dim found As Boolean
                found = False
                For Each projectItem In project.ProjectItems()
                    If (scriptFolderName.Equals(projectItem.Name)) Then
                        ' the desired folder already exists, save the projectItem that corresponds
                        ' to the folder.
                        found = True
                        newScriptFolder = projectItem
                    End If
                Next

                ' if the folder does not exist within the project, create it.
                If (Not found) Then
                    ' the folder does not already exist, so create it
                    newScriptFolder = project.ProjectItems().AddFolder(scriptFolderName, EnvDTE.Constants.vsProjectItemKindPhysicalFolder)
                End If
            End If
        Next

        ' now add the scripts in the folder to the project folder
        AddScriptsInDirectory2(newScriptFolder, startFolder)
    End Sub
End Module

Nella finestra delle macro, aprire il menu File e fare clic su Salva MyMacros.
Scegliere Chiudi e torna a dal menu File.

Eseguire le macro per dimostrare i risultati.

Eseguire la macro ToggleTriggers

Se si eseguono le macro con soluzioni diverse da quelle create in questa procedura dettagliata, è necessario specificare il nome del progetto di database contenuto nella soluzione al posto di MyAdvWorks.

Per eseguire la macro ToggleTriggers dalla Finestra di comando

Espandere il progetto di database MyAdvWorks in Esplora soluzioni.
Espandere la cartella Oggetti dello schema.
Espandere la cartella Tabelle.
Espandere la cartella Trigger.
In Esplora soluzioni fare clic con il pulsante destro del mouse su un trigger e scegliere Proprietà.

Prendere nota del valore della proprietà Operazione di compilazione per il trigger scelto.
Scegliere Altre finestre dal menu Visualizza, quindi Finestra di comando.

Verrà visualizzata la Finestra di comando.
Nella finestra Comando digitare:
```
Macros.MyMacros.BuildActionExample.ToggleTriggers MyAdvWorks
```
MyAdvWorks è il nome del progetto di database che avrà la proprietà Operazione di compilazione dei trigger eseguiti.
Attendere il completamento della macro.
Al termine dell’esecuzione della macro, visualizzare le proprietà per il trigger dal passaggio 5.

Il valore della proprietà Operazione di compilazione è l'opposto di ciò che era impostato prima di eseguire la macro.

È possibile eseguire nuovamente la macro per ripristinare i valori della proprietà Operazione di compilazione allo stato originale.

Eseguire la macro AddScriptsInDirectory da Esplora macro.

Eseguire la macro AddScriptsInDirectory

Eseguire la macro AddScriptsInDirectory da Esplora macro.

Se Esplora macro non è aperto, scegliere Altre finestre dal menu Visualizza e fare clic su Esplora macro.

Verrà visualizzataEsplora macro .
In Esplora macro, fare clic con il pulsante destro del mouse su AddScriptsInDirectory (è possibile dover espandere il modulo ImportScriptsExample per visualizzare la macro) e scegliere Esegui.

Verrà visualizzata la finestra di dialogo Visual Studio Macro con la richiesta di digitare il nome del progetto di database in cui importare gli script.
Digitare MyAdvWorkse scegliere OK.

Verrà di nuovo visualizzata la finestra di dialogo Visual Studio Macro con la richiesta di digitare il nome della cartella dello script.
Fare clic su OK per accettare il comportamento predefinito che aggiungerà gli script alla cartella degli Script.

Verrà di nuovo visualizzata la finestra di dialogo Visual Studio Macro con la richiesta di digitare il percorso della cartella da importare.
Digitare il percorso dove si trovano i file script come descritto nella sezione Prerequisiti, precedentemente in questo argomento. Ad esempio, se si hanno script in C:\Temp, digitare C:\Tempe quindi fare clic su OK.

La macro sarà in esecuzione fino a quando tutti i file con estensione .sql o .tsql non verranno aggiunti alla cartella degli Script del progetto di database MyAdvWorks.

Passaggi successivi

Questa procedura dettagliata illustra piccoli esempi delle attività che è possibile eseguire quando si utilizza il modello di automazione Visual Studio con i progetti di database. Se è necessaria più flessibilità, è possibile utilizzare il modello di automazione da un componente aggiuntivo Visual Studio.