¿Cómo puedo comparar el esquema de dos bases de datos?

¿Hay alguna manera de encontrar las diferencias en dos bases de datos de SQL Server (solo esquema). Uno es local y el segundo está en el sitio de un cliente. Estamos experimentando problemas con los informes de Crystal que ejecutan algunos informes y algunos códigos no se ejecutan y parece que los esquemas no coinciden.

¿Puedo ejecutar el mismo comando en ambas bases de datos y comparar los resultados para saber dónde están las diferencias?

Si no puede usar una de las muchas herramientas existentes debido a problemas de conectividad y desea una comparación "fuera de línea", puede usar SSMS para generar scripts para todos los objetos de la base de datos haciendo clic con el botón derecho en la base de datos y usando "Tareas ... / Generar "Scripts", y asegúrese de seleccionar crear un archivo por objeto.

Cuando haya hecho eso para ambas bases de datos, obtenga los dos conjuntos de scripts en una máquina local en dos carpetas separadas y use WinMerge (o similar) para comparar los dos.

Otra opción es usar las herramientas de datos de SQL Server (SSDT), una extensión de Visual Studio. Puede extraer el esquema de su base de datos como un archivo .dacpac y compararlo con otro archivo .dacpac o una base de datos existente. SSDT se incluye con las herramientas de cliente de SQL Server 2012, por lo que es bastante accesible. Puede encontrar las instrucciones completas sobre cómo ejecutar la comparación en el sitio de MSDN .

Después de luchar con una manera fácil de hacer esta misma tarea: ver qué ha cambiado entre 2 modelos, escribí el siguiente script SQL que comparará dos esquemas para determinar columnas nuevas y eliminadas

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

Si necesita comparar más de un archivo de base de datos, puede hacer un script SQLPackage.exe.

No tengo un código de trabajo para ti, pero puedes consultar la documentación de SQLPackage.exe para inspirarte.

Extraería su base de datos maestra a un archivo dacpac y luego compararía el archivo dacpac con el resto de sus bases de datos. El resultado de la comparación podría ser un informe xml de los cambios o un archivo .sql que puede ejecutar para sincronizar las bases de datos.

Algo como esto:

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

y entonces

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 

Puede echar un vistazo a este artículo o este para obtener un código de muestra.

Realice una búsqueda de "SQL Server Compare" y encontrará muchas herramientas. El que usamos en mi trabajo es Red Gate SQLCompare . Tiene una prueba de 14 días. Pero como está hablando de dos entornos diferentes, no creo que funcione para usted, a menos que el cliente le envíe una copia de seguridad de su base de datos. La otra opción es escribir consultas en las tablas del sistema (como sys.indexes, sys.tables, etc.).

La forma más fácil es usar una herramienta automatizada creada para este propósito , pero si no tiene acceso a una, puede obtener toda la información básica que necesita de las INFORMATION_SCHEMAvistas.

El uso de los metadatos en INFORMATION_SCHEMAes probablemente una opción más fácil que generar scripts DDL y hacer una comparación de fuentes porque tiene mucho más control sobre cómo se presentan los datos. Realmente no puede controlar el orden en que los scripts generados presentarán los objetos en una base de datos. Además, las secuencias de comandos contienen un montón de texto que puede ser dependiente de la implementación por defecto y puede causar una gran cantidad de "ruido" no coincidente cuando probablemente lo que realmente necesita centrarse es una tabla, vista o columna que falta, o posiblemente un tipo de datos de columna o el tamaño no coincide.

Escriba una consulta (o consultas) para obtener la información que le interesa a su código de las INFORMATION_SCHEMAvistas y ejecútela en cada SQL Server desde SSMS. Luego puede volcar los resultados en un archivo y usar una herramienta de comparación de archivos de texto (incluso MS Word) o puede volcar los resultados en tablas y ejecutar consultas SQL para encontrar desajustes.

Incluyo esta respuesta en aras de una nueva pregunta que se marcó como duplicado.

Una vez tuve que comparar dos bases de datos de producción y encontrar cualquier diferencia de esquema entre ellas. Los únicos elementos de interés eran las tablas que se habían agregado o eliminado y las columnas que se habían agregado, eliminado o alterado. Ya no tengo los scripts SQL que desarrollé, pero lo que sigue es la estrategia general. Y la base de datos no era SQL Server, pero creo que se aplica la misma estrategia.

Primero, creé lo que mejor se puede describir como una metadatabase. Las tablas de usuario de esta base de datos contenían descripciones de datos copiadas de las tablas del sistema de las bases de datos de producción. Cosas como nombre de tabla, nombre de columna, tipo de datos y precisión. Había un elemento más, Nombre de la base de datos, que no existía en ninguna de las bases de datos de producción.

