Quero colocar meus bancos de dados sob controle de versão. Alguém tem algum conselho ou artigos recomendados para começar?

Eu sempre quero ter pelo menos alguns dados lá (como menciona alumb : tipos de usuários e administradores). Também desejarei muitas vezes uma grande coleção de dados de teste gerados para medições de desempenho.

Martin Fowler escreveu meu artigo favorito sobre o assunto, http://martinfowler.com/articles/evodb.html . Eu escolho não colocar despejos de esquema no controle de versão, como sugerido por outros, porque eu quero uma maneira fácil de atualizar meu banco de dados de produção.

Para um aplicativo Web em que terei uma única instância de banco de dados de produção, utilizo duas técnicas:

Scripts de atualização do banco de dados

Scripts de atualização de banco de dados de sequência que contêm o DDL necessário para mover o esquema da versão N para N + 1. (Eles estão no seu sistema de controle de versão.) Uma tabela _version_history_, algo como

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

recebe uma nova entrada sempre que um script de atualização é executado, o que corresponde à nova versão.

Isso garante que seja fácil ver qual versão do esquema do banco de dados existe e que os scripts de atualização do banco de dados sejam executados apenas uma vez. Novamente, esses não são despejos de banco de dados. Em vez disso, cada script representa as alterações necessárias para passar de uma versão para a seguinte. Eles são o script que você aplica ao seu banco de dados de produção para "atualizá-lo".

Sincronização de sandbox do desenvolvedor

1. Um script para fazer backup, higienizar e reduzir um banco de dados de produção. Execute isso após cada atualização no banco de dados de produção.
2. Um script para restaurar (e ajustar, se necessário) o backup na estação de trabalho de um desenvolvedor. Cada desenvolvedor executa esse script após cada atualização no banco de dados de produção.

Uma ressalva: meus testes automatizados são executados em um banco de dados vazio, mas com correção de esquema, portanto, este conselho não atenderá perfeitamente às suas necessidades.

O produto SQL Compare do Red Gate não apenas permite fazer comparações no nível de objeto e gerar scripts de alteração a partir disso, mas também permite exportar seus objetos de banco de dados para uma hierarquia de pastas organizada por tipo de objeto, com uma criação [nome do objeto] .sql script por objeto nesses diretórios. A hierarquia do tipo de objeto é assim:

\ Funções
\ Segurança
\ Segurança \ Funções
\ Segurança \ Esquemas
\ Segurança \ Usuários
\ Procedimentos Armazenados
\ Tabelas

Se você despejar seus scripts no mesmo diretório raiz após fazer alterações, poderá usá-lo para atualizar seu repositório SVN e manter um histórico de execução de cada objeto individualmente.

Esse é um dos "problemas difíceis" que envolvem o desenvolvimento. Tanto quanto sei, não há soluções perfeitas.

Se você precisar armazenar apenas a estrutura do banco de dados e não os dados, poderá exportá-lo como consultas SQL. (no Enterprise Manager: Clique com o botão direito no banco de dados -> Gerar script SQL. Eu recomendo definir "criar um arquivo por objeto" na guia Opções). Em seguida, você pode confirmar esses arquivos de texto no svn e usar as funções diff e log do svn.

Eu tenho isso vinculado a um script em lote que pega alguns parâmetros e configura o banco de dados. Também adicionei algumas consultas adicionais que inserem dados padrão, como tipos de usuário e usuário administrador. (Se você quiser mais informações sobre isso, poste algo e eu posso colocar o script em algum lugar acessível)

