Exporter des objets de base de données SQL Server

Pour une source hors ligne, vous chargez des fichiers de script exportés qui décrivent les objets de votre base de données source. Vous pouvez les exporter à l'aide de n'importe quel outil disponible. Les onglets suivants décrivent deux approches : SQL Server Management Studio (SSMS) et SQL Server Management Objects (SMO).

SSMS

1. Dans SSMS, dans l'explorateur d'objets, cliquez avec le bouton droit sur la base de données à exporter. Choisissez Tâches, puis Generate Scripts.

2. Choisissez Enregistrer en tant que fichier script.

3. Sous Fichiers à générer, choisissez Un fichier de script par objet afin de créer un .sql fichier distinct pour chaque objet de base de données.

4. Dans Nom du répertoire, entrez le chemin d'accès à un répertoire pour les fichiers de sortie. Nous vous recommandons de créer un répertoire portant le même nom que la base de données.

5. Pour Enregistrer sous, choisissez le texte Unicode.

6. Choisissez Avancé pour ouvrir la boîte de dialogue Options de script avancées.

7. Définissez les options conformément aux tableaux suivants.

8. Cliquez sur OK, puis sur Suivant pour consulter le résumé.

9. Choisissez Next pour générer les scripts.

10. Choisissez Terminer pour fermer l'assistant.

Options de script avancées

Définissez les options suivantes dans la boîte de dialogue Options de script avancées.

Options générales

Option	Value
Rembourrage ANSI	False
Ajouter au fichier	False
Vérifier l'existence d'un objet	False
Poursuivre le script en cas d'erreur	True
Convertir les UDDT en types de base	False
Générer un script pour les objets dépendants	True
Inclure des en-têtes descriptifs	False
Inclure l'en-tête des paramètres de script	False
Inclure les noms des contraintes du système	False
Schéma : qualifiez les noms d'objets	True
Liaison de scripts	False
Collation de scripts	True
Valeurs par défaut du script	True
Script DROP AND CREATE	Script CRÉER
Propriétés étendues du script	True
Connexions aux scripts	False
Object-Level Autorisations relatives aux scripts	False
Propriétaire du script	False
Statistiques des scripts	Ne pas créer de statistiques par script
Base de données d'utilisation du script	True
Types de données à scripter	Schéma uniquement

Table/View options

Option	Value
Suivi des modifications apportées aux scripts	False
Contraintes de vérification des scripts	True
Options de compression des données de script	False
Clés étrangères de script	True
Full-Text Index des scripts	True
Index des scripts	True
Clés primaires du script	True
déclencheurs de script	True
Clés uniques du script	True

SMO

SQL Server Management Objects (SMO) est une API .NET permettant de gérer SQL Server par programmation. Vous pouvez utiliser SMO avec PowerShell ou C# pour créer des scripts sur des objets de base de données et générer des fichiers DDL à utiliser avec une source hors ligne.

Conditions préalables

• Windows PowerShell 5.1 ou version ultérieure, ou version PowerShell 7+

• Le SqlServer PowerShell module (à installer avecInstall-Module SqlServer)

• .NET Framework 4.6.2 ou version ultérieure, ou .NET 6+ pour multiplateforme

Configuration des scripts clés

Lorsque vous utilisez SMO pour exporter des scripts pour une source hors ligne, configurez les options de script suivantes :

Options de script SMO requises

Option	Value
ToFileOnly	True
Encoding	Unicode
AppendToFile	False
IncludeHeaders	True
IncludeDatabaseContext	True
SchemaQualify	True
AnsiPadding	True
Default	True
DriAll	True
Indexes	True
Triggers	True
FullTextIndexes	True
ExtendedProperties	True
ScriptDataCompression	True
ScriptDrops	False
IncludeIfNotExists	False
WithDependencies	False
NoCollation	True
Permissions	False
ContinueScriptingOnError	True

Exemple de PowerShell script

Le script suivant exporte tous les objets de base de données vers des .sql fichiers individuels. Chaque fichier contient une CREATE instruction pour un seul objet de base de données.

# Export SQL Server database objects using SMO
# Usage: .\Export-Database.ps1 -Database "MyDB" -OutputDir "C:\export\MyDB"

param(
    [string] $ServerInstance = "localhost",         # SQL Server instance name
    [Parameter(Mandatory)] [string] $Database,     # Database to export
    [Parameter(Mandatory)] [string] $OutputDir,    # Output directory for .sql files
    [switch] $TrustServerCertificate               # Skip certificate validation
)

$ErrorActionPreference = "Stop"

# Load the SqlServer module (includes SMO assemblies)
Import-Module SqlServer -ErrorAction Stop

# Connect to SQL Server
$srv = New-Object Microsoft.SqlServer.Management.Smo.Server($ServerInstance)
$srv.ConnectionContext.EncryptConnection = $true
if ($TrustServerCertificate) {
    $srv.ConnectionContext.TrustServerCertificate = $true
}

