Versionado de la base de datos de SQL Server

StackOverflow https://stackoverflow.com/questions/173

Pregunta

Quiero que mis bases de datos estén bajo control de versiones.¿Alguien tiene algún consejo o artículo recomendado para empezar?

Siempre querré tener al menos alguno datos allí (como alumbre menciona:tipos de usuarios y administradores).A menudo también quiero una gran colección de datos de prueba generados para mediciones de rendimiento.

¿Fue útil?

Solución

Martin Fowler escribió mi artículo favorito sobre el tema, http://martinfowler.com/articles/evodb.html.Elijo no poner los volcados de esquema bajo control de versiones como alumbre y otros sugieren porque quiero una manera fácil de actualizar mi base de datos de producción.

Para una aplicación web donde tendré una única instancia de base de datos de producción, utilizo dos técnicas:

Scripts de actualización de bases de datos

Una secuencia de scripts de actualización de la base de datos que contiene el DDL necesario para mover el esquema de la versión N a N+1.(Estos van en su sistema de control de versiones). Una tabla _version_history_, algo así como

create table VersionHistory (
    Version int primary key,
    UpgradeStart datetime not null,
    UpgradeEnd datetime
    );

obtiene una nueva entrada cada vez que se ejecuta un script de actualización que corresponde a la nueva versión.

Esto garantiza que sea fácil ver qué versión del esquema de la base de datos existe y que los scripts de actualización de la base de datos se ejecuten solo una vez.De nuevo, estos son no volcados de bases de datos.Más bien, cada guión representa el cambios necesario pasar de una versión a la siguiente.Son el script que aplica a su base de datos de producción para "actualizarla".

Sincronización de zona de pruebas para desarrolladores

  1. Un script para realizar copias de seguridad, desinfectar y reducir una base de datos de producción.Ejecute esto después de cada actualización a la base de datos de producción.
  2. Un script para restaurar (y modificar, si es necesario) la copia de seguridad en la estación de trabajo de un desarrollador.Cada desarrollador ejecuta este script después de cada actualización de la base de datos de producción.

Una advertencia:Mis pruebas automatizadas se ejecutan en una base de datos vacía pero con un esquema correcto, por lo que este consejo no se adaptará perfectamente a sus necesidades.

Otros consejos

El producto SQL Compare de Red Gate no solo le permite hacer comparaciones a nivel de objetos y generar secuencias de comandos de cambio a partir de eso, sino que también le permite exportar los objetos de su base de datos a una jerarquía de carpetas organizada por tipo de objeto, con una creación de [nombre de objeto].sql script por objeto en estos directorios.La jerarquía de tipos de objetos es así:

\Funciones
\Seguridad
\Seguridad oles
\Seguridad\Esquemas
\Seguridad\Usuarios
\Procedimientos almacenados
\Mesas

Si vuelca sus scripts en el mismo directorio raíz después de realizar cambios, puede usarlo para actualizar su repositorio SVN y mantener un historial de ejecución de cada objeto individualmente.

Éste es uno de los "problemas difíciles" que rodean al desarrollo.Hasta donde yo sé, no existen soluciones perfectas.

Si solo necesita almacenar la estructura de la base de datos y no los datos, puede exportar la base de datos como consultas SQL.(en Administrador empresarial:Haga clic derecho en la base de datos -> Generar script SQL.Recomiendo configurar "crear un archivo por objeto" en la pestaña de opciones). Luego puede enviar estos archivos de texto a svn y utilizar las funciones de registro y diferenciación de svn.

Tengo esto vinculado con un script por lotes que toma un par de parámetros y configura la base de datos.También agregué algunas consultas adicionales que ingresan datos predeterminados como tipos de usuario y el usuario administrador.(Si desea obtener más información sobre esto, publique algo y puedo colocar el script en algún lugar accesible)

