El blog de Javier Torrecilla : WinForms, VS, SQL

DbMigration y Code First

Javier Torrecilla — Fri, 16 Mar 2012 08:54:00 GMT

Introducción

Una de las novedades que se introdujo con la versión 4.3 de Entity Framework son las llamadas Database Migration (DbMigration), que vienen a satisfacer las necesidades de los desarrolladores a la hora de realizar cambios en la estructura de la base de datos, como por ejemplo:

- Creación o borrado de Tablas.

- Cambiar o quitar columnas.

- entre otras cosas :)

La principal problemática venía a la hora de tener nuestra aplicación instalada en varios clientes y que tengan distintas versiones de Base de Datos.

Empezando

Para poder empezar a utilizar DbMigration es necesario que al “menos” tengamos instalada la versión 4.3.1(*) de Entity Framework, si no podremos instalarla desde nuget o desde la consola de comandos:

   1: Install-Package EntityFramework 

(*) Se encuentra en fase beta la version 5.0 de Entity Framework.

A continuación desde la consola de comandos, tendremos que especificar la habilitación de migraciones para nuestro proyecto, para ello ejecutaremos el comando “Enable-Migrations”.

Esta acción va a realizar los siguientes procesos:

- Va a buscar una clase dentro de nuestro proyecto que implemente la clase DBContext, para utilizar dicho contexto a la hora de definir las migraciones.

- Va a crear una nueva carpeta “Migrations” en nuestro proyecto. Esta carpeta va a contener los siguientes ficheros:

1. Clase Configuration.cs: Esta clase va a ser una implementación de la clase base genérica DbMigrationsConfiguration con nuestro objeto contexto.
  Dentro de ella, vamos a poder definir la configuración de la migración (en el constructor) y si hay que hacer algun proceso de llenado de información (método Seed).
2. Una Migración Inicial: va a definir una clase que implemente la clase Base DbMigration, donde tendremos el método Up con la creación de nuestras entidades, y el método Down con el borrado de las mismas. La implementación de las migraciones se realiza en dos partes, la primera es la que acabamos de ver, y la segunda es relativa a información que se va a almacenar en la Base de Datos.

- Va a crear una tabla dentro de nuestra Base de Datos llamada __MigrationHistory que va a almacenar información relativa a las migraciones.

¿Cómo crear una Migración?

Bien para crear una nueva migración desde la consola de comandos ejecutaremos la siguiente instrucción:

“Add-Migration Name”

Al ejecutarlo, se va a generar una nueva clase dentro de la carpeta Migrations, con una estructura similar a la mencionada anteriormente con la migración inicial.

Dentro de dicha clase vamos a tener que implementar los métodos Up, para subir de versión, y Down para bajar de versión.

¿Qué Métodos podemos utilizar en los métodos Up y Down?

AddColumn	AddForeignKey	AddPrimaryKey
AlterColumn	CreateIndex	CreateTable<T>
DropColumn	DropForeignKey	DropPrimaryKey
DropIndex	DropTable	MoveTable
RenameColumn	RenameTable	SQL

Ejemplo:

public partial class ProductMigration : DbMigration

    {

        public override void Up()

        {

            CreateTable("Products",

                columns => new

                {

                    ProductId = columns.Int(identity: true),

                    Name = columns.String(maxLength: 100),

                    Description = columns.String(),

                    Price = columns.Decimal(precision: 10, scale: 2)

                });

        }

        

        public override void Down()

        {

            DropTable("Products");

        }

    }

¿Cómo actualizar la Base de Datos?

Para poder ejecutar una migración tenemos dos posibles formas:

1) Desde la consola de Comandos:

A través del comando “Update-Database”. Los parámetros del comando son:

- SourceMigration <String>
- TargetMigration <String>
- Script [<SwitchParameter>]
- Force [<SwitchParameter>]
- ProjectName <String>
- StartUpProjectName <String>
- ConfigurationTypeName <String>
- ConnectionStringName <String>
- ConnectionString <String>
- ConnectionProviderName <String>

2) Desde código:

Definiremos un objeto del tipo Configuration, otro del tipo DbMigrator, y ejecutaremos el método Update:

var config = new Migrations.Configuration();

            var migrator = new DbMigrator(config);

            migrator.Update();

Esta acción va a ejecutar la actualización a la ultima versión de la Base de Datos. En el caso de desear ejecutar una migración concreta o volver a una versión determinada, ejecutaríamos de la siguiente manera:

var config = new Migrations.Configuration();

var migrator = new DbMigrator(config);

migrator.Update("201203140720163_InitialCreate");

Espero que os resulte de utilidad.

Saludos!

[ORM-Lite] Massive

Javier Torrecilla — Mon, 09 Jan 2012 09:55:13 GMT

Introducción

Hace unos días realice una entrada sobre Dapper un mini ORM, y como ya comente iba a realizar una serie sobre más ejemplos de ORM ligeros. En esta ocasión le ha tocado a Massive.

