Delen via

Een database en een project vergelijken

van toepassing op:SQL ServerAzure SQL DatabaseAzure SQL Managed InstanceSQL-database in Microsoft Fabric

Inzicht in de verschillen in objectdefinities tussen een database en een SQL-project kan waardevolle inzichten bieden in de status van uw database en project, inclusief tijdens de voortdurende ontwikkeling of regressieproblemen. SQL-projecten bevatten hulpprogramma's voor het visualiseren van verschillen, het analyseren van wijzigingen die nodig zijn voor het bijwerken van een database, het importeren van wijzigingen uit een database in een SQL-projectbestandsset en het controleren van T-SQL-scripts die worden uitgevoerd om een database bij te werken zodat deze overeenkomt met het project.

In dit artikel worden methoden besproken voor het vergelijken van een database en een SQL-project met behulp van verschillende benaderingen:

  • U kunt schema's vergelijken om de verschillen tussen databases en/of projecten te visualiseren. Deze vergelijking kan u helpen bij het identificeren van wijzigingen die moeten worden gesynchroniseerd tussen de database en het project.
  • U kunt een implementatierapport gebruiken om beoordelingen samen te vatten en te automatiseren van de wijzigingen die nodig zijn om een database bij te werken.
  • U kunt schemavergelijking of SqlPackage-extract gebruiken om wijzigingen uit een database te importeren in een SQL-projectbestandsset.
  • U kunt sqlPackage-implementatiescript of schema vergelijken om de T-SQL-instructies te controleren die worden uitgevoerd om een database bij te werken zodat deze overeenkomt met het project.

Schema vergelijken: verschillen visualiseren

Prerequisites

Grafische schemavergelijking is nog niet beschikbaar in de preview-versie van SQL-projecten in SDK-stijl in Visual Studio. Gebruik Azure Data Studio of Visual Studio om schema's te vergelijken.

Schemavergelijking vereist een grafisch hulpprogramma, zoals Visual Studio of de MSSQL-extensie voor Visual Studio Code.

Summary

Schema vergelijken biedt de visueel rijkste interface om inzicht te krijgen in de verschillen tussen een database en een project. Een belangrijke mogelijkheid met schemavergelijking is dat de richting van de vergelijking omkeerbaar is. Als gevolg hiervan kunt u schemavergelijking gebruiken om inzicht te hebben in wijzigingen van een project die moeten worden geïmplementeerd in een database of wijzigingen uit een database om toe te voegen aan een project. U kunt schemavergelijking gebruiken om verschillen in objectdefinities te identificeren, zoals tabellen, weergaven, opgeslagen procedures en functies.

De volledige set verschillen of een geselecteerde subset kan worden gebruikt om de wijzigingen toe te passen op de database of het project. Schema vergelijken kan ook een implementatiescript genereren dat, wanneer het wordt uitgevoerd, de wijzigingen effectief toepast op een database.

Meer informatie over schemavergelijking vindt u in het overzicht van schemavergelijking.

Rapport implementeren: wijzigingen controleren

Voor het implementeren van rapporten is de SQLPackage CLI vereist.

dotnet tool install -g Microsoft.SqlPackage

Summary

Een implementatierapport bevat een overzicht van de wijzigingen die nodig zijn om een database bij te werken zodat deze overeenkomt met een project. De SQLPackage CLI genereert een implementatierapport door een bronmodel (.dacpac SQL-projectbuildartefact of -database) te vergelijken met een doeldatabase. Met de volgende opdracht wordt bijvoorbeeld een implementatierapport gegenereerd voor een database met de naam MyDatabase van een SQL-project:MyProject

dotnet build MyProject.sqlproj
sqlpackage /Action:deployreport /SourceFile:bin/Debug/MyProject.dacpac /TargetConnectionString:{connection string for MyDatabase} /OutputPath:deployreport.xml

De geproduceerde XML is een vereenvoudigde vorm van het implementatieplan, waarbij de bewerkingen worden samengevat die moeten worden uitgevoerd als een database-implementatie wordt uitgevoerd. De volgende lijst met bewerkingen is niet volledig:

  • Create
  • Alter
  • Drop
  • Refresh
  • UnbindSchemaBinding
  • UnbindFulltextIndex
  • TableDataMotion
  • SPRename
  • EnableChangeTrackingDatabase
  • DisableChangeTrackingDatabase

Een implementatierapport kan worden gecontroleerd in een teksteditor of in Visual Studio en ziet er ongeveer als volgt uit:

<?xml version="1.0" encoding="utf-8"?>
<DeploymentReport xmlns="http://schemas.microsoft.com/sqlserver/dac/DeployReport/2012/02">
    <Alerts />
    <Operations>
        <Operation Name="Create">
            <Item Value="[CO].[Products].[IX_Products_CategorySlug]" Type="SqlIndex" />
        </Operation>
        <Operation Name="Alter">
            <Item Value="[CO].[Brands]" Type="SqlTable" />
            <Item Value="[CO].[AddProductImage]" Type="SqlProcedure" />
        </Operation>
        <Operation Name="Refresh">
            <Item Value="[CO].[SelectStarView]" Type="SqlView" />
        </Operation>
    </Operations>
</DeploymentReport>

