SQL Server - copia stored procedure da un db a altro

Question

Sono nuovo di SQL e quello che dovevo fare era combinare 2 database mdf in uno. L'ho fatto utilizzando SQL Server 2008 Manager - Attività> Importa/Esporta tabelle. Le tabelle e le viste sono state copiate correttamente, ma non ci sono procedure memorizzate nel nuovo database. C'è un modo per farlo?

Answer 1

• clic destro sul database di
• Compiti
• generare script
• Selezionare gli oggetti che si desidera lo script
• Scrittura su file
• Run generato script contro database di destinazione

Answer 2

È possibile utilizzare la funzione "Genera script ..." di SSMS per escludere qualsiasi cosa tu n eed per il trasferimento. Fare clic con il tasto destro del mouse sul database di origine in SSMS, scegliere "Genera script ..." e seguire la procedura guidata. Quindi esegui lo script risultante che ora conterrà le istruzioni create per la stored procedure.

Answer 3

In Mgmt Studio, fare clic con il pulsante destro del mouse sul database originale, quindi Attività quindi Genera script ... - seguire la procedura guidata.

Answer 4

uso

select * from sys.procedures 

per mostrare tutte le vostre procedure;

sp_helptext @objname = 'Procedure_name' 

per ottenere il codice

e la vostra creatività per costruire qualcosa per ciclo attraverso tutti loro e generare il codice di esportazione :)

Answer 5

È possibile generare scriptof le stored procedure di come mostrato in altre risposte. Una volta che lo script è stato generato, è possibile utilizzare sqlcmd di eseguirli contro DB di destinazione come

sqlcmd -S <server name> -U <user name> -d <DB name> -i <script file> -o <output log file> 

Answer 6

tardi uno, ma fornisce maggiori dettagli che potrebbero essere utili ...

Ecco una lista delle cose che si possono fare con vantaggi e svantaggi

generare script utilizzando SSMS

• Pro: estremamente facile da utilizzare e supportato per impostazione predefinita
• Contro: Gli script potrebbero non essere nell'ordine di esecuzione corretto e potrebbero verificarsi errori se la stored procedure esiste già nel database secondario. Assicurati di rivedere lo script prima di eseguirlo.

Strumenti di terze parti

• Pro: Strumenti come ApexSQL Diff (questo è quello che uso, ma ci sono molti altri come strumenti da Red Gate o Dev Art) metterà a confronto due database in un clic e generare uno script che è possibile eseguire immediatamente
• Contro: questi non sono gratuiti (la maggior parte dei fornitori ha comunque una prova completamente funzionale)

sull'impianto Visto

• Pro: Si può facilmente vedere che esistono procedure memorizzate sul server secondario e solo generano quelli che non si dispone.
• Contro: richiede un po 'più di SQL conoscenza

Ecco come ottenere un elenco di tutte le procedure in alcuni database che non esistono in un altro database

select * 
from DB1.sys.procedures P 
where P.name not in 
(select name from DB2.sys.procedures P2) 

Answer 7

SELEZIONA definizione + char (13) + 'GO' FROM MyDatabase.sys.sql_modules s INNER JOIN MyDatabase.sys.procedures p ON [s]. [object_id] = [p]. [object_id] WHERE p.name LIKE 'Something%' "queryout "c: \ SP_scripts.sql -S MyInstance -T -t -w

ottenere lo sp ed eseguirlo

Answer 8

Questo codice copia tutte le stored procedure nel database master nel database di destinazione, è possibile copiare solo le procedure desiderate filtrando la query sul nome della procedura.

@sql è definito come nvarchar (max), @Name è il database di destinazione

DECLARE c CURSOR FOR 
    SELECT Definition 
    FROM [ResiDazeMaster].[sys].[procedures] p 
    INNER JOIN [ResiDazeMaster].sys.sql_modules m ON p.object_id = m.object_id 

OPEN c 

FETCH NEXT FROM c INTO @sql 

