Exporte objetos de bases de datos de SQL Server

En el caso de una fuente sin conexión, debe cargar los archivos de script exportados que describen los objetos de la base de datos de origen. Puede exportarlos con cualquier herramienta disponible. Las siguientes pestañas describen dos enfoques: SQL Server Management Studio (SSMS) y SQL Server Management Objects (SMO).

SSMS

1. En SSMS, en el Explorador de objetos, haga clic con el botón derecho en la base de datos que desee exportar. Elija Tareas y, a continuación, elija Generar scripts.

2. Seleccione Guardar como archivo de script.

3. En Archivos para generar, elija Un archivo de script por objeto para crear un .sql archivo independiente para cada objeto de la base de datos.

4. En Nombre de directorio, introduzca la ruta a un directorio para los archivos de salida. Se recomienda crear un directorio con el mismo nombre que la base de datos.

5. En Guardar como, selecciona Texto Unicode.

6. Seleccione Avanzado para abrir el cuadro de diálogo de opciones avanzadas de secuencias de comandos.

7. Defina las opciones según las tablas siguientes.

8. Haga clic en Aceptar y, a continuación, en Siguiente para revisar el resumen.

9. Seleccione Siguiente para generar los scripts.

10. Elija Finish para cerrar el asistente.

Opciones de secuencias de comandos avanzadas

Defina las siguientes opciones en el cuadro de diálogo Opciones avanzadas de secuencias de comandos.

Opciones generales

Opción	Valor
Relleno ANSI	False
Anexar al archivo	False
Compruebe la existencia del objeto	False
Continúe con la secuencia de comandos en caso de error	True
Convierta los UDDT en tipos base	False
Genere un script para objetos dependientes	True
Incluya encabezados descriptivos	False
Incluya el encabezado de los parámetros de secuencias de comandos	False
Incluya los nombres de las restricciones del sistema	False
Nombres de objetos aptos para esquemas	True
Encuadernación de	False
Intercalación de guiones	True
Valores predeterminados del script	True
Script DROP AND CREATE	Script CREATE
Propiedades extendidas del script	True
Inicios de sesión en scripts	False
Permisos de scripts Object-Level	False
Propietario del script	False
Estadísticas del script	No escriba las estadísticas
Script USE LA BASE DE DATOS	True
Tipos de datos que se van a codificar	Solo esquema

Table/View opciones

Opción	Valor
Seguimiento de cambios de script	False
Restricciones de verificación de scripts	True
Opciones de compresión de datos de scripts	False
Claves foráneas del script	True
Full-Text Índice de scripts	True
Índice de guiones	True
Claves principales del script	True
Activadores de guiones	True
Teclas únicas del script	True

SMO

SQL Server Management Objects (SMO) es una API.NET para administrar SQL Server mediante programación. Puede usar SMO con PowerShell o C# para crear scripts de objetos de bases de datos y generar archivos DDL para usarlos con una fuente fuera de línea.

Requisitos previos

• Windows PowerShell 5.1 o posterior, o 7+ PowerShell

• El SqlServer PowerShell módulo (instálelo conInstall-Module SqlServer)

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

Configuración de secuencias de comandos clave

Cuando utilice SMO para exportar scripts a una fuente sin conexión, configure las siguientes opciones de secuencias de comandos:

Opciones de secuencias de comandos SMO requeridas

Opción	Valor
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

Ejemplo PowerShell de script

El siguiente script exporta todos los objetos de la base de datos a .sql archivos individuales. Cada archivo contiene una CREATE sentencia para un único objeto de base de datos.

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