Si también necesita conservar todos los datos, le recomiendo mantener una copia de seguridad de la base de datos y utilizar Redgate (http://www.red-gate.com/) productos para hacer las comparaciones.No son baratos, pero valen cada centavo.

Primero, debes elegir el sistema de control de versiones adecuado para ti:

  • Sistema de control de versiones centralizado: un sistema estándar donde los usuarios verifican/registran antes/después de trabajar en archivos, y los archivos se guardan en un único servidor central.

  • Sistema de control de versiones distribuidas: un sistema en el que se está clonando el repositorio, y cada clon es en realidad la copia de seguridad completa del repositorio, por lo que si algún servidor se bloquea, entonces cualquier repositorio clonado se puede usar para restaurarlo después de elegir el sistema correcto para sus necesidades , deberá configurar el repositorio, que es el núcleo de cada sistema de control de versiones, todo esto se explica en el siguiente artículo: http://solutioncenter.apexsql.com/sql-server-source-control-part-i-understanding-source-control-basics/

Después de configurar un repositorio y, en el caso de un sistema de control de versiones central, una carpeta de trabajo, puede leer Este artículo.Muestra cómo configurar el control de fuente en un entorno de desarrollo usando:

  • SQL Server Management Studio a través del proveedor MSSCCI,

  • Herramientas de datos de Visual Studio y SQL Server

  • Una herramienta de terceros ApexSQL Source Control

Aquí en Red Gate ofrecemos una herramienta, Control de fuente SQL, que utiliza la tecnología SQL Compare para vincular su base de datos con un repositorio TFS o SVN.Esta herramienta se integra en SSMS y le permite trabajar como lo haría normalmente, excepto que ahora le permite confirmar los objetos.

Para un enfoque basado en migraciones (más adecuado para implementaciones automatizadas), ofrecemos Automatización de cambios SQL (anteriormente llamado ReadyRoll), que crea y administra un conjunto de scripts incrementales como un proyecto de Visual Studio.

En SQL Source Control es posible especificar tablas de datos estáticas.Estos se almacenan en el control de código fuente como declaraciones INSERT.

Si está hablando de datos de prueba, le recomendamos que genere datos de prueba con una herramienta o mediante un script posterior a la implementación que usted defina, o simplemente restaure una copia de seguridad de producción en el entorno de desarrollo.

Quizás quieras mirar Liquibase (http://www.liquibase.org/).Incluso si no utiliza la herramienta en sí, maneja bastante bien los conceptos de gestión de cambios o refactorización de bases de datos.

+1 para todos los que recomendaron las herramientas RedGate, con una recomendación adicional y una advertencia.

SqlCompare también tiene una API bastante documentada:por lo que puede, por ejemplo, escribir una aplicación de consola que sincronice su carpeta de secuencias de comandos controladas por fuente con una base de datos de prueba de integración de CI al registrarse, de modo que cuando alguien registre un cambio en el esquema desde su carpeta de secuencias de comandos, se implemente automáticamente junto con la aplicación coincidente. cambio de código.Esto ayuda a cerrar la brecha con los desarrolladores que se olvidan de propagar cambios en su base de datos local hasta una base de datos de desarrollo compartida (creo que aproximadamente la mitad de nosotros :)).

Una advertencia es que con una solución basada en script o no, las herramientas RedGate son lo suficientemente fluidas como para que sea fácil olvidarse de las realidades SQL subyacentes a la abstracción.Si cambia el nombre de todas las columnas de una tabla, SqlCompare no tiene forma de asignar las columnas antiguas a las nuevas y eliminará todos los datos de la tabla.Generará advertencias, pero he visto a personas hacer clic más allá de eso.Creo que aquí hay un punto general que vale la pena señalar: que hasta ahora solo se puede automatizar el control de versiones y la actualización de la base de datos: las abstracciones tienen muchas fugas.

Usamos DBfantasma para gestionar nuestra base de datos SQL.Luego, coloca sus scripts para crear una nueva base de datos en su control de versiones, y creará una nueva base de datos o actualizará cualquier base de datos existente al esquema en el control de versiones.De esa manera, no tendrá que preocuparse por crear secuencias de comandos de cambio (aunque aún puede hacerlo, si, por ejemplo, desea cambiar el tipo de datos de una columna y necesita convertir datos).

Con VS 2010, utilice el proyecto de base de datos.

  1. Crea un script en tu base de datos
  2. Realizar cambios en los scripts o directamente en su servidor DB
  3. Sincronizar usando datos> comparar esquema

Es una solución perfecta para el control de versiones de bases de datos y facilita la sincronización de bases de datos.

Es un buen método guardar scripts de bases de datos en el control de versiones con scripts de cambio para que pueda actualizar cualquier base de datos que tenga.También es posible que desee guardar esquemas para diferentes versiones para poder crear una base de datos completa sin tener que aplicar todos los scripts de cambio.El manejo de los scripts debe automatizarse para que no tenga que realizar trabajo manual.

Creo que es importante tener una base de datos separada para cada desarrollador y no utilizar una base de datos compartida.De esa forma, los desarrolladores pueden crear casos de prueba y fases de desarrollo independientemente de otros desarrolladores.

La herramienta de automatización debe tener medios para manejar los metadatos de la base de datos, lo que indica qué bases de datos se encuentran en qué estado de desarrollo y qué tablas contienen datos controlables por versión, etc.

También podría buscar una solución de migraciones.Estos le permiten especificar el esquema de su base de datos en código C# y subir y bajar la versión de su base de datos usando MSBuild.

actualmente estoy usando DbUp, y ha estado funcionando bien.

No mencionaste ningún detalle específico sobre el entorno de destino o las limitaciones, por lo que es posible que esto no sea del todo aplicable...pero si está buscando una forma de realizar un seguimiento eficaz de un esquema de base de datos en evolución y no se opone a la idea de utilizar Ruby, las migraciones de ActiveRecord son lo que necesita.

Las migraciones definen programáticamente las transformaciones de la base de datos utilizando Ruby DSL;cada transformación se puede aplicar o (generalmente) revertir, lo que le permite saltar a una versión diferente de su esquema de base de datos en cualquier momento dado.El archivo que define estas transformaciones se puede registrar en el control de versiones como cualquier otro fragmento de código fuente.

Porque las migraciones son parte de Registro activo, normalmente encuentran uso en aplicaciones Rails de pila completa;sin embargo, puedes usar ActiveRecord independientemente de Rails con un mínimo esfuerzo.Ver aquí para un tratamiento más detallado del uso de migraciones de AR fuera de Rails.

Cada base de datos debe estar bajo control del código fuente.Lo que falta es una herramienta para programar automáticamente todos los objetos de la base de datos (y los "datos de configuración") en un archivo, que luego se puede agregar a cualquier sistema de control de fuente.Si está utilizando SQL Server, entonces mi solución está aquí: http://dbsourcetools.codeplex.com/ .Divertirse.- Natán.

Es sencillo.

  1. Cuando el proyecto base esté listo, deberá crear un script de base de datos completo.Este script está comprometido con SVN.Es la primera versión.

  2. Después de eso, todos los desarrolladores crean scripts de cambios (ALTER..., nuevas tablas, sprocs, etc.).

  3. Cuando necesite la versión actual, debe ejecutar todos los scripts de cambios nuevos.

  4. Cuando la aplicación se lanza a producción, vuelve a 1 (pero, por supuesto, será una versión sucesiva).

Nant le ayudará a ejecutar esos scripts de cambio.:)

