Saya ingin mendapatkan basis data saya di bawah kontrol versi. Adakah yang punya saran atau artikel yang direkomendasikan untuk memulai?

Aku akan selalu ingin memiliki setidaknya beberapa data di sana (sebagai alumb menyebutkan: pengguna jenis dan administrator). Saya juga akan sering menginginkan kumpulan besar data uji yang dihasilkan untuk pengukuran kinerja.

Martin Fowler menulis artikel favorit saya tentang masalah ini, http://martinfowler.com/articles/evodb.html . Saya memilih untuk tidak menempatkan skema dump di bawah kontrol versi sebagai alumb dan yang lainnya menyarankan karena saya ingin cara mudah untuk meningkatkan basis data produksi saya.

Untuk aplikasi web di mana saya akan memiliki instance database produksi tunggal, saya menggunakan dua teknik:

Skrip Peningkatan Database

Skrip pemutakhiran basis data urutan yang berisi DDL diperlukan untuk memindahkan skema dari versi N ke N + 1. (Ini masuk dalam sistem kontrol versi Anda.) Tabel _version_history_, sesuatu seperti

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

mendapat entri baru setiap kali skrip upgrade berjalan yang sesuai dengan versi baru.

Ini memastikan bahwa mudah untuk melihat versi skema database apa yang ada dan bahwa skrip peningkatan database hanya dijalankan sekali. Sekali lagi, ini bukan dump database. Sebaliknya, setiap skrip mewakili perubahan yang diperlukan untuk berpindah dari satu versi ke versi berikutnya. Itu adalah skrip yang Anda terapkan ke basis data produksi Anda untuk "meningkatkannya".

Sinkronisasi Pengembang Kotak Pasir

1. Skrip untuk mencadangkan, membersihkan, dan mengecilkan basis data produksi. Jalankan ini setelah setiap peningkatan ke DB produksi.
2. Sebuah skrip untuk mengembalikan (dan mengubah, jika perlu) cadangan pada workstation pengembang. Setiap pengembang menjalankan skrip ini setelah setiap peningkatan ke DB produksi.

Peringatan: Pengujian otomatis saya dijalankan terhadap database yang benar-benar skema tetapi kosong, jadi saran ini tidak akan sesuai dengan kebutuhan Anda.

Produk SQL Compare Red Gate tidak hanya memungkinkan Anda melakukan perbandingan tingkat objek, dan menghasilkan skrip perubahan dari itu, tetapi juga memungkinkan Anda untuk mengekspor objek database Anda ke hierarki folder yang diatur oleh jenis objek, dengan satu [objectname] .sql creation skrip per objek di direktori ini. Hirarki tipe objek seperti ini:

\ Fungsi
\ Keamanan
\ Keamanan \ Peran
\ Keamanan \ Skema
\ Keamanan \ Pengguna
\ Prosedur Tersimpan
\ Tabel

Jika Anda membuang skrip Anda ke direktori root yang sama setelah Anda membuat perubahan, Anda dapat menggunakan ini untuk memperbarui repo SVN Anda, dan menyimpan sejarah berjalan dari setiap objek secara individual.

Ini adalah salah satu "masalah sulit" pembangunan di sekitarnya. Sejauh yang saya tahu tidak ada solusi yang sempurna.

Jika Anda hanya perlu menyimpan struktur basis data dan bukan data, Anda dapat mengekspor basis data sebagai kueri SQL. (di Enterprise Manager: Klik kanan pada basis data -> Hasilkan skrip SQL. Saya merekomendasikan pengaturan "buat satu file per objek" pada tab opsi) Anda kemudian dapat mengkomit file teks ini ke svn dan menggunakan fungsi svn dan logging.

Saya memiliki ini diikat bersama dengan skrip Batch yang mengambil beberapa parameter dan mengatur database. Saya juga menambahkan beberapa pertanyaan tambahan yang memasukkan data default seperti tipe pengguna dan pengguna admin. (Jika Anda ingin info lebih lanjut tentang ini, poskan sesuatu dan saya dapat menempatkan skrip di tempat yang dapat diakses)

