Come posso automatizzare l'attività "genera script" in SQL Server Management Studio 2008?

Vorrei automatizzare la generazione di script in SQL Server Management Studio 2008.

In questo momento quello che faccio è:

• Fai clic con il pulsante destro del mouse sul mio database, Attività, "Genera script ..."
• seleziona manualmente tutte le opzioni di esportazione di cui ho bisogno e premi Seleziona tutto nella scheda "Seleziona oggetto"
• Seleziona la cartella di esportazione
• Alla fine premi il pulsante "Fine"

C'è un modo per automatizzare questa attività?

Modifica: voglio generare script di creazione , non modificare script.

Ciò che Brann menziona dalla suite del team di Visual Studio 2008 SP1 è la versione 1.4 della pubblicazione guidata del database. È installato con SQL Server 2008 (forse solo professionale?) In \ Programmi \ Microsoft SQL Server \ 90 \ Tools \ Publishing \ 1.4. La chiamata VS da server explorer chiama semplicemente this. Puoi ottenere la stessa funzionalità tramite la riga di comando come:

sqlpubwiz help script

Non so se la v1.4 abbia gli stessi problemi della v1.1 (gli utenti vengono convertiti in ruoli, i vincoli non vengono creati nell'ordine giusto), ma non è una soluzione per me perché non esegue lo script di oggetti a file diversi come l'opzione Attività-> Genera script in SSMS fa. Attualmente sto utilizzando una versione modificata di Scriptio (utilizza l'API MS SMO) per fungere da sostituto migliorato per la procedura guidata di pubblicazione del database (sqlpubwiz.exe). Al momento non è scriptabile dalla riga di comando, potrei aggiungere quel contributo in futuro.

Scriptio è stato originariamente pubblicato sul blog di Bill Graziano, ma è stato successivamente rilasciato a CodePlex da Bill e aggiornato da altri. Leggi la discussione per vedere come eseguire la compilazione per l'utilizzo con SQL Server 2008.

http://scriptio.codeplex.com/

EDIT: da allora ho iniziato a utilizzare il prodotto SQL Compare di RedGate per farlo. È un ottimo sostituto per tutto ciò che avrebbe dovuto essere la procedura guidata di pubblicazione sql. Scegli un database, un backup o un'istantanea come origine e una cartella come posizione di output e scarica tutto bene in una struttura di cartelle. Capita che sia lo stesso formato utilizzato dal loro altro prodotto, SQL Source Control.

SqlPubwiz ha opzioni molto limitate rispetto alla generazione di script in SSMS. Al contrario, le opzioni disponibili con SMO corrispondono quasi esattamente a quelle in SSMS, suggerendo che probabilmente è anche lo stesso codice. (Spero che MS non l'abbia scritto due volte!) Ci sono diversi esempi su MSDN come questo che mostrano le tabelle di scripting come singoli oggetti. Tuttavia, se si desidera che tutto funzioni correttamente con uno schema "completo" che includa oggetti "DRI" (Declarative Referential Integrity) come chiavi esterne, lo scripting delle tabelle individualmente non funziona correttamente con le dipendenze. Ho scoperto che è necessario raccogliere tutti gli URN e consegnarli allo scripter come array. Questo codice, modificato dall'esempio,

    using Microsoft.SqlServer.Management.Smo;
    using Microsoft.SqlServer.Management.Sdk.Sfc;
    // etc...

    // Connect to the local, default instance of SQL Server. 
    Server srv = new Server();

    // Reference the database.  
    Database db = srv.Databases["YOURDBHERE"];

    Scripter scrp = new Scripter(srv);
    scrp.Options.ScriptDrops = false;
    scrp.Options.WithDependencies = true;
    scrp.Options.Indexes = true;   // To include indexes
    scrp.Options.DriAllConstraints = true;   // to include referential constraints in the script
    scrp.Options.Triggers = true;
    scrp.Options.FullTextIndexes = true;
    scrp.Options.NoCollation = false;
    scrp.Options.Bindings = true;
    scrp.Options.IncludeIfNotExists = false;
    scrp.Options.ScriptBatchTerminator = true;
    scrp.Options.ExtendedProperties = true;

    scrp.PrefetchObjects = true; // some sources suggest this may speed things up

    var urns = new List<Urn>();

    // Iterate through the tables in database and script each one   
    foreach (Table tb in db.Tables)
    {
        // check if the table is not a system table
        if (tb.IsSystemObject == false)
        {
            urns.Add(tb.Urn);
        }
    }

    // Iterate through the views in database and script each one. Display the script.   
    foreach (View view in db.Views)
    {
        // check if the view is not a system object
        if (view.IsSystemObject == false)
        {
            urns.Add(view.Urn);
        }
    }

    // Iterate through the stored procedures in database and script each one. Display the script.   
    foreach (StoredProcedure sp in db.StoredProcedures)
    {
        // check if the procedure is not a system object
        if (sp.IsSystemObject == false)
        {
            urns.Add(sp.Urn);
        }
    }

    StringBuilder builder = new StringBuilder();
    System.Collections.Specialized.StringCollection sc = scrp.Script(urns.ToArray());
    foreach (string st in sc)
    {
        // It seems each string is a sensible batch, and putting GO after it makes it work in tools like SSMS.
        // Wrapping each string in an 'exec' statement would work better if using SqlCommand to run the script.
        builder.AppendLine(st);
        builder.AppendLine("GO");
    }

    return builder.ToString();

Ho scritto un'utilità della riga di comando open source denominata SchemaZen che fa questo. È molto più veloce dello scripting da Management Studio e il suo output è più intuitivo per il controllo della versione. Supporta lo scripting di schemi e dati.

Per generare script eseguire:

script schemazen.exe --server localhost --database db --scriptDir c: \ somedir

Quindi per ricreare il database dagli script eseguire:

schemazen.exe crea --server localhost --database db --scriptDir c: \ somedir

È possibile utilizzare SQL Server Management Object (SMO) per automatizzare le attività di gestione di SQL Server 2005, inclusa la generazione di script: http://msdn.microsoft.com/en-us/library/ms162169.aspx .

Se sei uno sviluppatore, scegli sicuramente SMO. Ecco un collegamento alla classe Scripter, che è il tuo punto di partenza:

Classe Scripter

Non vedo PowerShell con SQLPSX menzionato in nessuna di queste risposte ... Personalmente non ci ho giocato, ma sembra meravigliosamente semplice da usare e idealmente adatto a questo tipo di attività di automazione, con attività come:

Get-SqlDatabase -dbname test -sqlserver server | Get-SqlTable | Get-SqlScripter | Set-Content -Path C:\script.sql
Get-SqlDatabase -dbname test -sqlserver server | Get-SqlStoredProcedure | Get-SqlScripter
Get-SqlDatabase -dbname test -sqlserver server | Get-SqlView | Get-SqlScripter

(rif: http://www.sqlservercentral.com/Forums/Topic1167710-1550-1.aspx#bm1168100 )

Pagina del progetto: http://sqlpsx.codeplex.com/

Il vantaggio principale di questo approccio è che combina la configurabilità / personalizzazione dell'utilizzo diretto di SMO con la comodità e la manutenibilità dell'utilizzo di un semplice strumento esistente come la Pubblicazione guidata del database.

In Strumenti> Opzioni> Progettisti> Progettisti di tabelle e database c'è un'opzione per "Genera automaticamente script di modifica" che ne genererà uno per ogni modifica apportata al momento del salvataggio.

Puoi farlo con il codice T-SQL utilizzando le tabelle INFORMATION_SCHEMA.

Esistono anche strumenti di terze parti: mi piace Apex SQL Script proprio per l'uso di cui parli. Lo eseguo completamente dalla riga di comando.

Prova i nuovi strumenti della riga di comando di SQL Server per generare script T-SQL e monitorare le viste a gestione dinamica.

Ha funzionato per me come un fascino. È un nuovo strumento basato su Python di Microsoft che viene eseguito dalla riga di comando. Tutto funziona come descritto nella pagina Microsoft (vedi link sotto) Ha funzionato per me con il server SQL 2012.

Lo installi con pip:

$ pip install mssql-scripter

Panoramica dei parametri di comando come al solito con h per aiuto:

mssql-scripter -h

Suggerimento: se accedi a SQL-Server tramite l'autenticazione di Windows, lascia semplicemente il nome utente e la password.

https://cloudblogs.microsoft.com/sqlserver/2017/05/17/try-new-sql-server-command-line-tools-to-generate-t-sql-scripts-and-monitor-dynamic-management- visualizzazioni/

Se vuoi una soluzione Microsoft puoi provare: Pubblicazione guidata database di Microsoft SQL Server 1.1

http://www.microsoft.com/downloads/details.aspx?FamilyId=56E5B1C5-BF17-42E0-A410-371A838E570A&displaylang=en

Crea un processo batch che puoi eseguire ogni volta che devi ricostruire gli script.

Ho usato DB Comparer: è gratuito e senza problemi per l'intero DB e può essere confrontato con un altro DB e anche produrre uno script Diff. Eccellente per gli script di modifica da sviluppo a produzione. http://www.dbcomparer.com/

C'è anche questo semplice strumento da riga di comando che creo per le mie esigenze.
http://mycodepad.wordpress.com/2013/11/18/export-ms-sql-database-schema-with-c/

Può esportare un intero database e cerca di esportare oggetti crittografati. Tutto è archiviato in cartelle e file sql separati per un facile confronto dei file.

Il codice è disponibile anche su GitHub.

Da Visual Studio 2008 SP1 TeamSuite:

Nella scheda Esplora server / Connessioni dati, è presente uno strumento di pubblicazione su provider che funziona come "Pubblicazione guidata database di Microsoft SQL Server", ma è compatibile con MS Sql Server 2008.

Sto usando VS 2012 (per DB su MSSQL Server 2008) il database di confronto ha un'opzione per salvarlo, il confronto e le opzioni. Queste sono essenzialmente le tue impostazioni per la consegna. Dopodiché puoi aggiornare o generare script.

Trovo solo un po 'imbarazzante caricarlo da file in un secondo momento (trascina e rilascia da Windows Explorer) poiché non vedo il file in Esplora soluzioni.