Migity Framework MigrationSqlGenerator cho SQLite

Question

có một MigrationSqlGenerator cho SQLite để sử dụng với khung thực thể không? Tôi chỉ tìm thấy một từ devart đó là thương mại.

Không có MigrationSqlNhà phát hiện được tìm thấy cho nhà cung cấp 'System.Data.SQLite'. Sử dụng phương thức SetSqlGenerator trong cấu hình di chuyển đích để đăng ký các trình tạo SQL bổ sung.

Đây là những gì tôi làm: http://msdn.microsoft.com/en-gb/data/jj591621

Answer 1

Tôi không nghĩ có bất kỳ, người ta tự do, để kiến ​​thức của tôi.

Nếu bạn không quan tâm đến thương mại Devart dotConnect for SQLite - bạn có thể thử thực hiện một mình - nó có thể không đơn giản nhưng bạn có mã nguồn EF theo ý của bạn (đối với EF6 nhưng những phần đó tương tự như tôi ' d nói).
http://entityframework.codeplex.com/

Nếu bạn có một cái nhìn vào mã nguồn SqlCeMigrationSqlGenerator (nguồn khác, tôi không thể tìm thấy một trên trang web chính thức, nhưng bạn có thể tải về và kiểm tra)

... bạn sẽ thấy máy phát điện tương đối đơn giản. Tất nhiên mà đi cho Ce đó là sử dụng khách hàng Sql tiêu chuẩn như máy phát điện cơ bản.

SQLite sẽ yêu cầu nhiều công việc hơn nhưng có thể không quá khó.

Ngoài ra, điều tương tự đến từ một nguồn cũng biết trên EF ở đây - Can we use EF migrations with MySql

---

Và đừng 'la mắng tôi' :) Tôi biết đây không phải là những gì bạn đang tìm kiếm - nhưng tôi nghĩ đó là lựa chọn duy nhất thực sự.

---

http://entityframework.codeplex.com/
SqlCeMigrationSqlGenerator
Can we use EF migrations with MySql

Answer 2

Mặc dù bài đã được mở trong một thời gian dài, tôi sẽ đăng những gì tôi đã làm dựa trên những gì bạn của chúng tôi NSGaga xuất hiện.

Tôi đã quản lý để tạo lớp "MigrationSqLiteGenerator", dựa trên những gì đã được phát triển cho SQLCE. Mã của lớp quá lớn, có thể tải xuống trên blog của tôi.

Trên Google Drive: https://drive.google.com/file/d/0B-NCqWnMQpBrQjkxMkxnVlRzb00/view?usp=sharing

Lớp này chỉ có những điều cơ bản, cộng là một điểm khởi đầu để cải thiện.

22.Mar.2017 CHỈNH SỬA theo @shiva: Đây là mã nội tuyến do đó nếu liên kết Google Drive bị hỏng lần nữa, bạn vẫn có thể truy cập mã. Chỉ cần tìm ra SO có giới hạn ký tự 30,000 trong các bài trả lời, vì vậy tôi phải xóa các chú thích trong mã.Nó đã kết thúc 32,000 nhân vật với ý kiến ​​:)

//   *-----------------------------------------------------------------* 
//   *                 * 
//   * CRIADO POR...: Julio C. Borges.        * 
//   * DATA.........: 19/07/2013.         * 
//   * MOTIVO.......:            * 
//   *                 * 
//   *-----------------------------------------------------------------* 

using System; 
using System.CodeDom.Compiler; 
using System.Collections.Generic; 
using System.Data.Common; 
using System.Data.Entity.Migrations.Model; 
using System.Data.Entity.Migrations.Sql; 
using System.Data.Metadata.Edm; 
using System.Data.SQLite; 
using System.Globalization; 
using System.IO; 
using System.Linq; 
using System.Text; 

namespace ICM_Conexao.SqLite.Classes 
{ 
    /// <sumary> 
    /// MigrationSqLiteGenerator 
    /// </sumary> 
    public class MigrationSqLiteGenerator : MigrationSqlGenerator 
    { 
     #region Constantes 

     private const string pstrDefaultDateTime = "yyyy-MM-dd hh:mm:ss"; 
     private const int pintDefaultStringMaxLength = 255; 
     private const int pintDefaultPrecisaoNumerica = 10; 
     private const byte pbytDefaultPrecisaoTempo = 7; 
     private const byte pintDefaultEscala = 0; 
     //private const string pstrNomeTabelaMigration = "__MigrationHistory"; 