Jika Anda perlu menyimpan semua data juga, saya sarankan menyimpan cadangan database dan menggunakan produk Redgate ( http://www.red-gate.com/ ) untuk melakukan perbandingan. Mereka tidak datang murah, tetapi mereka layak setiap sen.

Pertama, Anda harus memilih sistem kontrol versi yang tepat untuk Anda:

• Sistem Kontrol Versi Terpusat - sistem standar tempat pengguna melakukan check-in / check-in sebelum / setelah mereka mengerjakan file, dan file-file tersebut disimpan dalam satu server pusat

• Sistem Kontrol Versi Terdistribusi - sistem di mana repositori sedang dikloning, dan masing-masing klon sebenarnya adalah cadangan penuh dari repositori, jadi jika ada server yang crash, maka repositori yang dikloning dapat digunakan untuk mengembalikannya. Setelah memilih sistem yang tepat untuk kebutuhan Anda , Anda harus menyiapkan repositori yang merupakan inti dari setiap sistem kontrol versi. Semua ini dijelaskan dalam artikel berikut: http://solutioncenter.apexsql.com/sql-server-source-control-part-i-understanding -sumber-kontrol-dasar-dasar /

Setelah menyiapkan repositori, dan dalam kasus sistem kontrol versi pusat folder yang berfungsi, Anda dapat membaca artikel ini . Ini menunjukkan cara mengatur kontrol sumber dalam lingkungan pengembangan menggunakan:

• SQL Server Management Studio melalui penyedia MSSCCI,

• Alat-alat Data Visual Studio dan SQL Server

• Alat pihak ke-3 Kontrol Sumber ApexSQL

Di sini, di Red Gate kami menawarkan alat, Kontrol Sumber SQL , yang menggunakan teknologi SQL Compare untuk menghubungkan database Anda dengan repositori TFS atau SVN. Alat ini diintegrasikan ke dalam SSMS dan memungkinkan Anda bekerja seperti biasa, kecuali sekarang memungkinkan Anda mengkomit objek.

Untuk pendekatan berbasis migrasi (lebih cocok untuk penyebaran otomatis), kami menawarkan SQL Change Automation (sebelumnya bernama ReadyRoll), yang membuat dan mengelola serangkaian skrip tambahan sebagai proyek Visual Studio.

Dalam Kontrol Sumber SQL dimungkinkan untuk menentukan tabel data statis. Ini disimpan dalam kontrol sumber sebagai pernyataan INSERT.

Jika Anda berbicara tentang data uji, kami sarankan Anda untuk menghasilkan data uji dengan alat atau melalui skrip pasca penempatan yang Anda tentukan, atau Anda cukup mengembalikan cadangan produksi ke lingkungan pengembang.

Anda mungkin ingin melihat Liquibase ( http://www.liquibase.org/ ). Bahkan jika Anda tidak menggunakan alat itu sendiri, ia menangani konsep manajemen perubahan basis data atau refactoring dengan cukup baik.

+1 untuk semua orang yang merekomendasikan alat RedGate, dengan rekomendasi tambahan dan peringatan.

SqlCompare juga memiliki API yang terdokumentasi dengan baik: jadi Anda dapat, misalnya, menulis aplikasi konsol yang menyinkronkan folder skrip sumber terkontrol dengan database pengujian integrasi CI pada checkin, sehingga ketika seseorang memeriksa perubahan pada skema dari folder skrip mereka secara otomatis digunakan bersama dengan perubahan kode aplikasi yang cocok. Ini membantu menutup celah dengan pengembang yang lupa menyebarkan perubahan dalam db lokal mereka hingga DB pengembangan bersama (sekitar setengah dari kita, saya pikir :)).

Peringatan adalah bahwa dengan solusi skrip atau sebaliknya, alat RedGate cukup lancar sehingga mudah untuk melupakan realitas SQL yang mendasari abstraksi. Jika Anda mengganti nama semua kolom dalam sebuah tabel, SqlCompare tidak memiliki cara untuk memetakan kolom lama ke kolom baru dan akan menjatuhkan semua data dalam tabel. Ini akan menghasilkan peringatan tetapi saya telah melihat orang mengklik lebih dari itu. Ada poin umum di sini yang layak dibuat, saya pikir, bahwa Anda hanya dapat mengotomatiskan versi DB dan memutakhirkan sejauh ini - abstraksinya sangat bocor.

Kami menggunakan DBGhost untuk mengelola database SQL kami. Kemudian Anda meletakkan skrip Anda untuk membangun database baru di kontrol versi Anda, dan itu akan membangun database baru, atau memutakhirkan database yang ada ke skema di kontrol versi. Dengan begitu Anda tidak perlu khawatir membuat skrip perubahan (walaupun Anda masih bisa melakukannya, jika misalnya Anda ingin mengubah tipe data kolom dan perlu mengonversi data).

Dengan VS 2010, gunakan proyek Database.

1. Script database Anda
2. Buat perubahan pada skrip atau langsung di server db Anda
3. Sinkronisasi menggunakan Data> Bandingkan Skema

Membuat solusi versi DB yang sempurna, dan menyinkronkan DB dengan mudah.

Ini adalah pendekatan yang baik untuk menyimpan skrip basis data ke dalam kontrol versi dengan skrip perubahan sehingga Anda dapat memutakhirkan satu basis data yang Anda miliki. Anda juga mungkin ingin menyimpan skema untuk versi yang berbeda sehingga Anda dapat membuat database lengkap tanpa harus menerapkan semua skrip perubahan. Menangani skrip harus otomatis sehingga Anda tidak perlu melakukan pekerjaan manual.

Saya pikir ini penting untuk memiliki database terpisah untuk setiap pengembang dan tidak menggunakan database bersama. Dengan begitu para pengembang dapat membuat uji kasus dan fase pengembangan secara independen dari pengembang lain.

Alat otomatisasi harus memiliki sarana untuk menangani metadata database, yang memberi tahu basis data apa dalam kondisi pengembangan dan tabel mana yang berisi data yang dapat dikontrol versi dan sebagainya.

Anda juga dapat melihat solusi migrasi. Ini memungkinkan Anda untuk menentukan skema database Anda dalam kode C #, dan memutar versi database Anda naik dan turun menggunakan MSBuild.

Saat ini saya menggunakan DbUp , dan sudah berfungsi dengan baik.

Anda tidak menyebutkan secara spesifik tentang lingkungan atau kendala target Anda, jadi ini mungkin tidak sepenuhnya berlaku ... tetapi jika Anda sedang mencari cara untuk melacak skema DB yang berkembang secara efektif dan tidak merugikan gagasan untuk menggunakan Ruby, migrasi ActiveRecord ada di depan Anda.

Migrasi secara sistematis menentukan transformasi basis data menggunakan Ruby DSL; setiap transformasi dapat diterapkan atau (biasanya) dibatalkan, memungkinkan Anda untuk beralih ke versi berbeda dari skema DB Anda pada suatu titik waktu tertentu. File yang mendefinisikan transformasi ini dapat diperiksa ke dalam kontrol versi seperti bagian lain dari kode sumber.

Karena migrasi merupakan bagian dari ActiveRecord , mereka biasanya digunakan di aplikasi Rails bertumpuk penuh; namun, Anda dapat menggunakan ActiveRecord independen dari Rails dengan upaya minimal. Lihat di sini untuk perawatan yang lebih terperinci dalam menggunakan migrasi AR di luar Rails.

Setiap basis data harus di bawah kendali kode sumber. Apa yang kurang adalah alat untuk secara otomatis skrip semua objek database - dan "data konfigurasi" - ke file, yang kemudian dapat ditambahkan ke sistem kontrol sumber apa pun. Jika Anda menggunakan SQL Server, maka solusi saya ada di sini: http://dbsourcetools.codeplex.com/ . Selamat bersenang-senang. - Nathan.

Itu mudah.

1. Ketika proyek dasar siap maka Anda harus membuat skrip basis data lengkap. Skrip ini berkomitmen untuk SVN. Ini adalah versi pertama.

2. Setelah itu semua pengembang membuat skrip perubahan (ALTER ..., tabel baru, sprocs, dll).

3. Ketika Anda membutuhkan versi saat ini maka Anda harus menjalankan semua skrip perubahan baru.

4. Ketika aplikasi dirilis ke produksi maka Anda kembali ke 1 (tapi tentu saja itu akan menjadi versi yang berurutan).

Nant akan membantu Anda menjalankan skrip perubahan itu. :)