Y recuerda.Todo funciona bien cuando hay disciplina.Cada vez que se confirma un cambio en la base de datos, también se confirman las funciones correspondientes en el código.

Si tiene una base de datos pequeña y desea versionarla por completo, este script por lotes podría ayudar.Separa, comprime y verifica un archivo MDF de base de datos MSSQL en Subversion.

Si principalmente desea versionar su esquema y solo tiene una pequeña cantidad de datos de referencia, posiblemente pueda usar Migraciones subsónicas para manejar eso.El beneficio es que puedes migrar fácilmente hacia arriba o hacia abajo a cualquier versión específica.

Para hacer que el volcado a un sistema de control de código fuente sea un poco más rápido, puede ver qué objetos han cambiado desde la última vez utilizando la información de versión en sysobjects.

Configuración: Cree una tabla en cada base de datos que desee verificar de forma incremental para contener la información de la versión de la última vez que la verificó (vacía en la primera ejecución).Borre esta tabla si desea volver a escanear toda su estructura de datos.

IF ISNULL(OBJECT_ID('last_run_sysversions'), 0) <> 0 DROP TABLE last_run_sysversions
CREATE TABLE last_run_sysversions (
    name varchar(128), 
    id int, base_schema_ver int,
    schema_ver int,
    type char(2)
)

