Exportieren Sie SQL Server-Datenbankobjekte

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.

2. Wählen Sie Als Skriptdatei speichern.

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

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

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

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

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

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

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

10. 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)
    }
}