Dan ingatlah. Semuanya bekerja dengan baik ketika ada disiplin. Setiap kali ketika perubahan database dilakukan maka fungsi yang sesuai dalam kode juga dilakukan.

Untuk membuat dump ke sistem kontrol kode sumber yang sedikit lebih cepat, Anda dapat melihat objek mana yang telah berubah sejak terakhir kali dengan menggunakan informasi versi di sysobjects.

Pengaturan: Buat tabel di setiap basis data yang ingin Anda periksa secara bertahap untuk menyimpan informasi versi sejak terakhir kali Anda memeriksanya (kosong saat dijalankan pertama kali). Kosongkan tabel ini jika Anda ingin memindai ulang seluruh struktur data Anda.

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)
)

Mode menjalankan normal: Anda dapat mengambil hasil dari sql ini, dan menghasilkan skrip sql hanya untuk yang Anda minati, dan menempatkannya ke dalam kontrol sumber pilihan Anda.

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

Catatan: Jika Anda menggunakan pemeriksaan non-standar di salah satu basis data Anda, Anda harus mengganti /* COLLATE */dengan pemeriksaan basis data Anda. yaituCOLLATE Latin1_General_CI_AI

Karena aplikasi kami harus bekerja di beberapa RDBMS, kami menyimpan definisi skema kami dalam kontrol versi menggunakan format Torsi yang netral basis data (XML). Kami juga mengontrol versi data referensi untuk database kami dalam format XML sebagai berikut (di mana "Hubungan" adalah salah satu tabel referensi):

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