     #endregion 

     #region Instancias 

     private DbProviderManifest pprovProviderManifest; 
     private List<MigrationStatement> plstComandos; 
     private bool pblnGerouPrimaryKey; 

     #endregion 

     #region Método de Geração sobrescrito de MigratioSqlGenerator 

     public override IEnumerable<MigrationStatement> Generate(
      IEnumerable<MigrationOperation> lstOperacoesMigrations, string strManifestoProvider) 
     { 
      plstComandos = new List<MigrationStatement>(); 

      InicializaServicosProvider(strManifestoProvider); 
      GeraComandos(lstOperacoesMigrations); 

      return plstComandos; 
     } 

     #endregion 

     #region Métodos de geração dos comandos 

     protected virtual void Generate(CreateTableOperation opeCriacaoTabela) 
     { 
      // Preferencialmente não iremos gerar a tabela de dados do Migration 
      if (opeCriacaoTabela.Name.Contains("MigrationHistory")) 
       return; 

      using (var ltextWriter = TextWriter()) 
      { 
       GeraComandoCriacaoTabela(opeCriacaoTabela, ltextWriter); 

       ComandoSQL(ltextWriter); 
      } 
     } 

     protected virtual void Generate(AddForeignKeyOperation opeChaveEstrangeira) 
     { 
      // Inicialmente não havera a criação de chave estrangeira 
     } 

     protected virtual void Generate(DropForeignKeyOperation dropForeignKeyOperation) 
     { 
      // Inicalmente não haverá a criação de chave estrangeira 
     } 

     protected virtual void Generate(CreateIndexOperation opeCriacaoIndex) 
     { 
      using (var ltextWriter = TextWriter()) 
      { 
       ltextWriter.Write("CREATE "); 

       if (opeCriacaoIndex.IsUnique) 
        ltextWriter.Write(" UNIQUE "); 

       ltextWriter.Write("INDEX "); 
       ltextWriter.Write(opeCriacaoIndex.Name); 
       ltextWriter.Write(" ON "); 
       ltextWriter.Write(RemoveDBO(opeCriacaoIndex.Table)); 
       ltextWriter.Write("("); 

       for (int lintCount = 0; lintCount < opeCriacaoIndex.Columns.Count; lintCount++) 
       { 
        var lstrDadosColuna = opeCriacaoIndex.Columns[lintCount]; 

        ltextWriter.Write(lstrDadosColuna); 

        if (lintCount < opeCriacaoIndex.Columns.Count - 1) 
         ltextWriter.WriteLine(","); 
       } 

       ltextWriter.Write(")"); 

       ComandoSQL(ltextWriter); 
      } 
     } 

     protected virtual void Generate(DropIndexOperation opeDropIndex) 
     { 
      using (var ltextWriter = TextWriter()) 
      { 
       ltextWriter.Write("DROP INDEX "); 
       ltextWriter.Write(opeDropIndex.Name); 

       ComandoSQL(ltextWriter); 
      } 
     } 

     protected virtual void Generate(AddPrimaryKeyOperation opeAdicionaPrimaryKey) 
     { 
      using (var ltextWriter = TextWriter()) 
      { 
       ltextWriter.Write("ALTER TABLE "); 
       ltextWriter.Write(RemoveDBO(opeAdicionaPrimaryKey.Table)); 
       ltextWriter.Write(" ADD CONSTRAINT "); 
       ltextWriter.Write(opeAdicionaPrimaryKey.Name); 
       ltextWriter.Write(" PRIMARY KEY "); 
       ltextWriter.Write("("); 

       for (int li = 0; li < opeAdicionaPrimaryKey.Columns.Count; li++) 
       { 
        var lstrDadosColuna = opeAdicionaPrimaryKey.Columns[li]; 

        ltextWriter.Write(lstrDadosColuna); 

        if (li < opeAdicionaPrimaryKey.Columns.Count - 1) 
         ltextWriter.WriteLine(","); 
       } 

       ltextWriter.Write(")"); 

       ComandoSQL(ltextWriter); 
      } 
     } 