Se você precisar manter todos os dados também, recomendo manter um backup do banco de dados e usar os produtos Redgate ( http://www.red-gate.com/ ) para fazer as comparações. Eles não são baratos, mas valem cada centavo.

Primeiro, você deve escolher o sistema de controle de versão ideal para você:

• Sistema de controle de versão centralizado - um sistema padrão no qual os usuários fazem check-in / check-in antes / depois de trabalharem em arquivos e os arquivos estão sendo mantidos em um único servidor central

• Sistema de controle de versão distribuído - um sistema em que o repositório está sendo clonado e cada clone é realmente o backup completo do repositório; portanto, se algum servidor travar, qualquer repositório clonado poderá ser usado para restaurá-lo. Depois de escolher o sistema certo para suas necessidades , será necessário configurar o repositório que é o núcleo de todo sistema de controle de versão Tudo isso é explicado no seguinte artigo: http://solutioncenter.apexsql.com/sql-server-source-control-part-i-understanding -source-control-basics /

Depois de configurar um repositório e, no caso de um sistema central de controle de versão, uma pasta de trabalho, você pode ler este artigo . Ele mostra como configurar o controle de origem em um ambiente de desenvolvimento usando:

• SQL Server Management Studio por meio do provedor MSSCCI,

• Ferramentas de dados do Visual Studio e SQL Server

• Uma ferramenta de terceiros ApexSQL Source Control

Aqui no Red Gate, oferecemos uma ferramenta, o SQL Source Control , que usa a tecnologia SQL Compare para vincular seu banco de dados a um repositório TFS ou SVN. Essa ferramenta se integra ao SSMS e permite que você trabalhe como faria normalmente, exceto que agora permite confirmar os objetos.

Para uma abordagem baseada em migrações (mais adequada para implantações automatizadas), oferecemos o SQL Change Automation (anteriormente chamado ReadyRoll), que cria e gerencia um conjunto de scripts incrementais como um projeto do Visual Studio.

No SQL Source Control, é possível especificar tabelas de dados estáticas. Eles são armazenados no controle de origem como instruções INSERT.

Se você estiver falando sobre dados de teste, recomendamos que você gere dados de teste com uma ferramenta ou através de um script de pós-implantação que você defina ou simplesmente restaure um backup de produção no ambiente de desenvolvimento.

Você pode querer consultar Liquibase ( http://www.liquibase.org/ ). Mesmo que você não use a ferramenta, ela lida com os conceitos de gerenciamento de alterações ou refatoração de banco de dados.

+1 para todos os que recomendaram as ferramentas RedGate, com uma recomendação adicional e uma ressalva.

O SqlCompare também possui uma API decentemente documentada: para que você possa, por exemplo, escrever um aplicativo de console que sincronize sua pasta de scripts controlados de origem com um banco de dados de teste de integração de IC no check-in, para que, quando alguém faça check-in de uma alteração no esquema da pasta de scripts é implantado automaticamente junto com a alteração do código do aplicativo correspondente. Isso ajuda a fechar a lacuna com os desenvolvedores que esquecem a propagação de alterações no banco de dados local até um banco de dados de desenvolvimento compartilhado (cerca de metade de nós, acho :)).

Uma ressalva é que, com uma solução com script ou de outra forma, as ferramentas RedGate são suficientemente suaves para facilitar o esquecimento das realidades SQL subjacentes à abstração. Se você renomear todas as colunas em uma tabela, o SqlCompare não poderá mapear as colunas antigas para as novas e soltará todos os dados da tabela. Isso irá gerar avisos, mas já vi pessoas clicarem além disso. Acho que vale a pena ressaltar que você só pode automatizar o versionamento e a atualização do DB até agora - as abstrações são muito vazadas.

Usamos o DBGhost para gerenciar nosso banco de dados SQL. Em seguida, você coloca seus scripts para criar um novo banco de dados em seu controle de versão, e ele cria um novo banco de dados ou atualiza qualquer banco de dados existente para o esquema no controle de versão. Dessa forma, você não precisa se preocupar em criar scripts de alteração (embora você ainda possa fazer isso, se, por exemplo, quiser alterar o tipo de dados de uma coluna e precisar converter dados).

Com o VS 2010, use o projeto Banco de Dados.

1. Script seu banco de dados
2. Faça alterações nos scripts ou diretamente no servidor db
3. Sincronize usando Dados> Comparação de esquemas

Cria uma solução perfeita de versionamento de banco de dados e facilita a sincronização de bancos de dados.

É uma boa abordagem salvar os scripts do banco de dados no controle de versão com os scripts de alteração, para que você possa atualizar qualquer banco de dados existente. Além disso, convém salvar esquemas para diferentes versões para criar um banco de dados completo sem a necessidade de aplicar todos os scripts de alteração. O tratamento dos scripts deve ser automatizado para que você não precise fazer trabalho manual.

Eu acho que é importante ter um banco de dados separado para todos os desenvolvedores e não usar um banco de dados compartilhado. Dessa forma, os desenvolvedores podem criar casos de teste e fases de desenvolvimento independentemente de outros desenvolvedores.

A ferramenta de automação deve ter meios para lidar com os metadados do banco de dados, que informa quais bancos de dados estão em que estado de desenvolvimento e quais tabelas contêm dados controláveis ​​por versão e assim por diante.

Você também pode procurar uma solução de migração. Isso permite que você especifique o esquema do banco de dados no código C # e role a versão do banco de dados para cima e para baixo usando o MSBuild.

Atualmente, estou usando o DbUp e está funcionando bem.

Você não mencionou detalhes específicos sobre seu ambiente ou restrições de destino, portanto, isso pode não ser totalmente aplicável ... mas se você estiver procurando uma maneira de rastrear efetivamente um esquema de banco de dados em evolução e não for adverso à ideia de usar Ruby, as migrações do ActiveRecord estão no seu caminho.

As migrações definem programaticamente transformações de banco de dados usando uma DSL Ruby; cada transformação pode ser aplicada ou (geralmente) revertida, permitindo que você pule para uma versão diferente do seu esquema de banco de dados a qualquer momento. O arquivo que define essas transformações pode ser verificado no controle de versão como qualquer outra parte do código-fonte.

Como as migrações fazem parte do ActiveRecord , elas geralmente são usadas em aplicativos Rails de pilha completa; no entanto, você pode usar o ActiveRecord independente do Rails com o mínimo de esforço. Veja aqui um tratamento mais detalhado do uso das migrações de AR fora do Rails.

Todo banco de dados deve estar sob controle de código-fonte. O que falta é uma ferramenta para script automaticamente todos os objetos de banco de dados - e "dados de configuração" - em arquivo, que podem ser adicionados a qualquer sistema de controle de origem. Se você estiver usando o SQL Server, minha solução está aqui: http://dbsourcetools.codeplex.com/ . Diverta-se. Nathan.

É simples.

1. Quando o projeto base estiver pronto, você deverá criar um script completo do banco de dados. Este script foi confirmado no SVN. É a primeira versão.

2. Depois disso, todos os desenvolvedores criam scripts de alteração (ALTER ..., novas tabelas, sprocs, etc).

3. Quando você precisar da versão atual, execute todos os novos scripts de alteração.

4. Quando o aplicativo é lançado para produção, você volta para 1 (mas será a versão sucessiva, é claro).

Nant ajudará você a executar esses scripts de alteração. :)