Kami kemudian menggunakan alat buatan sendiri untuk membuat skema peningkatan dan referensi skrip pemutakhiran data yang diperlukan untuk beralih dari versi X dari basis data ke versi X + 1.

Jika Anda memiliki database kecil dan Anda ingin memvariasikan semuanya, skrip kumpulan ini mungkin membantu. Ini melepaskan, memampatkan, dan memeriksa file MDF database MSSQL ke Subversion.

Jika Anda sebagian besar ingin versi skema Anda dan hanya memiliki sedikit data referensi, Anda mungkin dapat menggunakan Migrasi SubSonic untuk mengatasinya. Keuntungannya adalah Anda dapat dengan mudah bermigrasi ke atas atau ke bawah ke versi tertentu.

Kami tidak menyimpan skema database, kami menyimpan perubahan ke database. Apa yang kami lakukan adalah menyimpan perubahan skema sehingga kami membuat skrip perubahan untuk versi database apa pun dan menerapkannya pada basis data pelanggan kami. Saya menulis aplikasi utilitas basis data yang didistribusikan dengan aplikasi utama kami yang dapat membaca skrip itu dan mengetahui pembaruan mana yang perlu diterapkan. Ini juga memiliki kecerdasan yang cukup untuk menyegarkan tampilan dan prosedur yang tersimpan sesuai kebutuhan.

Kami perlu versi SQL database kami setelah kami bermigrasi ke platform x64 dan versi lama kami putus dengan migrasi. Kami menulis aplikasi C # yang menggunakan SQLDMO untuk memetakan semua objek SQL ke folder:

                Akar
                    Nama server
                       DatabaseName
                          Objek Skema
                             Pemicu Basis Data *
                                .ddltrigger.sql
                             Fungsi
                                ..function.sql
                             Keamanan
                                Peran
                                   Peran Aplikasi
                                      .approle.sql
                                   Peran Basis Data
                                      .role.sql
                                Skema *
                                   .schema.sql
                                Pengguna
                                   .user.sql
                             Penyimpanan
                                Katalog Teks Lengkap *
                                   .fulltext.sql
                             Prosedur Tersimpan
                                ..proc.sql
                             Sinonim *
                                .sinonim.sql
                             Tabel
                                ..table.sql
                                Kendala
                                   ... chkconst.sql
                                   ... defconst.sql
                                Indeks
                                   ... index.sql
                                Kunci
                                   ... fkey.sql
                                   ... pkey.sql
                                   ... ukey.sql
                                Pemicu
                                   ... trigger.sql
                             Jenis
                                Tipe Data yang ditentukan pengguna
                                   ..uddt.sql
                                Koleksi Skema XML *
                                   ..xmlschema.sql
                             Tampilan
                                ..view.sql
                                Indeks
                                   ... index.sql
                                Pemicu
                                   ... trigger.sql

Aplikasi kemudian akan membandingkan versi yang baru ditulis dengan versi yang disimpan di SVN dan jika ada perbedaan itu akan memperbarui SVN. Kami memutuskan bahwa menjalankan proses sekali malam sudah cukup karena kami tidak membuat banyak perubahan pada SQL. Ini memungkinkan kita untuk melacak perubahan pada semua objek yang kita pedulikan dan memungkinkan kita untuk membangun kembali skema penuh kita jika terjadi masalah serius.