WHILE @@FETCH_STATUS = 0 
BEGIN 
    SET @sql = REPLACE(@sql,'''','''''') 
    SET @sql = 'USE [' + @Name + ']; EXEC(''' + @sql + ''')' 

    EXEC(@sql) 

    FETCH NEXT FROM c INTO @sql 
END    

CLOSE c 
DEALLOCATE c 

Answer 9

Originariamente ho trovato questo post alla ricerca di una soluzione per la copia di stored procedure dal mio database di produzione a distanza al mio database di sviluppo locale . Dopo aver utilizzato con successo l'approccio suggerito in questo thread, mi sono reso conto che sono diventato sempre più pigro (o intraprendente, a seconda di quello che preferisci) e volevo che fosse automatizzato. Mi sono imbattuto in this link, che ha dimostrato di essere molto utile (grazie vincpa), e ho esteso su di essa, con conseguente il seguente file (schema_backup.ps1):

$server    = "servername" 
$database   = "databaseName" 
$output_path  = "D:\prod_schema_backup" 
$login = "username" 
$password = "password" 

$schema    = "dbo" 
$table_path   = "$output_path\table\" 
$storedProcs_path = "$output_path\stp\" 
$views_path   = "$output_path\view\" 
$udfs_path   = "$output_path\udf\" 
$textCatalog_path = "$output_path\fulltextcat\" 
$udtts_path   = "$output_path\udtt\" 

[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.ConnectionInfo") | out-null 
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.SMO") | out-null 
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.SmoExtended") | out-null 
$srvConn = new-object Microsoft.SqlServer.Management.Common.ServerConnection 
$srvConn.ServerInstance = $server 
$srvConn.LoginSecure = $false 
$srvConn.Login = $login 
$srvConn.Password = $password 
$srv  = New-Object Microsoft.SqlServer.Management.SMO.Server($srvConn) 
$db   = New-Object ("Microsoft.SqlServer.Management.SMO.Database") 
$tbl  = New-Object ("Microsoft.SqlServer.Management.SMO.Table") 
$scripter = New-Object Microsoft.SqlServer.Management.SMO.Scripter($srvConn) 

# Get the database and table objects 
$db = $srv.Databases[$database] 

$tbl   = $db.tables | Where-object { $_.schema -eq $schema -and -not $_.IsSystemObject } 
$storedProcs = $db.StoredProcedures | Where-object { $_.schema -eq $schema -and -not $_.IsSystemObject } 
$views   = $db.Views | Where-object { $_.schema -eq $schema } 
$udfs   = $db.UserDefinedFunctions | Where-object { $_.schema -eq $schema -and -not $_.IsSystemObject } 
$catlog   = $db.FullTextCatalogs 
$udtts   = $db.UserDefinedTableTypes | Where-object { $_.schema -eq $schema } 

# Set scripter options to ensure only data is scripted 
$scripter.Options.ScriptSchema = $true; 
$scripter.Options.ScriptData = $false; 

#Exclude GOs after every line 
$scripter.Options.NoCommandTerminator = $false; 
$scripter.Options.ToFileOnly   = $true 
$scripter.Options.AllowSystemObjects = $false 
$scripter.Options.Permissions   = $true 
$scripter.Options.DriAllConstraints  = $true 
$scripter.Options.SchemaQualify   = $true 
$scripter.Options.AnsiFile    = $true 

$scripter.Options.SchemaQualifyForeignKeysReferences = $true 

$scripter.Options.Indexes    = $true 
$scripter.Options.DriIndexes   = $true 
$scripter.Options.DriClustered   = $true 
$scripter.Options.DriNonClustered  = $true 
$scripter.Options.NonClusteredIndexes = $true 
$scripter.Options.ClusteredIndexes  = $true 
$scripter.Options.FullTextIndexes  = $true 

$scripter.Options.EnforceScriptingOptions = $true 

function CopyObjectsToFiles($objects, $outDir) { 
    #clear out before 
    Remove-Item $outDir* -Force -Recurse 
    if (-not (Test-Path $outDir)) { 
     [System.IO.Directory]::CreateDirectory($outDir) 
    } 

    foreach ($o in $objects) { 

     if ($o -ne $null) { 

      $schemaPrefix = "" 

      if ($o.Schema -ne $null -and $o.Schema -ne "") { 
       $schemaPrefix = $o.Schema + "." 
      } 

      #removed the next line so I can use the filename to drop the stored proc 
      #on the destination and recreate it 
      #$scripter.Options.FileName = $outDir + $schemaPrefix + $o.Name + ".sql" 
      $scripter.Options.FileName = $outDir + $schemaPrefix + $o.Name 
      Write-Host "Writing " $scripter.Options.FileName 
      $scripter.EnumScript($o) 
     } 
    } 
} 

# Output the scripts 
CopyObjectsToFiles $tbl $table_path 
CopyObjectsToFiles $storedProcs $storedProcs_path 
CopyObjectsToFiles $views $views_path 
CopyObjectsToFiles $catlog $textCatalog_path 
CopyObjectsToFiles $udtts $udtts_path 
CopyObjectsToFiles $udfs $udfs_path 

Write-Host "Finished at" (Get-Date) 
$srv.ConnectionContext.Disconnect() 

Ho un file .bat che chiama questo e viene chiamato da Task Scheduler. Dopo la chiamata al file PowerShell, ho:

for /f %f in ('dir /b d:\prod_schema_backup\stp\') do sqlcmd /S localhost /d dest_db /Q "DROP PROCEDURE %f" 

Quella linea passerà attraverso la directory e rilasciare le procedure che sta per ricreare. Se questo non fosse un ambiente di sviluppo, non mi piacerebbe che le procedure scendessero a livello di codice in questo modo. Quindi rinominare tutti i file di stored procedure da avere.sql:

powershell Dir d:\prod_schema_backup\stp\ | Rename-Item -NewName { $_.name + ".sql" } 

e quindi eseguire:

for /f %f in ('dir /b d:\prod_schema_backup\stp\') do sqlcmd /S localhost /d dest_db /E /i "%f".sql 

E che consente di scorrere tutti i file sql e ricrea le stored procedure. Spero che qualsiasi parte di questo si riveli utile a qualcuno.