     protected virtual void Generate(DropPrimaryKeyOperation opeDropPrimaryKey) 
     { 
      using (var ltextWriter = TextWriter()) 
      { 
       ltextWriter.Write("ALTER TABLE "); 
       ltextWriter.Write(RemoveDBO(opeDropPrimaryKey.Table)); 
       ltextWriter.Write(" DROP CONSTRAINT "); 
       ltextWriter.Write(opeDropPrimaryKey.Name); 

       ComandoSQL(ltextWriter); 
      } 
     } 

     protected virtual void Generate(AddColumnOperation opeAdicionaColuna) 
     { 
      using (var ltextWriter = TextWriter()) 
      { 
       ltextWriter.Write("ALTER TABLE "); 
       ltextWriter.Write(RemoveDBO(opeAdicionaColuna.Table)); 
       ltextWriter.Write(" ADD "); 

       var lcmColuna = opeAdicionaColuna.Column; 

       Generate(lcmColuna, ltextWriter, null); 

       if ((lcmColuna.IsNullable != null) 
        && !lcmColuna.IsNullable.Value 
        && (lcmColuna.DefaultValue == null) 
        && (string.IsNullOrWhiteSpace(lcmColuna.DefaultValueSql)) 
        && !lcmColuna.IsIdentity 
        && !lcmColuna.IsTimestamp 
        && !lcmColuna.StoreType.Equals("rowversion", StringComparison.InvariantCultureIgnoreCase) 
        && !lcmColuna.StoreType.Equals("timestamp", StringComparison.InvariantCultureIgnoreCase)) 
       { 
        ltextWriter.Write(" DEFAULT "); 

        if (lcmColuna.Type == PrimitiveTypeKind.DateTime) 
        { 
         ltextWriter.Write(Generate(DateTime.Parse("1900-01-01 00:00:00", CultureInfo.InvariantCulture))); 
        } 
        else 
        { 
         ltextWriter.Write(Generate((dynamic)lcmColuna.ClrDefaultValue)); 
        } 
       } 

       ComandoSQL(ltextWriter); 
      } 
     } 

     protected virtual void Generate(DropColumnOperation opeRemoveColuna) 
     { 
      using (var ltextWriter = TextWriter()) 
      { 
       ltextWriter.Write("ALTER TABLE "); 
       ltextWriter.Write(RemoveDBO(opeRemoveColuna.Table)); 
       ltextWriter.Write(" DROP COLUMN "); 
       ltextWriter.Write(opeRemoveColuna.Name); 

       ComandoSQL(ltextWriter); 
      } 
     } 

     protected virtual void Generate(AlterColumnOperation opeAlteraColuna) 
     { 
      var lcmColuna = opeAlteraColuna.Column; 

      using (var ltextWriter = TextWriter()) 
      { 
       ltextWriter.Write("ALTER TABLE "); 
       ltextWriter.Write(RemoveDBO(opeAlteraColuna.Table)); 
       ltextWriter.Write(" ALTER COLUMN "); 
       ltextWriter.Write(lcmColuna.Name); 
       ltextWriter.Write(" "); 
       ltextWriter.Write(ConstruirTipoColuna(lcmColuna)); 

       if ((lcmColuna.IsNullable != null) 
        && !lcmColuna.IsNullable.Value) 
       { 
        ltextWriter.Write(" NOT NULL"); 
       } 

       ComandoSQL(ltextWriter); 
      } 

      if ((lcmColuna.DefaultValue == null) && string.IsNullOrWhiteSpace(lcmColuna.DefaultValueSql)) 
       return; 

      using (var ltextWriter = TextWriter()) 
      { 
       ltextWriter.Write("ALTER TABLE "); 
       ltextWriter.Write(RemoveDBO(opeAlteraColuna.Table)); 
       ltextWriter.Write(" ALTER COLUMN "); 
       ltextWriter.Write(lcmColuna.Name); 
       ltextWriter.Write(" DROP DEFAULT"); 

       ComandoSQL(ltextWriter); 
      } 

      using (var ltextWriter = TextWriter()) 
      { 
       ltextWriter.Write("ALTER TABLE "); 
       ltextWriter.Write(RemoveDBO(opeAlteraColuna.Table)); 
       ltextWriter.Write(" ALTER COLUMN "); 
       ltextWriter.Write(lcmColuna.Name); 
       ltextWriter.Write(" SET DEFAULT "); 
       ltextWriter.Write(
        (lcmColuna.DefaultValue != null) 
         ? Generate((dynamic)lcmColuna.DefaultValue) 
         : lcmColuna.DefaultValueSql 
        ); 

       ComandoSQL(ltextWriter); 
      } 
     } 