Saya menulis aplikasi ini beberapa waktu lalu, http://sqlschemasourcectrl.codeplex.com/ yang akan memindai MSFT SQL db Anda sesering yang Anda inginkan dan secara otomatis membuang objek Anda (tabel, tampilan, procs, fungsi, pengaturan sql) ke SVN. Bekerja seperti pesona. Saya menggunakannya dengan Unfuddle (yang memungkinkan saya mendapatkan peringatan tentang checkin)

Solusi khasnya adalah membuang database yang diperlukan dan membuat cadangan file-file itu.

Bergantung pada platform pengembangan Anda, mungkin ada plugin opensource yang tersedia. Menggulirkan kode Anda sendiri untuk melakukannya biasanya cukup sepele.

Catatan: Anda mungkin ingin membuat cadangan dump basis data alih-alih meletakkannya di kontrol versi. File-file tersebut dapat menjadi sangat cepat dalam kontrol versi, dan menyebabkan seluruh sistem kontrol sumber Anda menjadi lambat (saya mengingat kisah horor CVS saat ini).

Kami baru saja mulai menggunakan Team Foundation Server. Jika basis data Anda berukuran sedang, maka studio visual memiliki beberapa integrasi proyek yang bagus dengan pembandingan bawaan, perbandingan data, alat refactoring basis data, kerangka kerja pengujian basis data, dan bahkan alat pembuatan data.

Tapi, model itu tidak cocok dengan database yang sangat besar atau pihak ketiga (yang mengenkripsi objek) dengan sangat baik. Jadi, yang kami lakukan adalah menyimpan hanya objek yang kami sesuaikan. Server Visual Studio / Team foundation bekerja sangat baik untuk itu.

Kepala kepala TFS Database. blog

Situs MS TFS

Saya setuju dengan jawaban ESV dan untuk alasan yang tepat saya memulai proyek kecil beberapa waktu lalu untuk membantu menjaga pembaruan basis data dalam file yang sangat sederhana yang kemudian dapat dikelola dengan kode sumber yang panjang. Ini memungkinkan pembaruan yang mudah untuk pengembang serta UAT dan Produksi. Alat ini berfungsi tetapi Sql Server dan MySql.

Beberapa fitur proyek:

• Mengizinkan perubahan skema
• Mengizinkan nilai populasi pohon
• Mengizinkan sisipan data uji terpisah untuk mis. UAT
• Mengizinkan opsi untuk kembalikan (tidak otomatis)
• Mempertahankan dukungan untuk SQL server dan Mysql
• Memiliki kemampuan untuk mengimpor basis data yang ada ke kontrol versi dengan satu perintah sederhana (hanya server sql ... masih bekerja di mysql)

Kode dihosting di kode google. Silakan periksa kode Google untuk informasi lebih lanjut

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

Beberapa waktu yang lalu saya menemukan modul VB bas yang menggunakan objek DMO dan VSS untuk mendapatkan seluruh db scripted dan masuk ke VSS. Saya mengubahnya menjadi VB Script dan mempostingnya di sini . Anda dapat dengan mudah mengambil panggilan VSS dan menggunakan hal-hal DMO untuk menghasilkan semua skrip, dan kemudian memanggil SVN dari file batch yang sama yang memanggil VBScript untuk memeriksanya?

Dave J

Saya juga menggunakan versi dalam basis data yang disimpan melalui basis data properti luas prosedur. Aplikasi saya memiliki skrip untuk setiap langkah versi (mis. Pindah dari 1.1 ke 1.2). Ketika digunakan, itu terlihat pada versi saat ini dan kemudian menjalankan skrip satu per satu hingga mencapai versi aplikasi terakhir. Tidak ada skrip yang memiliki versi 'final' langsung, bahkan menggunakan DB bersih melakukan penyebaran melalui serangkaian langkah peningkatan.

Sekarang yang ingin saya tambahkan adalah bahwa saya telah melihat dua hari yang lalu sebuah presentasi di kampus MS tentang edisi VS DB yang baru dan akan datang. Presentasi difokuskan khusus pada topik ini dan saya terharu. Anda pasti harus memeriksanya, fasilitas baru difokuskan untuk menjaga definisi skema dalam skrip T-SQL (CREATEs), mesin runtime delta untuk membandingkan skema penempatan dengan skema yang ditentukan dan melakukan delta ALTER dan integrasi dengan integrasi kode sumber, hingga dan termasuk integrasi berkelanjutan MSBUILD untuk tetes build otomatis. Drop akan berisi jenis file baru, file .dbschema, yang dapat dibawa ke situs penyebaran dan alat baris perintah dapat melakukan 'delta' yang sebenarnya dan menjalankan penyebaran. Saya memiliki entri blog tentang topik ini dengan tautan ke unduhan VSDE, Anda harus memeriksanya:http://rusanu.com/2009/05/15/version-control-and-your-database/