Modo de funcionamiento normal: Puede tomar los resultados de este SQL y generar scripts SQL solo para aquellos que le interesen y colocarlos en un control de fuente de su elección.

IF ISNULL(OBJECT_ID('tempdb.dbo.#tmp'), 0) <> 0 DROP TABLE #tmp
CREATE TABLE #tmp (
    name varchar(128), 
    id int, base_schema_ver int,
    schema_ver int,
    type char(2)
)

SET NOCOUNT ON

-- Insert the values from the end of the last run into #tmp
INSERT #tmp (name, id, base_schema_ver, schema_ver, type) 
SELECT name, id, base_schema_ver, schema_ver, type FROM last_run_sysversions

DELETE last_run_sysversions
INSERT last_run_sysversions (name, id, base_schema_ver, schema_ver, type)
SELECT name, id, base_schema_ver, schema_ver, type FROM sysobjects

-- This next bit lists all differences to scripts.
SET NOCOUNT OFF

--Renamed.
SELECT 'renamed' AS ChangeType, t.name, o.name AS extra_info, 1 AS Priority
FROM sysobjects o INNER JOIN #tmp t ON o.id = t.id
WHERE o.name <> t.name /*COLLATE*/
AND o.type IN ('TR', 'P' ,'U' ,'V')
UNION 

--Changed (using alter)
SELECT 'changed' AS ChangeType, o.name /*COLLATE*/, 
       'altered' AS extra_info, 2 AS Priority
FROM sysobjects o INNER JOIN #tmp t ON o.id = t.id 
WHERE (
   o.base_schema_ver <> t.base_schema_ver
OR o.schema_ver      <> t.schema_ver
)
AND  o.type IN ('TR', 'P' ,'U' ,'V')
AND  o.name NOT IN ( SELECT oi.name 
         FROM sysobjects oi INNER JOIN #tmp ti ON oi.id = ti.id
         WHERE oi.name <> ti.name /*COLLATE*/
         AND oi.type IN ('TR', 'P' ,'U' ,'V')) 
UNION

--Changed (actually dropped and recreated [but not renamed])
SELECT 'changed' AS ChangeType, t.name, 'dropped' AS extra_info, 2 AS Priority
FROM #tmp t
WHERE    t.name IN ( SELECT ti.name /*COLLATE*/ FROM #tmp ti
         WHERE NOT EXISTS (SELECT * FROM sysobjects oi
                           WHERE oi.id = ti.id))
AND  t.name IN ( SELECT oi.name /*COLLATE*/ FROM sysobjects oi
         WHERE NOT EXISTS (SELECT * FROM #tmp ti
                           WHERE oi.id = ti.id)
         AND   oi.type  IN ('TR', 'P' ,'U' ,'V'))
UNION

--Deleted
SELECT 'deleted' AS ChangeType, t.name, '' AS extra_info, 0 AS Priority
FROM #tmp t
WHERE NOT EXISTS (SELECT * FROM sysobjects o
                  WHERE o.id = t.id)
