Mantenere il DB di SQL Server Aggiornato in ambiente Team [duplicato]

0

Lavoriamo in un ambiente di Visual Studio usando TFS. Quando gli sviluppatori ricevono il codice sorgente più recente, include una copia degli script sql di "aggiornamento" per il database dell'applicazione. La sfida è mantenere aggiornate le nostre copie locali del DB.

Quando le modifiche vengono apportate al DB da un altro sviluppatore, stiamo cercando un modo per:

  1. indica agli altri sviluppatori che la loro versione del DB non è aggiornata
  2. indica agli altri sviluppatori l'ordine in cui dovrebbero eseguire gli script di aggiornamento

Stiamo cercando suggerimenti. Per il punto numero 2, ho usato numeri come 01_DropCreate_TableX, 02_Create_StoreProcedure_X. etc

DH

    
posta Dylan 03.05.2013 - 15:59
fonte

3 risposte

2

Questo è ciò che facciamo, ma siamo sviluppatori PHP non VS quindi forse Microsoft ha un approccio migliore, ma l'idea dovrebbe essere la stessa.

Manteniamo una tabella dei log delle modifiche nel database. Ogni volta che gli script di aggiornamento vengono eseguiti, questa tabella viene aggiornata per riflettere lo stato corrente del database. Mantiene anche una cronologia delle modifiche (questo ti consente di individuare i database dei clienti che potrebbero avere degli hotfix speciali installati che altri non hanno).

CREATE TABLE 'changelogs' (
  'id' int(10) unsigned NOT NULL AUTO_INCREMENT,
  'version' varchar(45) NOT NULL,
  'previous' varchar(45) NOT NULL,
  'log' text,
  'started' datetime DEFAULT NULL,
  'finished' datetime DEFAULT NULL,
  'created' datetime NOT NULL,
  PRIMARY KEY ('id'),
  KEY 'created' ('created')
) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=latin1$$

Ci sono due tipi di aggiornamenti dal controllo del codice sorgente che gli sviluppatori dovranno conoscere.

  1. L'aggiornamento è ridondante, il che significa che possono semplicemente cancellare un record dai loro log delle modifiche del database e rieseguire gli aggiornamenti. Gli aggiornamenti non richiedono un punto critico nello schema.

  2. L'aggiornamento è dipendente e devono riportare il database a una versione stabile in modo che gli aggiornamenti possano portarlo in avanti. Gli aggiornamenti richiedono uno schema specifico.

Mentre i clienti possono eseguire la versione 2.0.0 del database. Gli sviluppatori possono solo eseguire il rollback a 2.9.9 per testare l'aggiornamento a 3.0.0 (beta). Puoi anche eseguire il downgrade degli script che eseguono rapidamente hack sul database per rendere sicuri gli aggiornamenti da eseguire.

Il processo di aggiornamento è fondamentalmente una tecnica automatizzata di tua scelta. Usiamo una directory in ogni progetto che memorizza un elenco di file SQL. Il contenuto della directory assomiglia a questo.

install.sql
update.txt
update-2.0.0.sql
update-2.0.1.sql
update-3.0.0.sql
hotfix-3.0.1.sql

install.sql è il nostro script di immissione del punto zero. Crea il database per le nuove installazioni.

update.txt è la nostra guida agli aggiornamenti per lo script di distribuzione, mentre il resto sono file SQL da eseguire.

Il contenuto di update.txt assomiglia a questo.

#
# Defines the update mapping of which SQL files are executed.
# The order of this file isn't important, but do not create
# endless circular versions (i.e. update 3 to 4, then 4 down to 3).
#
# Usage for each line:
# [current_version]=update-[new_version].sql
#
3.3.14=update-3.4.0.sql

# DATE: 20130107 144921
3.4.0=update-3.4.1.sql

L'unico valore che lo script di implementazione comprende è la prima parte current_verion . Quello è uguale a un file. Quando viene eseguito lo script di distribuzione, legge la versione corrente dalla tabella changelogs e quindi esegue il file SQL che corrisponde a quella versione. Questo fa avanzare il database nelle modifiche dello schema. Questo processo si ripete finché non ci sono più corrispondenze nel file update.txt (l'ordine nel file non è importante).

Questo approccio funziona bene per noi. Siamo in grado di individuare i clienti con gli hotfix, ma continuiamo a migrare verso versioni ufficiali successive. Installa anche piccoli file di modifica SQL per aggiornarli dal loro hotfit.

L'unico problema con questo approccio è che richiede disciplina da parte dello sviluppatore. Separiamo questo processo anche dal modulo software, piuttosto che da una directory di aggiornamento di grandi dimensioni per applicazione. Per ogni modulo, prefixiamo la tabella changelog . Quindi abbiamo più tabelle chiamate cose come documents_changelog e users_changelog . Questo ha funzionato bene per noi poiché i moduli sono condivisi su più applicazioni.

    
risposta data 03.05.2013 - 17:16
fonte
1

La mia soluzione è di avere una tabella delle versioni dello schema nel database.

Se il numero di versione (massimo) definito negli script (in realtà lo faccio nel codice: vedi link e variamente su stackoverflow) non corrisponde al numero massimo nel database, quindi hai un problema (le mie app si rifiutano semplicemente di eseguire se c'è una mancata corrispondenza, ma potresti essere più flessibile di così).

Questa è una soluzione semplice (anche se paritaria!) ma funziona bene per me. Su un sistema legacy abbiamo ancora più rozzo - abbiamo una tabella di script applicati (dal punto in cui siamo diventati leggermente più intelligenti) con gli script prefissati yyyy-MM-dd in modo da ordinare. A breve avremo un altro script per vedere quali non sono stati applicati.

La chiave per me è la possibilità di confrontare una versione / elenco di script effettivi applicata con una versione / elenco di script previsti.

Ora ci sono giocattoli più recenti per fare questo genere di cose - EF Migrations sembra avvicinarsi al punto in cui farà miracoli - ma per ora ho un modello che funziona bene per me.

    
risposta data 03.05.2013 - 16:22
fonte
0

Quello che stai cercando di fare è fare migrazioni di database. Ci sono un certo numero di strumenti diversi là fuori che gestiscono questo in vari modi. Dato che hai già un sacco di script che dovrebbero essere eseguiti in ordine, vorrei iniziare con RoundHouse in quanto può gestire il roba legacy che hai dato che è solo un runner script sql su steroidi gravi.

Un solo protip per l'integrazione con il db esistente - il trucco è quello di migrare un nuovo "database" e quindi afferrare le tavole rotonde e inserirle in produzione. Una volta che inizierai a spedire i backup a Dev di nuovo, avremo una copia della roba rotonda in modo che le migrazioni funzionino. Inoltre, puoi applicare le migrazioni alla produzione direttamente a quel punto e avere tutti i vantaggi dello strumento.

    
risposta data 03.05.2013 - 16:50
fonte