Ini pertanyaan yang sangat lama, namun banyak yang mencoba menyelesaikannya bahkan sekarang. Yang harus mereka lakukan adalah melakukan riset tentang Proyek Basis Data Visual Studio. Tanpa ini, pengembangan basis data apa pun terlihat sangat lemah. Dari organisasi kode hingga penerapan hingga versi, ini menyederhanakan segalanya.

Dalam pengalaman saya, solusinya ada dua:

1. Anda perlu menangani perubahan pada database pengembangan yang dilakukan oleh banyak pengembang selama pengembangan.

2. Anda perlu menangani peningkatan basis data di situs pelanggan.

Untuk menangani # 1, Anda akan memerlukan alat basis data / penggabungan yang kuat. Alat terbaik harus dapat melakukan penggabungan otomatis sebanyak mungkin sambil memungkinkan Anda untuk menyelesaikan konflik yang tidak ditangani secara manual.

Alat yang sempurna harus menangani operasi penggabungan dengan menggunakan algoritma penggabungan 3 arah yang memperhitungkan perubahan yang dibuat dalam database THEIRS dan database MINE, relatif terhadap database BASE.

Saya menulis alat komersial yang menyediakan dukungan penggabungan manual untuk database SQLite dan saya saat ini menambahkan dukungan untuk algoritma penggabungan 3-cara untuk SQLite. Lihat di http://www.sqlitecompare.com

Untuk menangani # 2 Anda akan membutuhkan kerangka kerja upgrade di tempat.

Ide dasarnya adalah untuk mengembangkan kerangka kerja pemutakhiran otomatis yang tahu cara memutakhirkan dari skema SQL yang ada ke skema SQL yang lebih baru dan dapat membangun jalur peningkatan untuk setiap instalasi DB yang ada.

Lihat artikel saya tentang masalah ini di http://www.codeproject.com/KB/database/sqlite_upgrade.aspx untuk mendapatkan gambaran umum tentang apa yang saya bicarakan.

Semoga berhasil

Liron Levi

Lihat DBGhost http://www.innovartis.co.uk/ . Saya telah menggunakan mode otomatis selama 2 tahun sekarang dan ini bekerja dengan sangat baik. Hal ini memungkinkan pembangunan DB kami terjadi seperti Java atau pembangunan C terjadi, kecuali untuk database. Kamu tahu apa maksudku.

Saya akan menyarankan menggunakan alat perbandingan untuk berimprovisasi sistem kontrol versi untuk database Anda. Alternatif yang baik adalah xSQL Schema Compare dan xSQL Data Compare .

Sekarang, jika tujuan Anda hanya memiliki skema database di bawah kontrol versi, Anda cukup menggunakan xSQL Schema Compare untuk menghasilkan xSQL Snapshots dari skema dan menambahkan file-file ini di kontrol versi Anda. Kemudian, untuk mengembalikan atau memperbarui ke versi tertentu cukup bandingkan versi database saat ini dengan snapshot untuk versi tujuan.

Sayangnya, jika Anda ingin memiliki data di bawah kontrol versi juga, Anda dapat menggunakan xSQL Data Compare untuk menghasilkan skrip perubahan untuk database Anda dan menambahkan file .sql di kontrol versi Anda. Anda kemudian dapat menjalankan skrip ini untuk mengembalikan / memperbarui ke versi apa pun yang Anda inginkan. Ingatlah bahwa untuk fungsi 'kembalikan' Anda perlu membuat skrip perubahan yang ketika dijalankan akan membuat Versi 3 sama dengan Versi 2 dan untuk fungsi 'pembaruan', Anda perlu membuat skrip perubahan yang melakukan sebaliknya.

Terakhir, dengan beberapa keterampilan pemrograman batch dasar Anda dapat mengotomatiskan seluruh proses dengan menggunakan versi baris perintah xSQL Schema Compare dan xSQL Data Compare

Penafian: Saya berafiliasi dengan xSQL.