AND t.name NOT IN (  SELECT oi.name /*COLLATE*/ FROM sysobjects oi
         WHERE NOT EXISTS (SELECT * FROM #tmp ti
                           WHERE oi.id = ti.id)
         AND   oi.type  IN ('TR', 'P' ,'U' ,'V'))
UNION

--Added
SELECT 'added' AS ChangeType, o.name /*COLLATE*/, '' AS extra_info, 4 AS Priority
FROM sysobjects o
WHERE NOT EXISTS (SELECT * FROM #tmp t
                  WHERE o.id = t.id)
AND      o.type  IN ('TR', 'P' ,'U' ,'V')
AND  o.name NOT IN ( SELECT ti.name /*COLLATE*/ FROM #tmp ti
         WHERE NOT EXISTS (SELECT * FROM sysobjects oi
                           WHERE oi.id = ti.id))
ORDER BY Priority ASC

Nota: Si utiliza una intercalación no estándar en cualquiera de sus bases de datos, deberá reemplazar /* COLLATE */ con la recopilación de su base de datos.es decir. COLLATE Latin1_General_CI_AI

Debido a que nuestra aplicación tiene que funcionar en múltiples RDBMS, almacenamos nuestra definición de esquema en el control de versiones utilizando la base de datos neutral. Esfuerzo de torsión formato (XML).También controlamos la versión de los datos de referencia de nuestra base de datos en formato XML de la siguiente manera (donde "Relación" es una de las tablas de referencia):

  <Relationship RelationshipID="1" InternalName="Manager"/>
  <Relationship RelationshipID="2" InternalName="Delegate"/>
  etc.

Luego utilizamos herramientas propias para generar la actualización del esquema y los scripts de actualización de datos de referencia necesarios para pasar de la versión X de la base de datos a la versión X + 1.

No almacenamos el esquema de la base de datos, almacenamos los cambios en la base de datos.Lo que hacemos es almacenar los cambios de esquema para crear un script de cambio para cualquier versión de la base de datos y aplicarlo a las bases de datos de nuestros clientes.Escribí una aplicación de utilidad de base de datos que se distribuye con nuestra aplicación principal y que puede leer ese script y saber qué actualizaciones deben aplicarse.También tiene suficiente inteligencia para actualizar vistas y procedimientos almacenados según sea necesario.

Tuvimos la necesidad de versionar nuestra base de datos SQL después de migrar a una plataforma x64 y nuestra versión anterior se rompió con la migración.Escribimos una aplicación C# que usó SQLDMO para asignar todos los objetos SQL a una carpeta:

                Root
                    ServerName
                       DatabaseName
                          Schema Objects
                             Database Triggers*
                                .ddltrigger.sql
                             Functions
                                ..function.sql
                             Security
                                Roles
                                   Application Roles
                                      .approle.sql
                                   Database Roles
                                      .role.sql
                                Schemas*
                                   .schema.sql
                                Users
                                   .user.sql
                             Storage
                                Full Text Catalogs*
                                   .fulltext.sql
                             Stored Procedures
                                ..proc.sql
                             Synonyms*
                                .synonym.sql
                             Tables
                                ..table.sql
                                Constraints
                                   ...chkconst.sql
                                   ...defconst.sql
                                Indexes
                                   ...index.sql
                                Keys
                                   ...fkey.sql
                                   ...pkey.sql
                                   ...ukey.sql
                                Triggers
                                   ...trigger.sql
                             Types
                                User-defined Data Types
                                   ..uddt.sql
                                XML Schema Collections*
                                   ..xmlschema.sql
                             Views
                                ..view.sql
                                Indexes
                                   ...index.sql
                                Triggers
                                   ...trigger.sql

Luego, la aplicación compararía la versión recién escrita con la versión almacenada en SVN y, si hubiera diferencias, actualizaría SVN.Determinamos que ejecutar el proceso una vez por noche era suficiente ya que no realizamos tantos cambios en SQL.Nos permite realizar un seguimiento de los cambios en todos los objetos que nos interesan y además nos permite reconstruir nuestro esquema completo en caso de un problema grave.