     protected virtual void Generate(DropTableOperation opeDropTable) 
     { 
      using (var ltextWriter = TextWriter()) 
      { 
       ltextWriter.Write("DROP TABLE "); 
       ltextWriter.Write(RemoveDBO(opeDropTable.Name)); 

       ComandoSQL(ltextWriter); 
      } 
     } 

     protected virtual void Generate(SqlOperation opeSQL) 
     { 
      ComandoSQL(opeSQL.Sql, opeSQL.SuppressTransaction); 
     } 

     protected virtual void Generate(RenameColumnOperation opeRenomearColuna) 
     { 
      // Inicialmente não suportada 
     } 

     protected virtual void Generate(RenameTableOperation opeRenameTable) 
     { 
     } 

     protected virtual void Generate(MoveTableOperation opeMoveTable) 
     { 
     } 

     private void Generate(ColumnModel cmDadosColuna, IndentedTextWriter textWriter, PrimaryKeyOperation opePrimaryKey) 
     { 
      textWriter.Write(cmDadosColuna.Name); 
      textWriter.Write(" "); 
      bool lblnEhPrimaryKey = false; 

      if (opePrimaryKey != null) 
       lblnEhPrimaryKey = opePrimaryKey.Columns.Contains(cmDadosColuna.Name); 


      if (lblnEhPrimaryKey) 
      { 
       if ((cmDadosColuna.Type == PrimitiveTypeKind.Int16) || 
        (cmDadosColuna.Type == PrimitiveTypeKind.Int32)) 
        textWriter.Write(" INTEGER "); 
       else 
        textWriter.Write(ConstruirTipoColuna(cmDadosColuna)); 

       if (cmDadosColuna.IsIdentity) 
       { 
        textWriter.Write(" PRIMARY KEY AUTOINCREMENT "); 
        pblnGerouPrimaryKey = true; 
       } 
      } 
      else 
      { 
       textWriter.Write(ConstruirTipoColuna(cmDadosColuna)); 

       if ((cmDadosColuna.IsNullable != null) 
        && !cmDadosColuna.IsNullable.Value) 
       { 
        textWriter.Write(" NOT NULL"); 
       } 

       if (cmDadosColuna.DefaultValue != null) 
       { 
        textWriter.Write(" DEFAULT "); 
        textWriter.Write(Generate((dynamic)cmDadosColuna.DefaultValue)); 
       } 
       else if (!string.IsNullOrWhiteSpace(cmDadosColuna.DefaultValueSql)) 
       { 
        textWriter.Write(" DEFAULT "); 
        textWriter.Write(cmDadosColuna.DefaultValueSql); 
       } 
      } 
     } 

     protected virtual void Generate(HistoryOperation opeHistorico) 
     { 
      // Foi removido, pois atualmente não usaremos o Migration 
      //using (var ltextWriter = TextWriter()) 
      //{ 
      // if (opeHistorico is InsertHistoryOperation) 
      // { 
      //  InsertHistoryOperation lhisOperacaoInsert = opeHistorico as InsertHistoryOperation; 
      //  ltextWriter.Write(" INSERT INTO "); 
      //  ltextWriter.Write(pstrNomeTabelaMigration); 
      //  ltextWriter.Write(" (MigrationId, Model, ProductVersion) VALUES "); 
      //  ltextWriter.Write(string.Format(" ('{0}', {1}, '{2}')", 
      //   lhisOperacaoInsert.MigrationId, 
      //   Generate(lhisOperacaoInsert.Model), lhisOperacaoInsert.ProductVersion)); 
      // } 
      // else if (opeHistorico is DeleteHistoryOperation) 
      // { 
      //  DeleteHistoryOperation lhisOperacaoInsert = opeHistorico as DeleteHistoryOperation; 
      //  ltextWriter.Write(" DELETE FROM "); 
      //  ltextWriter.Write(pstrNomeTabelaMigration); 
      //  ltextWriter.Write(string.Format(" WHERE MigrationId = '{0}'", 
      //   lhisOperacaoInsert.MigrationId)); 
      // } 

      // ComandoSQL(ltextWriter); 
      //} 
     } 