E lembre-se. Tudo funciona bem quando há disciplina. Sempre que a alteração do banco de dados é confirmada, as funções correspondentes no código também são confirmadas.

Se você possui um banco de dados pequeno e deseja fazer a versão completa, esse script em lote pode ajudar. Ele desanexa, compacta e verifica um arquivo MDF do banco de dados MSSQL no Subversion.

Se você deseja versão do seu esquema e apenas possui uma pequena quantidade de dados de referência, é possível usar as Migrações SubSonic para lidar com isso. O benefício é que você pode migrar facilmente para cima ou para baixo para qualquer versão específica.

Para tornar o despejo em um sistema de controle de código-fonte um pouco mais rápido, você pode ver quais objetos foram alterados desde a última vez usando as informações da versão em sysobjects.

Configuração: crie uma tabela em cada banco de dados que você deseja verificar incrementalmente para reter as informações da versão da última vez que você as verificou (vazia na primeira execução). Limpe esta tabela se desejar verificar novamente toda a estrutura de dados.

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 execução normal: você pode pegar os resultados desse sql e gerar scripts sql apenas para os interessados, e colocá-los no controle de origem de sua escolha.

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: Se você usar um agrupamento não padrão em qualquer um dos seus bancos de dados, será necessário substituí-lo /* COLLATE */pelo agrupamento do banco de dados. ieCOLLATE Latin1_General_CI_AI

Como nosso aplicativo precisa trabalhar com vários RDBMSs, armazenamos nossa definição de esquema no controle de versão usando o formato de torque neutro em banco de dados (XML). Também controlamos a versão dos dados de referência para nosso banco de dados no formato XML da seguinte maneira (onde "Relacionamento" é uma das tabelas de referência):

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

Em seguida, usamos ferramentas domésticas para gerar os scripts de atualização de esquema e de referência de atualização de dados necessários para passar da versão X do banco de dados para a versão X + 1.

Não armazenamos o esquema do banco de dados, armazenamos as alterações no banco de dados. O que fazemos é armazenar as alterações no esquema para criar um script de mudança para qualquer versão do banco de dados e aplicá-lo aos bancos de dados de nossos clientes. Eu escrevi um aplicativo utilitário de banco de dados que é distribuído com o aplicativo principal que pode ler esse script e saber quais atualizações precisam ser aplicadas. Ele também possui inteligência suficiente para atualizar visualizações e procedimentos armazenados, conforme necessário.