Escribí esta aplicación hace un tiempo, http://sqlschemasourcectrl.codeplex.com/ que escaneará su base de datos MSFT SQL con la frecuencia que desee y volcará automáticamente sus objetos (tablas, vistas, procesos, funciones, configuraciones de SQL) en SVN.Funciona de maravilla.Lo uso con Unfuddle (que me permite recibir alertas sobre los registros)

La solución típica es volcar la base de datos según sea necesario y hacer una copia de seguridad de esos archivos.

Dependiendo de su plataforma de desarrollo, es posible que haya complementos de código abierto disponibles.Desarrollar su propio código para hacerlo suele ser bastante trivial.

Nota:Es posible que desee realizar una copia de seguridad del volcado de la base de datos en lugar de ponerlo en control de versiones.Los archivos pueden volverse muy rápidos en el control de versiones y hacer que todo el sistema de control de fuente se vuelva lento (en este momento estoy recordando una historia de terror de CVS).

Acabamos de empezar a utilizar Team Foundation Server.Si su base de datos es de tamaño mediano, entonces Visual Studio tiene algunas buenas integraciones de proyectos con comparación integrada, comparación de datos, herramientas de refactorización de bases de datos, marco de prueba de bases de datos e incluso herramientas de generación de datos.

Pero ese modelo no se adapta muy bien a bases de datos muy grandes o de terceros (que cifran objetos).Entonces, lo que hemos hecho es almacenar sólo nuestros objetos personalizados.El servidor Visual Studio/Team Foundation funciona muy bien para eso.

Arq. jefe de la base de datos TFS.Blog

Sitio MS TFS

Estoy de acuerdo con la respuesta de ESV y por esa misma razón comencé un pequeño proyecto hace un tiempo para ayudar a mantener las actualizaciones de la base de datos en un archivo muy simple que luego podría mantenerse como un código fuente largo.Permite actualizaciones sencillas para desarrolladores, así como para UAT y producción.La herramienta funciona solo en Sql Server y MySql.

Algunas características del proyecto:

  • Permite cambios de esquema
  • Permite valorar la población de árboles.
  • Permite inserciones de datos de prueba independientes, por ejemplo.UAT
  • Permite la opción de reversión (no automatizada)
  • Mantiene soporte para SQL server y Mysql.
  • Tiene la capacidad de importar su base de datos existente al control de versiones con un simple comando (solo servidor SQL...todavía trabajando en mysql)

El código está alojado en el código de Google.Consulte el código de Google para obtener más información.

http://code.google.com/p/databaseversioncontrol/

Hace un tiempo encontré un módulo VB bas que usaba objetos DMO y VSS para programar una base de datos completa en VSS.Lo convertí en un VB Script y lo publiqué. aquí.¿Podría eliminar fácilmente las llamadas VSS y usar el material DMO para generar todos los scripts y luego llamar a SVN desde el mismo archivo por lotes que llama a VBScript para registrarlos?

David J.

También estoy usando una versión en la base de datos almacenada a través de la familia de procedimientos de propiedades extendidas de la base de datos.Mi aplicación tiene scripts para cada paso de la versión (es decir.pasar de 1.1 a 1.2).Cuando se implementa, mira la versión actual y luego ejecuta los scripts uno por uno hasta llegar a la última versión de la aplicación.No existe ningún script que tenga la versión "final" directa, incluso la implementación en una base de datos limpia se realiza a través de una serie de pasos de actualización.

Ahora, lo que me gustaría agregar es que hace dos días vi una presentación en el campus de MS sobre la nueva y próxima edición de VS DB.La presentación se centró específicamente en este tema y quedé impresionado.Definitivamente deberías comprobarlo, las nuevas funciones se centran en mantener la definición del esquema en scripts T-SQL (CREATES), un motor delta en tiempo de ejecución para comparar el esquema de implementación con el esquema definido y realizar los ALTER delta y la integración con la integración del código fuente, hasta e incluye integración continua de MSBUILD para lanzamientos de compilación automatizados.La entrega contendrá un nuevo tipo de archivo, los archivos .dbschema, que se pueden llevar al sitio de implementación y una herramienta de línea de comandos puede realizar los 'deltas' reales y ejecutar la implementación.Tengo una entrada de blog sobre este tema con enlaces a las descargas de VSDE, deberías consultarlos: http://rusanu.com/2009/05/15/version-control-and-your-database/

