Come posso confrontare lo schema di due database?

C'è un modo per trovare le differenze in due database di SQL Server (solo schema). Uno è locale e il secondo è presso il sito di un cliente. Stiamo riscontrando problemi con i report Crystal che eseguono alcuni report e alcuni codici non in esecuzione e sembra che gli schemi non corrispondano.

Posso eseguire lo stesso comando su entrambi i database e confrontare i risultati per dire dove sono le differenze?

Se non è possibile utilizzare uno dei tanti strumenti disponibili a causa di problemi di connettività e si desidera un confronto "offline", è possibile utilizzare SSMS per generare script per tutti gli oggetti del database facendo clic con il pulsante destro del mouse sul database e utilizzando "Attività ... / Genera Script "e assicurati di selezionare per creare un file per oggetto.

Al termine di entrambi i database, ottenere i due set di script su un computer locale in due cartelle separate e utilizzare WinMerge (o simile) per confrontare i due.

Un'altra opzione è utilizzare SQL Server Data Tools (SSDT), un'estensione di Visual Studio. È possibile estrarre lo schema del database come file .dacpac e confrontarlo con un altro file .dacpac o un database esistente. SSDT è incluso con gli strumenti client di SQL Server 2012, rendendolo abbastanza accessibile. Puoi trovare le istruzioni complete su come eseguire il confronto sul sito MSDN .

Dopo aver lottato con un modo semplice per fare questa stessa attività - vedi cosa è cambiato tra 2 modelli, ho scritto il seguente script SQL che confronterà due schemi per determinare le colonne nuove ed eliminate

set nocount on;
-- Set the two variables newmodel and oldmodel to the appropriate database names and execute the script

declare @newmodel varchar(50), @oldmodel varchar(50);

Set @newmodel = '[NewModel to Compare]';
set @oldmodel = '[OldModel to Compare]';


Declare @Temp table (TABLE_SCHEMA varchar(40), TABLE_NAME varchar(40), COLUMN_NAME varchar(50), ORDINAL_POSITION int, IS_NULLABLE varchar(5), NullChange varchar(5), Comment varchar(50));

Declare @script varchar(5000);


set @script = '
Select nc.TABLE_SCHEMA, nc.TABLE_NAME, nc.COLUMN_NAME, nc.ORDINAL_POSITION, nc.IS_NULLABLE, IIF(nc.IS_NULLABLE <> oc.IS_NULLABLE, ''Yes'', ''No''), 
        IIF(oc.COLUMN_NAME IS NULL, convert(varchar(20), ''ADDED COLUMN''), convert(varchar(20), ''--'')) as Comment
    from {NEW}.INFORMATION_SCHEMA.COLUMNS nc
        LEFT join {OLD}.INFORMATION_SCHEMA.COLUMNS oc 
            on nc.TABLE_NAME = oc.TABLE_NAME and nc.COLUMN_NAME = oc.COLUMN_NAME
UNION ALL
    Select oc.TABLE_SCHEMA, oc.TABLE_NAME, oc.COLUMN_NAME, oc.ORDINAL_POSITION, oc.IS_NULLABLE, ''No'', ''DELETED COLUMN'' as Comment
    from {OLD}.INFORMATION_SCHEMA.COLUMNS oc
    where CONCAT(oc.TABLE_NAME, ''.'', oc.COLUMN_NAME) 
        not in (Select CONCAT(TABLE_NAME, ''.'', COLUMN_NAME) from {NEW}.INFORMATION_SCHEMA.COLUMNS)
';


Set @script = replace(@script, '{OLD}', @oldmodel);
Set @script = replace(@script, '{NEW}', @newmodel);

--print @script

Insert into @Temp
    exec(@script);

Select * from @Temp where Comment <> '--'
order by TABLE_NAME, ORDINAL_POSITION, COLUMN_NAME;
go

Se è necessario confrontare più di un file di database, è possibile eseguire lo script SQLPackage.exe.

Non ho un codice funzionante per te, ma potresti prendere spunto dalla documentazione di SQLPackage.exe .

Estrarre il database master in un file dacpac e quindi confrontare il file dacpac con il resto dei database. Il risultato del confronto potrebbe essere un rapporto xml delle modifiche o un file .sql che è possibile eseguire per sincronizzare i database.

Qualcosa come questo:

