O produto de comparação SQL do Red Gate não só lhe permite fazer comparações ao nível de objectos e gerar programas de mudança a partir disso, como também lhe permite exportar os seus objectos de base de dados para uma hierarquia de pastas organizada por tipo de objecto, com um [objectname].script de criação de sql por objecto nestas pastas. A hierarquia do tipo de objeto é assim:

\Functions
\Segurança
\Segurança\Papéis
\Security\Schemas
\Segurança\Utilizadores
\Procedimentos Armazenados
\Tabela

Se enviar os seus programas para a mesma pasta de topo depois de fazer alterações, poderá usar isto para actualizar o seu acordo de SVN e manter um histórico em execução de cada objecto individualmente.

Se você só precisa armazenar a estrutura da base de dados e não os dados você pode exportar a base de dados como consultas SQL. (no Enterprise Manager: clique com o botão direito na base de dados -> gerar script SQL. Eu recomendo a configuração do "criar um arquivo por objeto" na página de opções) você pode então enviar esses arquivos de texto para svn e fazer uso das funções de diferenças e login do svn.

Ter isso atado junto com um script de lote que leva alguns parâmetros e configura a base de dados. Eu também adicionei algumas consultas adicionais que introduzem dados padrão como tipos de usuário e o usuário administrativo. (Se você quiser mais informações sobre isso, postar algo e eu posso colocar o script em algum lugar acessível)

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

Primeiro, você deve escolher o sistema de controle de versões que é certo para você:

• Sistema centralizado de controle de Versão-um sistema padrão onde os usuários check-out / check-in antes / depois que eles trabalham em arquivos, e os arquivos estão sendo mantidos em um único servidor central

• Sistema de controle de Versão Distribuído - um sistema onde o repositório está sendo clonado, e cada clone é na verdade o backup completo do repositório, então se algum servidor falhar, então qualquer clonado o repositório pode ser usado para restaurá-lo Depois de escolher o sistema certo para suas necessidades, você precisará configurar o repositório que é o núcleo de cada 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 controlo de versões, uma pasta de trabalho, pode ler Este artigo. Ele mostra como configurar o controlo de código num ambiente de desenvolvimento usando:

• SQL Server Management Studio via MSSCCI provider,

• Visual Studio e SQL Server Data Tools

• um controlo de fonte ApexSQL para Ferramentas de terceiros

Aqui no Red Gate oferecemos uma ferramenta, SQL Source Control , que usa a tecnologia SQL Compare para ligar a sua base de dados com um repositório TFS ou SVN. Esta ferramenta integra-se no SSMS e permite-lhe trabalhar como normalmente, excepto que agora lhe permite enviar os objectos.

Para uma abordagem baseada em migrações (mais adequada para implementações automatizadas), oferecemos ReadyRoll, que cria e gere um conjunto de scripts incrementais como um projeto de estúdio Visual.

Na fonte SQL Controle é possível especificar tabelas de dados estáticas. Estes são armazenados no controle de origem como instruções de inserção.

Se está a falar de dados de teste, recomendamos que crie dados de teste com uma ferramenta ou através de um programa de pós-implantação que defina, ou simplesmente que restaure uma cópia de segurança de produção para o ambiente dev.

É melhor veres o Liquibase (http://www.liquibase.org/). mesmo que não utilize a ferramenta em si, ela lida muito bem com os conceitos de gestão de alterações de bases de dados ou de refactoring.

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

O SqlCompare também tem uma API decentemente documentada: para que possa, por exemplo, escrever uma aplicação de consola que sincroniza a sua pasta de scripts controlados pelo código fonte com uma base de dados de testes de integração de IC no checkin, de modo que, quando alguém verificar uma alteração no esquema da sua pasta de scripts, ela é automaticamente implantada juntamente com a alteração correspondente do Código da aplicação. Isto ajuda a fechar o gap with developers who are forgotful about Propagand changes in their local db up to a shared development DB (about half of us, I think :) ).

Uma ressalva é que com uma solução scriptada ou não, as ferramentas RedGate são suficientemente suaves que é fácil esquecer sobre as realidades SQL subjacentes à abstração. Se mudar o nome de todas as colunas de uma tabela, o SqlCompare não tem como mapear as colunas antigas para as novas colunas e irá largar todos os dados na tabela. Irá gerar avisos, mas já vi pessoas a passar por isso. Há um ponto geral aqui que vale a pena fazer, eu acho, que você só pode automatizar DB versioning e atualizar até agora - as abstrações são muito vazadas.

Usamos DBGhost para gerir a nossa base de dados SQL. Em seguida, você coloca seus scripts para construir um novo banco de dados em seu controle de versão, e ele vai construir um novo banco de dados, ou atualizar qualquer banco de dados existente para o esquema no controle de versão. Dessa forma, você não tem que se preocupar com a criação de scripts de mudança (embora você ainda pode fazer isso, se, por exemplo, você quer mudar o tipo de dados de uma coluna e precisa converter dados).