# Get the database
$db = $srv.Databases[$Database]
if (-not $db) { Write-Error "Database '$Database' not found."; exit 1 }
if (-not (Test-Path $OutputDir)) { New-Item -ItemType Directory -Path $OutputDir -Force | Out-Null }

# Configure scripting options for offline source compatibility
$scripter = New-Object Microsoft.SqlServer.Management.Smo.Scripter($srv)
$opts = $scripter.Options
$opts.ToFileOnly             = $true       # Write directly to files
$opts.Encoding               = [System.Text.Encoding]::Unicode  # Unicode encoding
$opts.AppendToFile           = $false      # One object per file
$opts.IncludeHeaders         = $true       # Add descriptive headers
$opts.IncludeDatabaseContext = $true       # Add USE [database] statement
$opts.SchemaQualify          = $true       # Use schema.object format
$opts.AnsiPadding            = $true       # Include ANSI_PADDING settings
$opts.Default                = $true       # Include default constraints
$opts.DriAll                 = $true       # Include all constraints and keys
$opts.Indexes                = $true       # Include indexes
$opts.Triggers               = $true       # Include triggers
$opts.FullTextIndexes        = $true       # Include full-text indexes
$opts.ExtendedProperties     = $true       # Include extended properties
$opts.ScriptDataCompression  = $true       # Include data compression settings
$opts.ScriptDrops            = $false      # CREATE only, no DROP statements
$opts.IncludeIfNotExists     = $false      # No IF NOT EXISTS wrapper
$opts.WithDependencies       = $false      # Do not script dependent objects
$opts.NoCollation            = $true       # Omit collation clauses
$opts.Permissions            = $false      # Omit permissions
$opts.ContinueScriptingOnError = $true     # Skip errors, continue with next object

# Define which object types to export
$collections = [ordered]@{
    "Schemas"               = "Schema"
    "Tables"                = "Table"
    "Views"                 = "View"
    "StoredProcedures"      = "StoredProcedure"
    "UserDefinedFunctions"  = "UserDefinedFunction"
    "Sequences"             = "Sequence"
    "Synonyms"              = "Synonym"
    "UserDefinedDataTypes"  = "UserDefinedDataType"
    "UserDefinedTableTypes" = "UserDefinedTableType"
    "UserDefinedTypes"      = "UserDefinedType"
    "UserDefinedAggregates" = "UserDefinedAggregate"
    "XmlSchemaCollections"  = "XmlSchemaCollection"
    "Rules"                 = "Rule"
    "Defaults"              = "Default"
    "PartitionSchemes"      = "PartitionScheme"
    "PartitionFunctions"    = "PartitionFunction"
    "Assemblies"            = "SqlAssembly"
    "FullTextCatalogs"      = "FullTextCatalog"
    "FullTextStopLists"     = "FullTextStopList"
    "SearchPropertyLists"   = "SearchPropertyList"
    "SecurityPolicies"      = "SecurityPolicy"
    "ExternalDataSources"   = "ExternalDataSource"
    "ExternalFileFormats"   = "ExternalFileFormat"
}

# System schemas to skip
$sysSchemas = 'dbo','guest','INFORMATION_SCHEMA','sys',
    'db_owner','db_accessadmin','db_securityadmin','db_ddladmin',
    'db_backupoperator','db_datareader','db_datawriter',
    'db_denydatareader','db_denydatawriter'

# Export the CREATE DATABASE statement
$dbScripter = New-Object Microsoft.SqlServer.Management.Smo.Scripter($srv)
$dbScripter.Options.ToFileOnly = $true
$dbScripter.Options.Encoding = [System.Text.Encoding]::Unicode
$dbScripter.Options.IncludeDatabaseContext = $true
$dbScripter.Options.FileName = Join-Path $OutputDir "$Database.Database.sql"
$dbScripter.Script($db)

# Export each object to a separate .sql file
foreach ($colName in $collections.Keys) {
    $col = $db.$colName
    if (-not $col -or $col.Count -eq 0) { continue }

    foreach ($obj in $col) {
        # Skip system objects
        if ($obj.PSObject.Properties['IsSystemObject'] -and $obj.IsSystemObject) { continue }
        if ($colName -eq "Schemas" -and $obj.Name -in $sysSchemas) { continue }

        # Build the output file name: schema.objectname.type.sql
        $schema = if ($obj.PSObject.Properties['Schema']) { $obj.Schema } else { "" }
        $safeName = $obj.Name -replace '[\\/:*?"<>|]', '_'
        $fileName = if ($schema) { "$schema.$safeName.$($collections[$colName]).sql" }
                    else { "$safeName.$($collections[$colName]).sql" }

        $opts.FileName = Join-Path $OutputDir $fileName
        $scripter.Script($obj)
    }
}