Es una pregunta muy antigua, sin embargo muchos están tratando de resolverla incluso ahora.Todo lo que tienen que hacer es investigar sobre los proyectos de bases de datos de Visual Studio.Sin esto, cualquier desarrollo de bases de datos parece muy débil.Desde la organización del código hasta la implementación y el control de versiones, lo simplifica todo.

En mi experiencia la solución es doble:

  1. Debe manejar los cambios en la base de datos de desarrollo que realizan varios desarrolladores durante el desarrollo.

  2. Debe manejar las actualizaciones de la base de datos en los sitios de los clientes.

Para manejar el punto 1, necesitará una sólida herramienta de combinación/diferenciación de bases de datos.La mejor herramienta debería poder realizar la combinación automática tanto como sea posible y al mismo tiempo permitirle resolver manualmente los conflictos no controlados.

La herramienta perfecta debería manejar las operaciones de fusión mediante el uso de un algoritmo de fusión de 3 vías que tenga en cuenta los cambios que se realizaron en la base de datos YOURS y la base de datos MINE, en relación con la base de datos BASE.

Escribí una herramienta comercial que brinda soporte de combinación manual para bases de datos SQLite y actualmente estoy agregando soporte para el algoritmo de combinación de 3 vías para SQLite.Compruébalo en http://www.sqlitecompare.com

Para manejar el punto 2, necesitará un marco de actualización implementado.

La idea básica es desarrollar un marco de actualización automática que sepa cómo actualizar desde un esquema SQL existente al esquema SQL más nuevo y pueda crear una ruta de actualización para cada instalación de base de datos existente.

Mira mi artículo sobre el tema en http://www.codeproject.com/KB/database/sqlite_upgrade.aspx para tener una idea general de lo que estoy hablando.

Buena suerte

Liron Levi

Echa un vistazo a DBGhost http://www.innovartis.co.uk/.Lo he usado de forma automatizada durante 2 años y funciona muy bien.Permite que nuestras compilaciones de base de datos se realicen de manera muy similar a como sucede con una compilación de Java o C, excepto por la base de datos.Usted sabe lo que quiero decir.

Sugeriría utilizar herramientas de comparación para improvisar un sistema de control de versiones para su base de datos.Una buena alternativa son Comparación de esquemas xSQL y Comparación de datos xSQL.

Ahora, si su objetivo es tener solo el esquema de la base de datos bajo control de versiones, simplemente puede usar xSQL Schema Compare para generar instantáneas xSQL del esquema y agregar estos archivos en su control de versiones.Luego, para revertir o actualizar a una versión específica, simplemente compare la versión actual de la base de datos con la instantánea de la versión de destino.

Lamentablemente, si también desea tener los datos bajo control de versiones, puede usar xSQL Data Compare para generar scripts de cambio para su base de datos y agregar los archivos .sql en su control de versiones.Luego puede ejecutar estos scripts para revertir/actualizar a cualquier versión que desee.Tenga en cuenta que para la funcionalidad 'revertir' necesita generar secuencias de comandos de cambio que, cuando se ejecuten, harán que la Versión 3 sea igual a la Versión 2 y para la funcionalidad 'actualizar', debe generar secuencias de comandos de cambio que hagan lo contrario.

Por último, con algunas habilidades básicas de programación por lotes, puede automatizar todo el proceso utilizando las versiones de línea de comandos de xSQL Schema Compare y xSQL Data Compare.

Descargo de responsabilidad:Estoy afiliado a xSQL.

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top