Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Exportieren Sie SQL Server-Datenbankobjekte
<a name="export-sql-server-database-objects"></a>

Für eine Offline-Quelle laden Sie exportierte Skriptdateien hoch, die Ihre Quelldatenbankobjekte beschreiben. Sie können sie mit jedem verfügbaren Tool exportieren. Auf den folgenden Registerkarten werden zwei Ansätze beschrieben: SQL Server Management Studio (SSMS) und SQL Server Management Objects (SMO).

------
#### [ SSMS ]

1. Klicken Sie in SSMS im Object Explorer mit der rechten Maustaste auf die zu exportierende Datenbank. Wählen Sie **Tasks** und anschließend **Generate Scripts** aus.

1. Wählen Sie **Als Skriptdatei speichern**.

1. Wählen Sie unter **Zu generierende Dateien** die Option **Eine Skriptdatei pro Objekt** aus, um für jedes Datenbankobjekt eine separate `.sql` Datei zu erstellen.

1. Geben Sie **unter Verzeichnisname** den Pfad zu einem Verzeichnis für die Ausgabedateien ein. Wir empfehlen, ein Verzeichnis mit demselben Namen wie die Datenbank zu erstellen.

1. Wählen **Sie für Speichern unter** die Option **Unicode-Text** aus.

1. Wählen Sie „**Erweitert**“, um das Dialogfeld „**Erweiterte Skriptoptionen**“ zu öffnen.

1. Stellen Sie die Optionen gemäß den folgenden Tabellen ein.

1. Wählen Sie **OK** und dann **Weiter**, um die Zusammenfassung zu überprüfen.

1. Wählen Sie **Weiter**, um die Skripts zu generieren.

1. Klicken Sie auf **Finish**, um den Assistenten zu schließen.

**Erweiterte Skriptoptionen**

Stellen Sie im Dialogfeld „**Erweiterte Skriptoptionen“ die folgenden Optionen** ein.


**Allgemeine Optionen**  

| Option | Wert | 
| --- | --- | 
| ANSI-Polsterung | Falsch | 
| An Datei anhängen | Falsch | 
| Prüfen Sie, ob ein Objekt existiert | Falsch | 
| Setzen Sie das Scripting bei einem Fehler fort | Wahr | 
| UDDTs in Basistypen konvertieren | Falsch | 
| Generieren Sie ein Skript für abhängige Objekte | Wahr | 
| Beschreibende Überschriften einbeziehen | Falsch | 
| Header für Skriptparameter einbeziehen | Falsch | 
| Schließen Sie Namen von Systemeinschränkungen ein | Falsch | 
| Objektnamen nach Schema qualifizieren | Wahr | 
| Skriptbindung | Falsch | 
| Sortierung von Skripten | Wahr | 
| Standardeinstellungen für Skripts | Wahr | 
| Skript DROP UND CREATE | Skript ERSTELLEN | 
| Erweiterte Eigenschaften des Skripts | Wahr | 
| Skript-Anmeldungen | Falsch | 
| Skriptberechtigungen Object-Level  | Falsch | 
| Besitzer des Skripts | Falsch | 
| Skript-Statistiken | Erstellen Sie keine Skript-Statistiken | 
| Skript „DATENBANK VERWENDEN“ | Wahr | 
| Arten von Daten, für die ein Skript geschrieben werden soll | Nur Schema | 


**Table/View Optionen**  

| Option | Wert | 
| --- | --- | 
| Nachverfolgung von Skriptänderungen | Falsch | 
| Einschränkungen bei der Skriptüberprüfung | Wahr | 
| Optionen für die Komprimierung von Skriptdaten | Falsch | 
| Fremdschlüssel für Skripts | Wahr | 
|  Full-Text Skript-Index | Wahr | 
| Skript-Index | Wahr | 
| Primärschlüssel des Skripts | Wahr | 
| Script-Trigger | Wahr | 
| Eindeutige Schlüssel für Skripts | Wahr | 

------
#### [ SMO ]

SQL Server Management Objects (SMO) ist eine.NET-API für die programmgesteuerte Verwaltung von SQL Server. Sie können SMO mit PowerShell oder C\# verwenden, um Datenbankobjekte zu skripten und DDL-Dateien für die Verwendung mit einer Offline-Quelle zu generieren.

**Voraussetzungen**
+ Windows PowerShell 5.1 oder höher oder 7\+ PowerShell 
+ Das `SqlServer` PowerShell Modul (mit `Install-Module SqlServer` installieren)
+ .NET Framework 4.6.2 oder höher oder .NET 6\+ für plattformübergreifende Anwendungen

**Wichtige Skriptkonfiguration**

Wenn Sie SMO verwenden, um Skripts für eine Offline-Quelle zu exportieren, konfigurieren Sie die folgenden Skriptoptionen:


**Erforderliche SMO-Skriptoptionen**  

| Option | Wert | 
| --- | --- | 
| ToFileOnly | Wahr | 
| 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 | Falsch | 
| WithDependencies | False | 
| NoCollation | True | 
| Permissions | False | 
| ContinueScriptingOnError | True | 

**Beispielskript PowerShell **

Das folgende Skript exportiert alle Datenbankobjekte in einzelne `.sql` Dateien. Jede Datei enthält eine `CREATE` Anweisung für ein einzelnes Datenbankobjekt.

```
# 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)
    }
}
```

------