Tivemos a necessidade de versão do nosso banco de dados SQL depois de migrar para uma plataforma x64 e nossa versão antiga foi interrompida com a migração. Escrevemos um aplicativo C # que usava o SQLDMO para mapear todos os objetos SQL para uma pasta:

                Raiz
                    Nome do servidor
                       Nome do banco de dados
                          Objetos de esquema
                             Acionadores de banco de dados *
                                .ddltrigger.sql
                             Funções
                                ..function.sql
                             Segurança
                                Funções
                                   Funções de aplicativo
                                      .approle.sql
                                   Funções de banco de dados
                                      .role.sql
                                Esquemas *
                                   .schema.sql
                                Comercial
                                   .user.sql
                             Armazenamento
                                Catálogos de texto completo *
                                   .fulltext.sql
                             Procedimentos armazenados
                                ..proc.sql
                             Sinônimos *
                                .synonym.sql
                             Tabelas
                                ..table.sql
                                Restrições
                                   ... chkconst.sql
                                   ... defconst.sql
                                Índices
                                   ... index.sql
                                Chaves
                                   ... fkey.sql
                                   ... pkey.sql
                                   ... ukey.sql
                                Gatilhos
                                   ... trigger.sql
                             Tipos
                                Tipos de dados definidos pelo usuário
                                   ..uddt.sql
                                Coleções de esquema XML *
                                   ..xmlschema.sql
                             Visualizações
                                ..view.sql
                                Índices
                                   ... index.sql
                                Gatilhos
                                   ... trigger.sql

O aplicativo compararia a versão recém-escrita à versão armazenada no SVN e, se houvesse diferenças, ele atualizaria o SVN. Determinamos que executar o processo uma vez por noite era suficiente, pois não fazemos muitas alterações no SQL. Ele nos permite rastrear alterações em todos os objetos com os quais nos preocupamos, além de reconstruir todo o nosso esquema no caso de um problema sério.

Eu escrevi este aplicativo há algum tempo, http://sqlschemasourcectrl.codeplex.com/ , que varrerá os seus bancos de dados MSFT SQL quantas vezes você quiser e despejará automaticamente seus objetos (tabelas, visualizações, procs, funções, configurações sql) no SVN. Funciona como um encanto. Eu o uso com o Unfuddle (o que me permite receber alertas sobre check-ins)

A solução típica é despejar o banco de dados conforme necessário e fazer backup desses arquivos.

Dependendo da sua plataforma de desenvolvimento, pode haver plugins de código aberto disponíveis. Rolar seu próprio código para fazer isso geralmente é bastante trivial.

Nota: convém fazer backup do dump do banco de dados em vez de colocá-lo no controle de versão. Os arquivos podem ficar enormes rapidamente no controle de versão e fazer com que todo o sistema de controle de fonte fique lento (estou relembrando uma história de horror do CVS no momento).

Começamos a usar o Team Foundation Server. Se o seu banco de dados é de tamanho médio, o Visual Studio possui algumas integrações interessantes de projeto com comparação interna, comparação de dados, ferramentas de refatoração de banco de dados, estrutura de teste de banco de dados e até ferramentas de geração de dados.

Mas esse modelo não se encaixa muito bem em bancos de dados grandes ou de terceiros (que criptografam objetos) muito bem. Então, o que fizemos é armazenar apenas nossos objetos personalizados. O servidor de base do Visual Studio / Team funciona muito bem para isso.

Arco principal do banco de dados TFS. blogue

Site MS TFS

Concordo com a resposta ESV e, por esse exato motivo, iniciei um pequeno projeto há algum tempo para ajudar a manter as atualizações do banco de dados em um arquivo muito simples, que poderia ser mantido com um código-fonte longo e afastado. Permite atualizações fáceis para desenvolvedores, bem como para UAT e produção. A ferramenta funciona, mas Sql Server e MySql.

Alguns recursos do projeto:

• Permite alterações de esquema
• Permite população de árvores de valor
• Permite inserções de dados de teste separadas, por exemplo. UAT
• Permite a opção de reversão (não automatizada)
• Mantém suporte para SQL server e Mysql
• Tem a capacidade de importar seu banco de dados existente para o controle de versão com um comando simples (apenas servidor sql ... ainda trabalhando no mysql)

O código está hospedado no código do google. Confira o código do Google para obter mais informações

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

Há um tempo atrás, encontrei um módulo básico do VB que usava objetos DMO e VSS para obter um banco de dados inteiro com script e entrar no VSS. Eu o transformei em um script VB e publiquei aqui . Você poderia facilmente fazer as chamadas VSS e usar o material DMO para gerar todos os scripts e, em seguida, chamar o SVN do mesmo arquivo em lotes que chama o VBScript para fazer check-in?

Dave J

Também estou usando uma versão no banco de dados armazenada pela família de procedimentos de propriedades estendidas do banco de dados. Meu aplicativo possui scripts para cada etapa da versão (ou seja, mova de 1.1 para 1.2). Quando implantado, ele analisa a versão atual e executa os scripts um por um até atingir a última versão do aplicativo. Não há script que tenha a versão "final" direta, mesmo que implemente em um banco de dados limpo a implante por meio de uma série de etapas de atualização.