¿Qué es Massive?

Bien Massive es otro ORM ligero creado por Rob Conery(Blog y Twitter), que nos permite realizar consultas a una Base de datos y su explotación en un sistema a través de objetos Expando.

¿Por dónde empezar?

Para poder trabajar con Massive, tenemos dos posibilidades:

- Agregarlo como un paquete a nuestro proyecto desde Nuget (No es la ultima versión a fecha de hoy)

- Descargar el único fichero que genera desde GitHub.

Existe un fichero disponible para los siguientes tipos de Base de datos:

- Sql Server.

- Oracle.

- SQLLite.

- PostgreSQL.

Para este post vamos a utilizar el de SQL Server, y la misma tabla que vimos el otro día sobre “CandidateInfo”.

Algunos Ejemplos

Vamos a ver algunos ejemplos de la utilización de Massive dentro de un proyecto de .NET.

El primer paso, como decía antes, será agregar la clase de Massive a nuestro proyecto.

A continuación vamos a definir una clase que va servir para trabajar con la tabla CandidateInfo de nuestra Base de Datos:

        1: public class CandidateInfo : Massive.DynamicModel 

       2:  {

       3:     public CandidateInfo() : base("MyCV","CandidateInfo","CandidateId")

       4:     {

       5:          

       6:     }

       7:  }

Nuestra clase CandidateInfo va a heredar de la Clase DynamicModel, y vamos a hacer que se implemente el constructor base, indicándole los siguientes parámetros:

- Cadena de Conexión: conexión existente en el fichero de configuración de la aplicación que queremos utilizar.

- Nombre de la tabla que queremos utilizar.

- Campo clave de la tabla.

Una vez definida nuestra clase vamos a ver los propios ejemplos:

Consulta de Datos

Para realizar una simple consulta de datos, vamos a necesitar declarar un objeto del tipo de la clase anteriormente indicada:

       1: var candidateInfo = new App_Code.CandidateInfo();

Una vez definida nuestra tabla, vamos a obtener:

- Todos los resultados:

       1: var query = candidateInfo.All();

       2: foreach (var candidato in query)

       3: {

       4:     var dictionary = ObjectExtensions.ToDictionary(candidato);

       5:     foreach (var item in dictionary)

       6:     {

       7:         Console.WriteLine(String.Format("{0} : {1}", item.Key, item.Value));

       8:     }

       9: }

- Resultados Filtrados:

       1: var query = candidateInfo.All("CandidateName like '%a%'");

       2: foreach (var candidato in query)

       3: {

       4:     var dictionary = ObjectExtensions.ToDictionary(candidato);

       5:     foreach (var item in dictionary)

       6:     {

       7:         Console.WriteLine(String.Format("{0} : {1}", item.Key, item.Value));

       8:     }

       9: }

El Método All, dispone de los siguientes parámetros:

- Where: para realizar un filtro.

- Order: para establecer el orden de los resultados.

- Limit: Para establecer un Top de los resultados.

- Columnas: para indicar que columnas se van a establecer.

- Parámetros: se pueden establecer los valores del filtro como parámetros.

Todos los parámetros son opcionales.

Al tratarse de tipos anónimos podríamos realizar la siguiente consulta:

       1: var query =  candidateInfo.Query(

       2:                "Select CandidateName,CountryName from CandidateInfo inner join CountryInfo on CountryId=CandidateCountry");

       3:  

       4:            

       5:            foreach(var dato in query)

       6:            {

       7:  

       8:                var dictionary = ObjectExtensions.ToDictionary(dato);

       9:                foreach (var item in dictionary)

      10:                {

      11:                    Console.WriteLine(String.Format("{0} : {1}", item.Key, item.Value));

      12:                }

      13:            }

Como crear un nuevo registro:

       1: var dato = candidateInfo.Insert(new

       2:                              {

       3:                                  CandidateName = "Javier",

       4:                                  CandidateLastName = "Torrecilla",

       5:                                  CandidateBirthDate = DateTime.Now,

       6:                                  CandidateCountry = 1,

       7:                                  CandidateCity = 1,

       8:                                  CandidateEmail = "r@yahoo.es"

       9:                              });

Como realizar la eliminación de un registro:

   1:  int delete = candidateInfo.Delete(@where: "CandidateName =@0", args: "j");

Como realizar una actualización de un dato:

   1:   candidateInfo.Update(new {CandidateLastName = "Torrecilla Puertas"}, guid);

También existe la posibilidad de ejecutar una sentencia sql, un ojbeto DBCommand o una lista de DBCommand a través del método Execute.

Conclusiones

Massive, nos provee una forma bastante rápida de manejar nuestra Base de Datos, sin tener que escribir gran cantidad de código.

Nos da la flexibilidad que aporta dynamic y el trabajo con tipos anónimos.

Por otro lado, al ser un único fichero podemos realizar nuestras propias modificaciones, aunque nos salgamos de la línea definida por Rob.

El próximo post de la serie será acerca de PetaPoco