     protected virtual string Generate(byte[] bytDefaultValue) 
     { 
      var lstrbHexString = new StringBuilder(); 

      foreach (var lbtByte in bytDefaultValue) 
       lstrbHexString.Append(lbtByte.ToString("X2", CultureInfo.InvariantCulture)); 

      return "x'" + lstrbHexString + "'"; 
     } 

     protected virtual string Generate(bool blnDefaultValue) 
     { 
      return blnDefaultValue ? "1" : "0"; 
     } 

     protected virtual string Generate(DateTime dtmDefaultValue) 
     { 
      return "'" + dtmDefaultValue.ToString(pstrDefaultDateTime, CultureInfo.InvariantCulture) + "'"; 
     } 

     protected virtual string Generate(DateTimeOffset dtfDefaultValue) 
     { 
      return "'" + dtfDefaultValue.ToString(pstrDefaultDateTime, CultureInfo.InvariantCulture) + "'"; 
     } 

     protected virtual string Generate(Guid guidDefaultValue) 
     { 
      return "'" + guidDefaultValue + "'"; 
     } 

     protected virtual string Generate(string strDefaultValue) 
     { 
      return "'" + strDefaultValue + "'"; 
     } 

     protected virtual string Generate(TimeSpan tsDefaultValue) 
     { 
      return "'" + tsDefaultValue + "'"; 
     } 

     protected virtual string Generate(object objDefaultValue) 
     { 
      return string.Format(CultureInfo.InvariantCulture, "{0}", objDefaultValue); 
     } 

     #endregion 

     #region Métodos auxiliares 

     protected virtual string ConstruirTipoColuna(ColumnModel cmModeloColuna) 
     { 
      return cmModeloColuna.IsTimestamp ? "rowversion" : ConstruirTipoPropriedade(cmModeloColuna); 
     } 

     private string ConstruirTipoPropriedade(ColumnModel propModeloPropriedade) 
     { 
      var lstrOriginalStoreTypeName = propModeloPropriedade.StoreType; 

      if (string.IsNullOrWhiteSpace(lstrOriginalStoreTypeName)) 
      { 
       var ltypeUsage = pprovProviderManifest.GetStoreType(propModeloPropriedade.TypeUsage).EdmType; 
       lstrOriginalStoreTypeName = ltypeUsage.Name; 
      } 

      var lstrStoreTypeName = lstrOriginalStoreTypeName; 

      const string lstrSufixoMax = "(max)"; 

      if (lstrStoreTypeName.EndsWith(lstrSufixoMax, StringComparison.Ordinal)) 
       lstrStoreTypeName = lstrStoreTypeName.Substring(0, lstrStoreTypeName.Length - lstrSufixoMax.Length) + lstrSufixoMax; 

      switch (lstrOriginalStoreTypeName.ToLowerInvariant()) 
      { 
       case "decimal": 
       case "numeric": 
        lstrStoreTypeName += "(" + (propModeloPropriedade.Precision ?? pintDefaultPrecisaoNumerica) 
            + ", " + (propModeloPropriedade.Scale ?? pintDefaultEscala) + ")"; 
        break; 
       case "datetime": 
       case "time": 
        lstrStoreTypeName += "(" + (propModeloPropriedade.Precision ?? pbytDefaultPrecisaoTempo) + ")"; 
        break; 
       case "blob": 
       case "varchar2": 
       case "varchar": 
       case "char": 
       case "nvarchar": 
       case "nvarchar2": 
        lstrStoreTypeName += "(" + (propModeloPropriedade.MaxLength ?? pintDefaultStringMaxLength) + ")"; 
        break; 
      } 

      return lstrStoreTypeName; 
     } 

     protected void ComandoSQL(string strInstrucaoSQL, bool blnSuprimeTransacao = false) 
     { 
      plstComandos.Add(new MigrationStatement 
      { 
       Sql = strInstrucaoSQL, 
       SuppressTransaction = blnSuprimeTransacao 
      }); 
     } 

     protected void ComandoSQL(IndentedTextWriter writer) 
     { 
      ComandoSQL(writer.InnerWriter.ToString()); 
     } 


     protected static IndentedTextWriter TextWriter() 
     { 
      return new IndentedTextWriter(new StringWriter(CultureInfo.InvariantCulture)); 
     } 

     private static string RemoveDBO(string strTexto) 
     { 
      return strTexto.Replace("dbo.", string.Empty); 
     } 

