Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Exporte objetos de bases de datos de SQL Server
<a name="export-sql-server-database-objects"></a>

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

1. Seleccione **Guardar como archivo de script**.

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

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

1. **En Guardar como**, selecciona **Texto Unicode**.

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

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

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

1. Seleccione **Siguiente** para generar los scripts.

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

------