ultima significa servidor restaurar que nivel migrar datos compatibilidad admite actualizar sql sql-server sql-server-2008 version-control

significa - restaurar base de datos sql server 2014 a 2012



Agregar control de versión a la base de datos SQL Server existente (5)

Soy parte de un equipo de desarrollo que actualmente trabaja con una base de datos que no tiene ningún tipo de control de fuente. Trabajamos con SQL Server 2008 R2 y siempre hemos administrado la base de datos directamente con SSMS. Ahora tiene ~ 340 tablas y ~ 1600 procedimientos almacenados, además de algunos disparadores y vistas, por lo que no es una pequeña base de datos.

Mi objetivo es tener el DB bajo control de versiones, así que he estado leyendo artículos, como la serie de Scott Allen y muchas preguntas antiguas relacionadas con SO. Pero todavía no puedo decidir cómo proceder.

Lo que estoy pensando es guiar el esquema de la base de datos en un archivo, luego los procedimientos, disparadores y vistas en un archivo cada uno. Entonces mantén todo versionado bajo Mercurial. Pero, por supuesto, todos los miembros del equipo pueden acceder a SSMS y cambiar directamente el esquema y los procedimientos, con la posibilidad de que cualquiera de nosotros pueda olvidarse de replicar esos cambios en los archivos versionados.

¿Qué mejores opciones hay? Y, ¿me olvidé de cualquier elemento que valga la pena tener el control de fuente? Mi mayor preocupación es que la mayoría de la literatura que encontré explica cómo hacer control de versiones cuando se crea una nueva base de datos, pero no cuando ya es antigua y relativamente grande.

Ha habido muchas discusiones sobre este tema en muchos foros de desarrolladores.

Lo que he hecho y encontré para ser la manera más simple y limpia de hacer es esto:

  1. Extraiga el DDL de cada objeto de BD en su propio archivo, los índices y PK pueden ir en el mismo archivo que la tabla a la que pertenecen. Los FK, los procedimientos, las vistas, los factores desencadenantes, todo lo que pueda ir a través de múltiples tablas van en su propio archivo.

  2. Organice los archivos DDL en directorios por tipo de objeto (por ejemplo, tabla, procedimiento, activador, vista, etc.)

  3. Para las tablas que contienen datos de referencia estáticos (por ejemplo, código postal o estado), tenga un archivo separado con un montón de instrucciones de inserción

  4. Verifique esta estructura de directorios en cualquier control de versión que esté usando

  5. Escriba un script que atraviese esta estructura de directorio que represente su BD, la diferencie con la DB real a la que apunta (extraiga el esquema de las tablas del sistema) y aplique los diffs usando las sentencias ALTER TABLE

  6. En caso de que haya transformaciones de datos entre versiones, por ejemplo, en v1 usted tenía un campo FirstAndLastName y en v2 decidió dividirlo en FirstName y LastName, tendrá una declaración de migración / procesamiento de datos masivos.

Logré cambios de DB exitosamente en varios trabajos usando varios RDBMS diferentes. Usualmente utilizo Perl para el script que difiere el esquema DB y los archivos DDL en su imagen. Hay algunas suposiciones para este método y una de ellas es que nunca realiza ningún cambio en la base de datos directamente en la base de datos sino en sus archivos DDL y luego ejecuta la secuencia de comandos para aplicarla. Si lo haces de otra manera, se desharán cuando ejecutes el script. Entonces requiere un acuerdo de equipo y disciplina. Tu kilometraje puede variar.

Ahora, si hay una herramienta de software libre que hará esto por usted, utilícela en lugar de idear la suya. He estado haciendo las cosas de esta manera por más de 10 años

Recomendaría SQL Server Data Tools y / o un proyecto de base de datos SQL de Visual Studio. Invertirá la ingeniería de su DB existente en archivos de código (sql) que pueden ser controlados por la versión y ofrece muchas otras sutilezas (publicación, comparación, etc.)

El proceso general

Creamos una línea de base para una versión particular (digamos, v1.0 ). Una línea base incluye una secuencia de comandos de creación de esquema completa, así como una secuencia de comandos de actualización de las versiones anteriores permitidas, si corresponde (más sobre eso en un momento). Entonces para v1.0 , tendríamos solo un script:

baseline-v1.0.sql

A partir de esa línea de base, creamos scripts de cambios incrementales a medida que trabajamos desde la línea base anterior. Estos scripts se crean de forma que se vuelven a introducir, de modo que se pueden ejecutar de forma segura varias veces (donde la primera vez solo hace un trabajo real, vea el siguiente párrafo sobre cómo hacer una sugerencia). Simplemente creamos un archivo para cada secuencia de comandos de cambio con el nombre de referencia y una marca de tiempo (que llamamos la versión). Entonces, por ejemplo, digamos que creamos dos scripts de cambio después de una línea base. Tendríamos los siguientes archivos:

baseline-v1.0.sql (for creating new installations) baseline-v1.0-201211071220.sql (created on Nov. 7, 2012 at 12:20 PM UTC) baseline-v1.0-201211122019.sql (created on Nov. 12, 2012 at 8:00 PM UTC)

