Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Exporter des objets de base de données SQL Server
<a name="export-sql-server-database-objects"></a>

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**.

1. Choisissez **Enregistrer en tant que fichier script**.

1. 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.

1. 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.

1. Pour **Enregistrer sous**, choisissez le **texte Unicode**.

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

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

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

1. Choisissez **Next** pour générer les scripts.

1. 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 avec`Install-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)
    }
}
```

------