Exportar objetos de banco de dados do SQL Server

Para uma fonte off-line, você carrega arquivos de script exportados que descrevem os objetos do banco de dados de origem. Você pode exportá-los usando qualquer ferramenta disponível. As guias a seguir descrevem duas abordagens: SQL Server Management Studio (SSMS) e SQL Server Management Objects (SMO).

SSMS

1. No SSMS, no Object Explorer, clique com o botão direito do mouse no banco de dados a ser exportado. Escolha Tarefas e, em seguida, escolha Gerar scripts.

2. Escolha Salvar como arquivo de script.

3. Em Arquivos a serem gerados, escolha Um arquivo de script por objeto para criar um .sql arquivo separado para cada objeto do banco de dados.

4. Em Nome do diretório, insira o caminho para um diretório para os arquivos de saída. Recomendamos criar um diretório com o mesmo nome do banco de dados.

5. Em Salvar como, escolha Texto Unicode.

6. Escolha Avançado para abrir a caixa de diálogo Opções avançadas de script.

7. Defina as opções de acordo com as tabelas a seguir.

8. Escolha OK e, em seguida, escolha Avançar para revisar o resumo.

9. Escolha Avançar para gerar os scripts.

10. Escolha Finalizar para fechar o assistente.

Opções avançadas de script

Defina as seguintes opções na caixa de diálogo Opções avançadas de script.

Opções gerais

Opção	Valor
Preenchimento ANSI	Falso
Anexar ao arquivo	Falso
Verifique a existência do objeto	Falso
Continue escrevendo em caso de erro	Verdadeiro
Converter UDDTs em tipos básicos	Falso
Gerar script para objetos dependentes	Verdadeiro
Incluir cabeçalhos descritivos	Falso
Incluir cabeçalho de parâmetros de script	Falso
Incluir nomes de restrições do sistema	Falso
O esquema qualifica nomes de objetos	Verdadeiro
Vinculação de script	Falso
Compilação de scripts	Verdadeiro
Padrões de script	Verdadeiro
Script DROP AND CREATE	Script CREATE
Propriedades estendidas do script	Verdadeiro
Logins de script	Falso
Object-Level Permissões de script	Falso
Proprietário do script	Falso
Estatísticas do script	Não crie scripts de estatísticas
Script USE DATABASE	Verdadeiro
Tipos de dados a serem roteirizados	Somente esquema

Table/View opções

Opção	Valor
Monitoramento de alterações de script	Falso
Restrições de verificação de script	Verdadeiro
Opções de compactação de dados de script	Falso
Chaves estrangeiras do script	Verdadeiro
Full-Text Índice de scripts	Verdadeiro
Índice de scripts	Verdadeiro
Chaves primárias do script	Verdadeiro
Acionadores de script	Verdadeiro
Chaves exclusivas do script	Verdadeiro

SMO

O SQL Server Management Objects (SMO) é uma API do.NET para gerenciar programaticamente o SQL Server. Você pode usar SMO com PowerShell ou C# para criar scripts de objetos de banco de dados e gerar arquivos DDL para uso com uma fonte off-line.

Pré-requisitos

• Windows PowerShell 5.1 ou posterior, ou PowerShell 7+

• O SqlServer PowerShell módulo (instalar comInstall-Module SqlServer)

• .NET Framework 4.6.2 ou posterior, ou .NET 6+ para multiplataforma

Configuração de script de chave

Ao usar o SMO para exportar scripts para uma fonte off-line, configure as seguintes opções de script:

Opções de script SMO necessárias

Opção	Valor
ToFileOnly	Verdadeiro
Encoding	Unicode
AppendToFile	Falso
IncludeHeaders	Verdadeiro
IncludeDatabaseContext	Verdadeiro
SchemaQualify	Verdadeiro
AnsiPadding	Verdadeiro
Default	Verdadeiro
DriAll	Verdadeiro
Indexes	Verdadeiro
Triggers	Verdadeiro
FullTextIndexes	Verdadeiro
ExtendedProperties	Verdadeiro
ScriptDataCompression	Verdadeiro
ScriptDrops	Falso
IncludeIfNotExists	Falso
WithDependencies	Falso
NoCollation	Verdadeiro
Permissions	Falso
ContinueScriptingOnError	Verdadeiro

Exemplo de PowerShell script

O script a seguir exporta todos os objetos do banco de dados para .sql arquivos individuais. Cada arquivo contém uma CREATE instrução para um único objeto de banco de dados.

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