sqlpackage.exe /a:Extract /scs:Server=MyLaptopSQL2014;Database=Test; /tf:C:UsersKevin3NFDocumentsSQLScriptsDACPACSTest.dacpac  

e poi

sqlpackage.exe /a:Script /sf:C:UsersKevin3NFDocumentsSQLScriptsDACPACSTest.dacpac /tsn:MyLaptopSQL2014 /tdn:Test1 /op:C:UsersKevin3NFDocumentsSQLScriptsDACPACSDeltasTest1.sql /p:DropObjectsNotInSource=True /p:DropIndexesNotInSource=True 
 sqlpackage.exe /a:Script /sf:C:UsersKevin3NFDocumentsSQLScriptsDACPACSTest.dacpac /tsn:MyLaptopSQL2014 /tdn:Test2 /op:C:UsersKevin3NFDocumentsSQLScriptsDACPACSDeltasTest2.sql /p:DropObjectsNotInSource=True /p:DropIndexesNotInSource=True 

Puoi dare un'occhiata a questo articolo o questo per il codice di esempio.

Fai una ricerca per "SQL Server Compare" e troverai molti strumenti. Quello che usiamo nel mio lavoro è Red Gate SQLCompare . Ha una prova di 14 giorni. Ma dal momento che stai parlando di due ambienti diversi, non penso che funzionerebbe per te, a meno che il client non ti invii un backup del loro DB. L'altra opzione è scrivere query sulle tabelle di sistema (come sys.indexes, sys.tables, ecc.).

Il modo più semplice è utilizzare uno strumento automatizzato creato per questo scopo , ma se non ne hai accesso a uno, puoi ottenere tutte le informazioni di base che ti servono dalle INFORMATION_SCHEMAviste.

L'uso dei metadati in INFORMATION_SCHEMAè probabilmente un'opzione più semplice rispetto alla generazione di script DDL e al confronto dei sorgenti perché hai un controllo molto maggiore sul modo in cui i dati vengono presentati. Non puoi davvero controllare l'ordine in cui gli script generati presenteranno gli oggetti in un database. Inoltre, gli script contengono un sacco di testo che potrebbe dipendere dall'implementazione per impostazione predefinita e può causare un sacco di "rumore" non corrispondente quando ciò su cui probabilmente devi veramente concentrarti è una tabella, una vista o una colonna mancante, o forse un tipo di dati di colonna o dimensioni non corrispondenti.

Scrivi una query (o query) per ottenere le informazioni importanti per il tuo codice dalle INFORMATION_SCHEMAviste ed eseguirle su ogni SQL Server da SSMS. È quindi possibile scaricare i risultati in un file e utilizzare uno strumento di confronto dei file di testo (anche MS Word) oppure è possibile scaricare i risultati in tabelle ed eseguire query SQL per trovare discrepanze.

Includo questa risposta nell'interesse di una nuova domanda che è stata contrassegnata come duplicata.

Una volta ho dovuto confrontare due database di produzione e trovare eventuali differenze di schema tra di loro. Gli unici elementi di interesse erano le tabelle che erano state aggiunte o eliminate e le colonne che erano state aggiunte, rimosse o modificate. Non ho più gli script SQL che ho sviluppato, ma ciò che segue è la strategia generale. E il database non era SQL Server, ma penso che si applichi la stessa strategia.

Innanzitutto, ho creato quello che può essere meglio descritto come metadatabase. Le tabelle utente di questo database contenevano descrizioni dei dati copiate dalle tabelle di sistema dei database di produzione. Cose come Nome tabella, Nome colonna, Tipo di dati e Precisione. C'era un altro elemento, Nome database, che non esisteva in nessuno dei database di produzione.

Successivamente, ho sviluppato degli script che accoppiavano selezioni dalle tabelle di sistema dei database di produzione con inserimenti nelle tabelle utente del metadatabase.

Infine, ho sviluppato query per trovare tabelle esistenti in un database ma non nell'altro e colonne da tabelle in entrambi i database che erano solo in un database e colonne con definizioni incoerenti tra i due database.

Di circa 100 tabelle e 600 colonne, ho trovato una manciata di incoerenze e una colonna che è stata definita come un punto mobile in un database e un numero intero nell'altro. Quest'ultimo si è rivelato essere una manna dal cielo, perché ha portato alla luce un problema che aveva afflitto uno dei database per anni.