Agora, o que eu gostaria de acrescentar é que eu vi dois dias atrás uma apresentação no campus da MS sobre a nova e futura edição do VS DB. A apresentação foi focada especificamente neste tópico e fiquei impressionado. Você deve definitivamente conferir, as novas instalações estão focadas em manter a definição do esquema nos scripts T-SQL (CREATEs), um mecanismo delta de tempo de execução para comparar o esquema de implantação com o esquema definido e executar os ALTERs delta e integração com a integração do código-fonte, até e incluindo a integração contínua MSBUILD para quedas automatizadas de compilação. A gota conterá um novo tipo de arquivo, os arquivos .dbschema, que podem ser levados ao site de implantação e uma ferramenta de linha de comando pode executar os 'deltas' reais e executar a implantação. Eu tenho uma entrada de blog sobre este tópico com links para os downloads do VSDE; você deve vê-los:http://rusanu.com/2009/05/15/version-control-and-your-database/

É uma pergunta muito antiga, no entanto, muitos estão tentando resolver isso até agora. Tudo o que eles precisam fazer é pesquisar sobre os projetos de banco de dados do Visual Studio. Sem isso, qualquer desenvolvimento de banco de dados parece muito fraco. Da organização do código à implantação e à versão, simplifica tudo.

Na minha experiência, a solução é dupla:

1. Você precisa lidar com as alterações no banco de dados de desenvolvimento que são feitas por vários desenvolvedores durante o desenvolvimento.

2. Você precisa lidar com atualizações de banco de dados nos sites dos clientes.

Para lidar com o número 1, você precisará de uma forte ferramenta de difusão / mesclagem de banco de dados. A melhor ferramenta deve ser capaz de executar a mesclagem automática, tanto quanto possível, permitindo que você resolva conflitos não tratados manualmente.

A ferramenta perfeita deve lidar com operações de mesclagem usando um algoritmo de mesclagem de três vias que leva em consideração as alterações feitas no banco de dados THEIRS e no banco de dados MINE, em relação ao banco de dados BASE.

Eu escrevi uma ferramenta comercial que fornece suporte de mesclagem manual para bancos de dados SQLite e atualmente estou adicionando suporte ao algoritmo de mesclagem de 3 vias para SQLite. Confira em http://www.sqlitecompare.com

Para lidar com o item 2, você precisará de uma estrutura de atualização.

A idéia básica é desenvolver uma estrutura de atualização automática que saiba como atualizar de um esquema SQL existente para o esquema SQL mais recente e possa criar um caminho de atualização para todas as instalações de banco de dados existentes.

Confira meu artigo sobre o assunto em http://www.codeproject.com/KB/database/sqlite_upgrade.aspx para ter uma idéia geral do que estou falando.

Boa sorte

Liron Levi

Confira DBGhost http://www.innovartis.co.uk/ . Eu uso de forma automatizada há 2 anos e funciona muito bem. Ele permite que nossas compilações de banco de dados aconteçam da mesma forma que uma compilação Java ou C, exceto para o banco de dados. Você sabe o que eu quero dizer.

Eu sugeriria o uso de ferramentas de comparação para improvisar um sistema de controle de versão para o seu banco de dados. Uma boa alternativa são o xSQL Schema Compare e o xSQL Data Compare .

Agora, se seu objetivo é ter apenas o esquema do banco de dados sob controle de versão, você pode simplesmente usar a Comparação de Esquema xSQL para gerar Instantâneos xSQL do esquema e adicionar esses arquivos ao seu controle de versão. Para reverter ou atualizar para uma versão específica, basta comparar a versão atual do banco de dados com a captura instantânea da versão de destino.

Infelizmente, se você também deseja que os dados estejam sob controle de versão, é possível usar o xSQL Data Compare para gerar scripts de alteração para o banco de dados e adicionar os arquivos .sql no controle de versão. Você pode então executar esses scripts para reverter / atualizar para qualquer versão que desejar. Lembre-se de que, para a funcionalidade 'reverter', você precisa gerar scripts de mudança que, quando executados, tornarão a Versão 3 igual à Versão 2 e para a funcionalidade 'atualização', você precisará gerar scripts de mudança que fazem o oposto.

Por fim, com algumas habilidades básicas de programação em lote, você pode automatizar todo o processo usando as versões de linha de comando do xSQL Schema Compare e xSQL Data Compare

Isenção de responsabilidade: sou afiliado ao xSQL.