Een implementatierapport kan worden gebruikt om de wijzigingen te controleren en te controleren op mogelijk gebeurtenissen met een hoge impact, zoals het maken/neerzetten van gegevens of geclusterde indexen. Deze gebeurtenissen worden vermeld in het implementatierapport onder het Alerts element.

Een voordeel van de XML-bewerking voor het implementeren van rapporten is dat deze kan worden gebruikt om de controle van wijzigingen te automatiseren die nodig zijn om een database bij te werken. De XML kan worden geparseerd en gebruikt om een rapport te genereren of waarschuwingen te activeren op basis van de vermelde bewerkingen of objectnamen.

Wijzigingen uit een database importeren

Zoals vermeld in de sectie Schema vergelijken, kan schema vergelijken worden gebruikt om wijzigingen uit een database toe te passen in een SQL-projectbestandsset. Het toepassen van wijzigingen in een SQL-project is een veelvoorkomend scenario wanneer u een database hebt die actief is ontwikkeld in rechtstreeks en een SQL-project wordt gebruikt voor het beheren van de databaseobjecten in broncodebeheer. Het handmatig voltooien van deze bewerking via Visual Studio of Azure Data Studio kan tijdrovend zijn, met name wanneer de database veel objecten of sporadische wijzigingen heeft. In deze sectie bekijken we hoe u het extraheren van objectdefinities uit een database kunt automatiseren in een SQL-projectbestandsset.

Prerequisites

Met een focus op automatisering gebruiken we de SQLPackage CLI om objectdefinities uit een database te extraheren in een SQL-projectbestandsset. De .NET-sjablonen Microsoft.Build.Sql.Templates worden gebruikt om een SQL-projectbestand te maken, een optionele stap.

# install SqlPackage CLI
dotnet tool install -g Microsoft.SqlPackage

# install Microsoft.Build.Sql.Templates
dotnet new install Microsoft.Build.Sql.Templates

Summary

De opdracht SqlPackage extract neemt een brondatabase en genereert een uitvoerdatabasemodel, hetzij als een .dacpac bestand of als een set SQL-scripts. SqlPackage genereert standaard een .dacpac bestand, maar de /p:ExtractTarget= eigenschap kan worden gebruikt om een set SQL-scripts op te geven. Met de volgende opdracht wordt de database MyDatabase geëxtraheerd in een SQL-projectbestand dat is ingesteld in de map MyDatabaseProject:

sqlpackage /Action:Extract /SourceConnectionString:{connection string for MyDatabase} /TargetFile:MyDatabaseProject /p:ExtractTarget=SchemaObjectType

Wanneer een map onder broncodebeheer valt, worden in de geëxtraheerde objectdefinities verschillen weergegeven in de hulpprogramma's voor broncodebeheer. Door SqlPackage te gebruiken om de bestanden te genereren en te controleren op verschillen in broncodebeheer, kunt u het proces voor het importeren van wijzigingen uit een database in een SQL-projectbestandsset automatiseren.

In een reeks van drie opdrachten kunnen we de vorige set bestanden verwijderen, de database extraheren en controleren op verschillen in de hulpprogramma's voor broncodebeheer:

rm -rf MyDatabaseProject
sqlpackage /Action:Extract /SourceConnectionString:{connection string for MyDatabase} /TargetFile:MyDatabaseProject /p:ExtractTarget=SchemaObjectType
git status --porcelain | wc -l

Onze uitvoer is het aantal bestanden dat is gewijzigd door het meest recente SqlPackage-extract. De uitvoer van de git status opdracht kan worden gebruikt om andere automatiseringsstappen te activeren. Als we deze set bestanden als een SQL-project willen gebruiken, kunnen we de .NET-sjablonen van Microsoft.Build.Sql.Templates gebruiken om een SQL-projectbestand in de map MyDatabaseProjectte maken:

dotnet new sqlproj -n MyDatabaseProject -o MyDatabaseProject

Controleer de T-SQL-scripts voor implementatie

Zoals vermeld in de sectie schemavergelijking, kan schemavergelijking worden gebruikt om de T-SQL-scripts te genereren die nodig zijn om een database bij te werken zodat deze overeenkomt met een SQL-project. In deze sectie bekijken we hoe u SqlPackage gebruikt om de generatie van de T-SQL-scripts te automatiseren die nodig zijn om een database bij te werken zodat deze overeenkomen met een SQL-project, zodat ze kunnen worden opgeslagen als een pijplijnartefact voor beoordeling en goedkeuring.

Prerequisites

dotnet tool install -g Microsoft.SqlPackage

Summary

Het uitvoeren van een SQL-projectimplementatie met SqlPackage maakt gebruik van de publicatieactie , maar als we de T-SQL-scripts willen controleren die worden uitgevoerd, kunnen we de scriptactie gebruiken. Met de volgende opdracht worden de T-SQL-scripts gegenereerd die nodig zijn om een database bij te werken die MyDatabase overeenkomt met een SQL-project met de naam MyProject:

dotnet build MyProject.sqlproj
sqlpackage /Action:Script /SourceFile:bin/Debug/MyProject.dacpac /TargetConnectionString:{connection string for MyDatabase} /DeployScriptPath:Deployment.sql

Verwante inhoud

  • Last updated on