Com VS 2010, use o projecto da Base de dados.

1. Script out your database
2. faça alterações aos programas ou directamente em o seu servidor db
3. sincronizar usando os dados > Schema Compare

É uma boa abordagem para gravar scripts de banco de dados no controle de versões com scripts de mudança para que você possa atualizar qualquer banco de dados que você tenha. Além disso, você pode querer salvar esquemas para diferentes versões para que você possa criar um banco de dados completo sem ter que aplicar todos os scripts de mudança. Manusear os scripts deve ser automatizado para que você não tenha que fazer o trabalho manual.

Acho que é importante ter uma base de dados separada para cada programador e não usar uma base de dados partilhada. Que como 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 metadados de bases de dados, que indica quais as bases de dados em que estado de desenvolvimento e quais as tabelas que contêm dados controláveis de Versão, etc.

Não mencionou nenhum detalhe sobre o seu ambiente ou restrições alvo, por isso isto pode não ser inteiramente aplicável... mas se você está procurando uma maneira eficaz de rastrear um esquema de DB em evolução e não são adversos à idéia de usar Ruby, as migrações da ActiveRecord estão no seu ramo.

Uma vez que as migrações fazem parte de ActiveRecord, elas normalmente encontram uso em aplicações de Carris de pilha completa; no entanto, você pode usar ActiveRecord independente dos carris com o mínimo de esforço. Veja Aqui para um tratamento mais detalhado da utilização das migrações de AR fora dos carris.

Você também pode olhar para uma solução de migrações. Estes permitem-lhe especificar o seu esquema de base de dados em código C#, e rolar a sua versão de base de dados para cima e para baixo usando o MSBuild.

Estou a usar DbUp , e tem funcionado bem.

Todas as bases de dados devem estar sob controlo de código fonte. O que está faltando é uma ferramenta para script automaticamente todos os objetos de banco de dados - e "dados de configuração" - para arquivo, que então pode ser adicionado a qualquer sistema de controle de fonte. Se você está usando o servidor SQL, então minha solução está aqui: http://dbsourcetools.codeplex.com / . Divertir. - Nata.

1. Quando o projeto base estiver pronto, você deve criar um script de banco de dados completo. Este script é enviado para SVN. É a primeira versão.

2. Depois disso, todos os desenvolvedores criam scripts de mudança (ALTER..., novas tabelas, sprocs, etc).

3. Quando precisar da versão actual, deverá executar todos os novos programas de alterações.

4. Quando app é lançado para a produção, em seguida, você voltar para 1 (mas, em seguida, será a versão sucessiva de curso).

O Nant vai ajudá-lo a executar esses programas de alteração. :)

Se tiver uma pequena base de dados e quiser actualizar a coisa toda, este programa em lote pode ajudar. Ele detalha, comprime e verifica um arquivo MDF de banco de dados MSSQL no Subversion.

Se quiser, na sua maioria, actualizar o seu esquema e apenas ter uma pequena quantidade de dados de referência, poderá possivelmente usar as migrações subsónicas para lidar com isso. O benefício lá é que você pode facilmente migrar para cima ou para baixo para qualquer versão específica.

Para fazer o dump para um sistema de controlo de código fonte que seja um pouco mais rápido, você pode ver quais os objectos que mudaram desde a última vez usando a informação de versão em sysobjects.

Configuração: crie uma tabela em cada base de dados que deseja verificar de forma incremental para manter a informação da versão da última vez que a verificou (em branco na primeira execução). Limpe esta tabela se quiser rever toda a sua 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 normal de execução: Você pode pegue os resultados deste sql, e crie scripts sql apenas para aqueles que você está interessado, e coloque-os em um controle de fonte 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 utilizar uma colação não-padrão em qualquer das suas bases de dados, terá de substituir /* COLLATE */ pela sua colação de base de dados. = = referências = = COLLATE Latin1_General_CI_AI

Como o nosso aplicativo tem de funcionar em múltiplos RDBMSs, armazenamos a nossa definição de esquema no controlo de versões usando o formato neutro de base de dados Torque (XML). Nós também controlamos os dados de referência para a nossa base de dados em formato XML da seguinte forma (Onde "relacionamento" é uma das tabelas de referência):

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

Então usamos ferramentas domésticas para gerar a atualização do esquema e os programas de atualização de dados de referência que são necessários para ir da versão X do banco de dados para a versão X + 1.

                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

A aplicação compararia então a versão escrita recente com a versão armazenada no SVN e, se houvesse diferenças, actualizaria o SVN. Nós determinamos que a execução do processo uma vez por noite era suficiente, uma vez que não fazemos muitas mudanças para BANCO. Ele nos permite acompanhar as mudanças em todos os objetos que nos preocupam mais nos permite reconstruir nosso esquema completo Em caso de um problema grave.