Il modello per il metadatabase è stato suggerito dalle tabelle di sistema in questione. Le query non erano difficili da costruire, ruotando principalmente attorno al gruppo e avendo count (nome del database) = 1.

Nel tuo caso, con 700 database di produzione, potresti voler automatizzare i primi due passaggi più di quanto ho fatto con solo due database da confrontare. Ma l'idea è simile.

Avevo la stessa identica domanda e credo che Microsoft SQL Server Management Studio (SSMS) abbia una soluzione molto più semplice / semplice di qualsiasi altra cosa abbia visto qui. Ho un sito di produzione con MS SQL Server Express e presto ne avrò molti altri in cui non voglio installare VisualStudio o altre applicazioni diverse da SSMS.

Quindi all'interno di SSMS, fare clic con il tasto destro sul database per ottenere lo schema. Selezionare Attività> Genera script ... per aprire una procedura guidata per eseguire lo script dello schema e della configurazione per l'intero database (o oggetti selezionati, se lo si desidera). Ho mantenuto tutte le opzioni predefinite tranne il percorso / nome file, ma lo strumento ha una pletora di opzioni. La procedura guidata ha creato un SQL che ho copiato tramite OneDrive sul mio PC. Ho quindi usato Notepad ++ per confrontare l'SQL con un file generato allo stesso modo con il mio database SIT. Devi filtrare i risultati dalla data / ora nei commenti, ma per il resto è un ottimo confronto tra i due database.

Presto! Scrivere questo è stato significativamente più difficile che fare il confronto reale.

Un ottimo strumento che uso (anche se non aggiornato da un po 'funziona ancora) è AdeptSqlDiff

Vengono confrontati sia lo schema che i dati. Proprio come RedGate c'è un costo ma anche una prova di 30 giorni. E il prezzo è abbastanza ragionevole.

Forse questo script gratuito https://github.com/dlevsha/compalex può aiutarti. Supporta Microsoft SQL Server.

Compalex è uno script leggero gratuito per confrontare due schemi di database. Supporta MySQL, MS SQL Server e PostgreSQL.

Puoi provare la demo qui

http://demo.compalex.net/

Esistono molti strumenti di terze parti che confronteranno schema e dati e sincronizzazione. Due strumenti che puoi usare sono quelli che io e il mio team abbiamo sviluppato, xSQL Schema Compare per confronti di schemi e xSQL Data Compare per confronti di dati tra oggetti con lo stesso schema. Spero che sia di aiuto!
Disclaimer: sono affiliato a xSQL

Ci sono molti strumenti sul mercato che potresti usare per fare il lavoro. La mia azienda sta usando ApexSQL Diff sia per il confronto che per la sincronizzazione perché è gratuito per Azure, ma non si può sbagliare con gli strumenti Devart o Redgate.

Sono un fan di SQL DBDiff , che è uno strumento open source che puoi utilizzare per confrontare tabelle, viste, funzioni, utenti, ecc. Di due istanze di database di SQL Server e generare uno script di modifica tra i database di origine e di destinazione.

Ho realizzato un'utilità MssqlMerge che consente di confrontare i database MSSQL, sia la struttura che i dati. È disponibile una versione gratuita che consente di confrontare definizioni di tabelle, viste, procedure e funzioni memorizzate. Inoltre, esiste una versione Pro che supporta più tipi di oggetti e dispone della funzione "Differenza risultati query" in cui è possibile eseguire e confrontare tutti i risultati delle query, comprese le query con le visualizzazioni di sistema, per confrontare alcuni altri dettagli non disponibili.

Controllalo:

SELECT TABLE_SCHEMA ,
       TABLE_NAME ,
       COLUMN_NAME ,
       ORDINAL_POSITION ,
       COLUMN_DEFAULT ,
       DATA_TYPE ,
       CHARACTER_MAXIMUM_LENGTH ,
       NUMERIC_PRECISION ,
       NUMERIC_PRECISION_RADIX ,
       NUMERIC_SCALE ,
       DATETIME_PRECISION
FROM   INFORMATION_SCHEMA.COLUMNS
where TABLE_SCHEMA in ('dbo','meta')
and table_name in (select name from sys.tables)
order by TABLE_SCHEMA ,       TABLE_NAME ,ORDINAL_POSITION

Uso questo strumento gratuito (e open source): OpenDBDiff

DBDiff è lo strumento migliore per questo, lo puoi trovare qui .