     private void GeraComandos(IEnumerable<MigrationOperation> lstOperacoesMigrations) 
     { 
      foreach (dynamic ldynOperacao in lstOperacoesMigrations) 
       Generate(ldynOperacao); 
     } 


     private void InicializaServicosProvider(string strManifestoProvider) 
     { 
      using (var lconConexao = CreateConnection()) 
      { 
       pprovProviderManifest = DbProviderServices 
        .GetProviderServices(lconConexao) 
        .GetProviderManifest(strManifestoProvider); 
      } 
     } 

     protected virtual DbConnection CreateConnection() 
     { 
      return new SQLiteConnection(); 
     } 

     private void GeraComandoCriacaoTabela(CreateTableOperation opeCriacaoTabela, IndentedTextWriter textWriter) 
     { 

      textWriter.WriteLine("CREATE TABLE " + RemoveDBO(opeCriacaoTabela.Name) + " ("); 
      textWriter.Indent++; 

      for (int i = 0; i < opeCriacaoTabela.Columns.Count; i++) 
      { 
       ColumnModel lcmDadosColuna = opeCriacaoTabela.Columns.ToList()[i]; 
       Generate(lcmDadosColuna, textWriter, opeCriacaoTabela.PrimaryKey); 

       if (i < opeCriacaoTabela.Columns.Count - 1) 
        textWriter.WriteLine(","); 
      } 

      if ((opeCriacaoTabela.PrimaryKey != null) && !pblnGerouPrimaryKey) 
      { 
       textWriter.WriteLine(","); 
       textWriter.Write("CONSTRAINT "); 
       textWriter.Write(RemoveDBO(opeCriacaoTabela.PrimaryKey.Name)); 
       textWriter.Write(" PRIMARY KEY "); 
       textWriter.Write("("); 

       for (int li = 0; li < opeCriacaoTabela.PrimaryKey.Columns.Count; li++) 
       { 
        var lstrNomeColuna = opeCriacaoTabela.PrimaryKey.Columns[li]; 

        textWriter.Write(lstrNomeColuna); 

        if (li < opeCriacaoTabela.PrimaryKey.Columns.Count - 1) 
         textWriter.WriteLine(","); 
       } 

       textWriter.WriteLine(")"); 
      } 
      else 
      { 
       textWriter.WriteLine(); 
      } 

      textWriter.Indent--; 
      textWriter.Write(")"); 
     } 

     #endregion 

    } 
} 

Answer 3

Tôi nghĩ chúng ta có thể sử dụng cùng một khái niệm Android để thực hiện một động cơ di cư đơn giản cho SQLite. Điều này post cho thấy khái niệm đó. Tất nhiên chúng tôi không có bất kỳ MigrationSqlGenerator làm việc nhưng khái niệm đó là đáng tin cậy und hữu ích.

Answer 4

Tôi không biết về SQLite, nhưng nếu bạn cố tạo một cái như những người khác đã đề xuất, bạn có thể sử dụng dự án nguồn mở này để bắt đầu. Hoặc bạn có thể thấy điều này sẽ đủ cho riêng mình?

http://www.codeproject.com/Articles/32977/Upgrade-framework-for-SQLite-databases

Answer 5

Đối với những ai đang tìm kiếm một máy phát điện để xử lý di cư cũng Tôi tìm thấy một gói NuGet tại https://sqliteef6migrations.codeplex.com gọi là "System.Data.SQLite.EF6.Migrations".

Sau khi bạn đã cài đặt gói, bạn sẽ cần thực hiện các thay đổi sau đối với Phương thức cấu hình di chuyển.

public Configuration() 
{ 
    AutomaticMigrationsEnabled = false; 
    SetSqlGenerator("System.Data.SQLite", new SQLiteMigrationSqlGenerator()); 
} 

Lớp hoàn chỉnh sẽ trông giống như thế này.

namespace YourNamespace 
{ 
    using System.Data.Entity.Migrations; 
    using System.Data.SQLite.EF6.Migrations; 

    internal sealed class Configuration : DbMigrationsConfiguration<YourContext> 
    { 
     public Configuration() 
     { 
      AutomaticMigrationsEnabled = false; 
      SetSqlGenerator("System.Data.SQLite", new SQLiteMigrationSqlGenerator()); 
     } 

     protected override void Seed(YourContext context) 
     { 
      // This method will be called after migrating to the latest version. 
     } 
    } 
}