A solução típica é descarregar a base de dados conforme necessário e fazer backup desses ficheiros.

Dependendo da sua plataforma de desenvolvimento, pode haver plugins opensource disponíveis. Rolar seu próprio código para fazê-lo é geralmente bastante trivial.

Nota: poderá querer fazer uma cópia de segurança da base de dados em vez de a colocar no controlo de versões. Os arquivos podem ficar enormes rapidamente no controle de versão, e fazer com que todo o seu sistema de controle de fonte para se tornar lento (estou lembrando uma história de horror CVS no momento).

Mas, esse modelo não se encaixa muito bem em bases de dados grandes ou de terceiros (que encriptam objectos). Então, o que fizemos foi armazenar apenas os nossos objectos personalizados. Visual Studio / Team foundation server funciona muito bem por isso.

Chefe da Base de dados da TFS. blog

Sítio do MS TFS

Concordo com a resposta do ESV e, por essa razão, comecei um pequeno projecto há algum tempo atrás para ajudar a manter as actualizações da base de dados num ficheiro muito simples que poderia ser mantido um longo código fonte. Ele permite atualizações fáceis para desenvolvedores, bem como UAT e produção. A ferramenta funciona no servidor mas Sql e MySql.

Algumas características do projecto:

• permite as alterações do esquema
• permite o valor da população das árvores
• permite inserir dados de ensaio separados para eg. UAT
• permite a opção de rollback (não automatizado)
• mantém o suporte para o servidor SQL e o Mysql
• tem a capacidade de importar a sua base de dados existente para o controlo de versões com um comando simples(apenas o servidor sql ... ainda estou a trabalhar no mysql.

O código está hospedado no código google. Por favor, confira o código Google para mais informações

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

Dave J

Também estou a usar uma versão na base de dados armazenada através da família de procedimentos de propriedades estendidas da base de dados. A minha aplicação tem scripts para cada passo de versão (ie. passar de 1.1 para 1.2). Quando implantado, ele olha para a versão atual e, em seguida, executa os scripts, um a um, até chegar à última versão do aplicativo. Não há nenhum script que tenha a versão 'final' reta, mesmo implantado em um DB limpo faz a implantação através de uma série de passos de atualização.

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

1. Você precisa lidar com 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 em sites de clientes.

Para lidar com o #1, vai precisar de uma ferramenta forte de diferenças/junção de bases de dados. A melhor ferramenta deve ser capaz de realizar a junção automática tanto quanto possível, permitindo-lhe resolver os conflitos sem ajuda manualmente.

A ferramenta perfeita deve lidar com as operações de junção usando um algoritmo de junção de 3 vias que traz em conta as alterações que foram feitas na base de dados deles e na base de dados MINE, em relação à base de dados BASE.

Escrevi uma ferramenta comercial que oferece suporte manual de junção para bases de dados SQLite e estou a adicionar suporte para algoritmo de junção de 3 vias para SQLite. Confira em http://www.sqlitecompare.com

Para lidar com o #2 vai precisar de um upgrade no lugar.

A ideia básica é desenvolver uma plataforma de actualização automática que saiba como actualizar a partir de um esquema SQL existente para o esquema SQL mais recente e que possa criar um caminho de actualização para cada instalação DB existente.

Vê o meu artigo sobre o assunto em http://www.codeproject.com/KB/database/sqlite_upgrade.aspx para ter uma ideia geral do que estou a falar.

Liron Levi

Confira DBGhost http://www.innovartis.co.uk há dois anos que uso de forma automatizada e funciona muito bem. Ele permite que nossas compilações DB aconteçam muito como uma construção Java ou C acontece, exceto para o banco de dados. Sabes o que quero dizer.

Agora, se o seu objectivo é ter apenas o esquema da base de dados sob controlo de versão, pode simplesmente usar o esquema xSQL Compare para gerar imagens do esquema xSQL e adicionar estes ficheiros no seu controlo de versão. Do que, para reverter ou atualizar para uma versão específica basta comparar a versão atual do base de dados com a fotografia para a versão de destino.

Alas, se você quiser ter os dados sob controle de versão também, você pode usar dados xSQL comparar para gerar scripts de mudança para o seu banco de dados e adicionar o .arquivos sql em seu controle de versão. Poderá então executar estes programas para reverter / actualizar para qualquer versão que desejar. Tenha em mente que para a funcionalidade 'reverter' você precisa gerar scripts de mudança que quando executado fará a versão 3 o mesmo que a versão 2 e para a funcionalidade 'update', você precisa gerar scripts de mudança que fazem o oposto.

Por último, com algumas competências básicas de programação em lote, poderá automatizar todo o processo usando as versões da linha de comandos do XSQL Schema Compare e xSQL Data Compare

Aviso: sou membro da xSQL.