A continuación, desarrollé scripts que combinaban selecciones de las tablas del sistema de las bases de datos de producción con inserciones en las tablas de usuario de la metadatabase.

Finalmente, desarrollé consultas para encontrar tablas que existían en una base de datos pero no en la otra, y columnas de tablas en ambas bases de datos que solo estaban en una base de datos y columnas con definiciones inconsistentes entre las dos bases de datos.

De alrededor de 100 tablas y 600 columnas, encontré un puñado de inconsistencias, y una columna que se definió como un punto flotante en una base de datos y un número entero en la otra. Ese último resultó ser un regalo del cielo, porque descubrió un problema que había estado asolando una de las bases de datos durante años.

El modelo para la metadatabase fue sugerido por las tablas del sistema en cuestión. Las consultas no fueron difíciles de construir, girando principalmente alrededor del grupo y con count (nombre de la base de datos) = 1.

En su caso, con 700 bases de datos de producción, es posible que desee automatizar los dos primeros pasos más que yo con solo dos bases de datos para comparar. Pero la idea es similar.

Tenía exactamente la misma pregunta y creo que Microsoft SQL Server Management Studio (SSMS) tiene una solución mucho más fácil / simple que cualquier cosa que haya visto aquí. Tengo un sitio de producción con MS SQL Server Express y pronto habrá varios más donde no quiero tener que instalar VisualStudio u otras aplicaciones que no sean SSMS.

Entonces, dentro de SSMS, haga clic derecho en la base de datos para obtener el esquema. Seleccione Tareas> Generar guiones ... para abrir un asistente para guiar el esquema y la configuración de toda la base de datos (u objetos seleccionados si lo desea). Mantuve todas las opciones predeterminadas, excepto la ruta / nombre de archivo, pero la herramienta tiene una gran cantidad de opciones. El asistente creó un SQL que copié a través de OneDrive a mi PC. Luego usé Notepad ++ para comparar el SQL con un archivo generado de la misma manera contra mi base de datos SIT. Debe filtrar los resultados de la fecha / hora en los comentarios, pero de lo contrario es una gran comparación de las dos bases de datos.

¡Presto! Escribir esto fue significativamente más difícil que hacer la comparación real.

Una gran herramienta que uso (aunque no se actualiza en un tiempo todavía funciona) es AdeptSqlDiff

¿Ambos esquemas se comparan así como las comparaciones de datos? Al igual que RedGate, hay un costo pero también una prueba de 30 días. Y el precio es bastante razonable.

Tal vez este script gratuito https://github.com/dlevsha/compalex pueda ayudarlo. Es compatible con Microsoft SQL Server.

Compalex es un script ligero y gratuito para comparar dos esquemas de bases de datos. Es compatible con MySQL, MS SQL Server y PostgreSQL.

Puedes probar la demo aquí

http://demo.compalex.net/

Existen muchas herramientas de terceros que harán comparaciones de esquemas y datos, y sincronización. Dos herramientas que puede usar son las que mi equipo y yo hemos desarrollado, xSQL Schema Compare para comparaciones de esquemas y xSQL Data Compare para comparaciones de datos entre objetos con el mismo esquema. ¡Espero que esto ayude!
Descargo de responsabilidad: estoy afiliado a xSQL

Hay muchas herramientas en el mercado que puede usar para hacer el trabajo. Mi compañía está usando ApexSQL Diff para comparación y sincronización porque es gratuito para Azure, pero no puede fallar con las herramientas Devart o Redgate.

Soy fanático de SQL DBDiff , que es una herramienta de código abierto que puede usar para comparar tablas, vistas, funciones, usuarios, etc. de dos instancias de bases de datos de SQL Server y generar un script de cambio entre las bases de datos de origen y de destino.

He creado una utilidad MssqlMerge que permite comparar bases de datos MSSQL, tanto estructura como datos. Hay una versión gratuita disponible que permite comparar definiciones de tablas, vistas, procedimientos almacenados y funciones. Y también hay una versión Pro que admite más tipos de objetos y tiene la función 'Diferencia de resultado de consulta' donde puede ejecutar y comparar los resultados de cualquier consulta, incluidas las consultas con vistas del sistema, para comparar algunos otros detalles que no están disponibles de fábrica.

Mira esto:

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

Utilizo esta herramienta gratuita (y de código abierto): OpenDBDiff

DBDiff es la mejor herramienta para esto, puede encontrarlo aquí .