Creamos una tabla schema_version que tiene dos columnas: baseline y version . baseline es una etiqueta (como la v1.0 mencionada anteriormente), y la version es solo una marca de tiempo cuando se creó la secuencia de comandos de cambio (decidimos hacerlo porque la creación de números de versión arbitrarios creaba una sobrecarga administrativa molesta, donde una marca de tiempo era fácil de usar ) Entonces, antes de ejecutar el script de cambio, verificamos si el script de cambio se ha aplicado aún, al consultarlo por baseline y version . Si ya está presente, solo devuelve el script o lo que sea. De lo contrario, aplique el cambio e inserte en la tabla schema_version para marcar el script de cambio completado.

Ejemplo de secuencia de comandos de cambio:

-- Created by <developer> on Nov. 7, 2012 at 12:20 PM UTC declare @schema_baseline varchar(10), @schema_version varchar(12) set @schema_baseline = ''v1.0'' set @schema_version = ''201211071210'' if exists (select 1 from schema_version where baseline = @schema_baseline and version = @schema_version = @schema_version) return 0 -- begin change script -- place your schema changes here -- end change script insert into schema_version(@schema_baseline, @schema_version)

Ahora, cuando realmente instalamos el software, ejecutamos la secuencia de comandos de baseline correspondiente. A medida que actualizamos esa versión, simplemente aplicamos los scripts de cambio en orden.

Cuando alcanzamos un hito importante en nuestra fase de desarrollo de productos, creamos una nueva línea de base. Entonces, creamos una nueva secuencia de comandos de línea base (de nuevo, esta es una instantánea de la base de datos como línea de base), además de una secuencia de comandos de actualización de la línea de base anterior. Entonces, digamos que tenemos una nueva línea de base, v2.0 , tendríamos los siguientes archivos:

baseline-v2.0.sql (for creating new installations) baseline-v2.0-upgrade-v1.0.sql (for upgrading from v1.0)

Entonces el proceso continúa.

Cómo aplicamos los cambios

Todos los scripts se mantienen en control de fuente. Tenemos una herramienta que empaqueta estos archivos y actualiza automáticamente las bases de datos, que utilizan nuestros equipos de soporte e instalación. La herramienta averigua la línea de base actual de la base de datos de destino y le pregunta al usuario si desea actualizar a la línea de base en el paquete. Si lo hacen, y existe una ruta de actualización válida desde la versión actual, aplica la secuencia de comandos de actualización y actualiza schema_version.baseline y elimina todas las entradas para las secuencias de comandos de cambio de la línea de base previa. Si la base de datos es nueva, aplica el script de línea base regular. De cualquier manera, una vez que se alcanza la línea base, aplica todos los scripts de cambio desde la línea de base que están presentes en el paquete, uno a la vez, en orden, en una transacción. Si un script de cambio en particular falla, revierte el último conjunto de cambios y errores. Miramos el registro, solucionamos cualquier problema y luego volvemos a ejecutar el paquete. En ese punto, debería retomar el último script de cambio que tuvo éxito, ahorrando tiempo.

Automatización y herramientas Diff

No permitimos que las herramientas de diferencias actualicen las bases de datos de producción directamente. Es demasiado arriesgado. Usamos herramientas de diff, por supuesto, para ayudar a crear nuestra actualización y cambiar guiones, pero una vez que los tenemos, los revisamos, les damos masajes, los probamos, etc., y luego creamos la actualización o cambiamos la secuencia de comandos de acuerdo con las especificaciones anteriores. . Usamos herramientas / scripts de shell para crear los archivos de script de cambio y ponemos la placa de calderas en la verificación de schema_version .

Advertencias

En realidad es bastante directo y funciona bien. El único momento en que se vuelve complicado es con ramas. En su mayor parte, las sucursales se manejan bien. Si necesitamos un script de cambio para el trabajo de una rama en particular, se incorporará muy bien a la línea principal una vez que fusionemos la rama nuevamente. No hay problema. Donde se pone complicado es cuando dos ramas intentan hacer cosas similares, o donde una rama depende de otra. Sin embargo, eso es principalmente un problema de planificación y proceso. Si nos atascamos en una situación así, simplemente creamos una nueva línea base (digamos v2.1 ), luego actualizamos las ramas en consecuencia.

Otra cosa a tener en cuenta es que si una instalación desea actualizarse de una línea base a otra, debe aplicar todos los cambios pendientes para la línea base actual, antes de que actualicemos a la nueva. En otras palabras, no permitimos que las instalaciones salgan desde donde están a la siguiente línea de base (a menos que, por supuesto, ya estén en la versión más reciente para la línea base actual).

Nuestro sistema de control de fuente Sql Historian puede ayudar a la gente con este problema, especialmente en la situación que mencionas donde los compañeros de equipo "olvidan" registrar el código después de que hayan actualizado el servidor.

Se encuentra en segundo plano y registra todos los cambios realizados en sus objetos db en control de fuente, sin que los usuarios necesiten controlar nada. Piense en ello como un grabador de blackbox de avión, manteniéndose fuera del camino hasta que lo necesite.