This Blog

Syndication

Search

Tags

Community

Email Notifications

Archives

Enlaces Recomendados

LINQPad: ¿Adios a SQL Server Management Studio?...Creo que no, pero...

Varios meses después de la última vez que escribimos sobre LINQ, hacía tiempo que tenía ganas de escribir sobre una utilidad (gratuita!) relacionada con LINQ y que no había podido probar hasta la semana pasada durante un descanso de uno de los seminarios del CIIN...y esta utilidad no es otra que LINQPad, el equivalente a SQL Server Management Studio para bases de datos de datos SQL Server Express, pero para LINQ To SQL puesto que esta utilidad solo funciona con bases de datos SQL Server. Según la página de su creador, además de permitirnos definir y probar nuestras consultas LINQ contra BD's SQL Server, también podremos hacerlo contra objetos (LINQ To Objects) o archivos XML (LINQ To XML). En este post os mostraré como de sencillo resulta probar nuestras consultas LINQ To SQL mediante LINQPad. Empecemos.

Conectándonos a una BD SQL Server

Nada más iniciar la aplicación (por cierto, es un simple archivo ejecutable que no tiene ningún requisito de instalación y que es autoactualizable...yo lo estoy ejecutando con una máquina virtual con Visual Studio 2008 RTM instalado y también con WSS 3.0), lo primero que podemos hacer es añadir una nueva conexión (al estilo de lo que ya conocemos de SQL Server Management Studio) para la que especificamos el servidor de BD, el modo de visualización, si vamos a atachar un archivo físico de base de datos, el tipo de autenticación,...vamos lo normal y conocido:

LINQPad1 LINQPad2 LINQPad3

Creando una consulta LINQ

Una vez conectados a la BD, a través de la correspondiente editor de consulta, podremos definir la correspondiente consulta LINQ. En este caso yo voy a definir una consulta LINQ sencilla sobre una BD compuesta únicamente por tres tablas (podéis ver el diagrama de base de datos correspondiente), de manera que al ejecutarla obtenemos el resultado esperado...

LINQPad4 LINQPad5

Nota: La consulta LINQ ejecutada es la siguiente (bastante sencilla como ya os comenté):

from c in MD_Clientes
    join ve in MD_ClienteVehiculos on
    c.ID_Cliente equals ve.ID_Cliente
    join v in MD_Vehiculos on
    ve.ID_Vehiculo equals v.ID_Vehiculo
    orderby c.ID_Cliente descending
    select new{NIF=c.ID_Cliente,Nombre=c.SNombre + " " + c.SApellidos,
        Dieccion=c.SDireccion, Coche=v.SMarca + " " + v.SModelo}

Como veis, en la consulta LINQ estoy utilizando algunas de las novedades en el lenguaje C# 3.0 que ya vimos en este post:

  • Inicializadores de objetos.
  • Operadores estándar de consulta.

Analizando la información que nos da LINQPad

Además de comprobar que la consulta LINQ definida devuelve los resultados esperados, LINQPad adicionalmente nos permite:

  • Visualizar las expresiones lambda sobre las que se asienta la consulta, y que en este caso genera el siguiente listado lleno de estas expresiones, inicializadores de objetos y métodos de extensión (los propios operadores estándar de consulta)

MD_Clientes
   .Join (
      MD_ClienteVehiculos,
      c => c.ID_Cliente,
      ve => ve.ID_Cliente,
      (c, ve) =>
         new 
         {
            c = c,
            ve = ve
         }
   )
   .Join (
      MD_Vehiculos,
      temp0 => temp0.ve.ID_Vehiculo,
      v => v.ID_Vehiculo,
      (temp0, v) =>
         new 
         {
            <>h__TransparentIdentifier0 = temp0,
            v = v
         }
   )
   .OrderByDescending (temp1 => temp1.<>h__TransparentIdentifier0.c.ID_Cliente)
   .Select (
      temp1 =>
         new 
         {
            NIF = temp1.<>h__TransparentIdentifier0.c.ID_Cliente,
            Nombre = ((temp1.<>h__TransparentIdentifier0.c.SNombre + " ") +
                  temp1.<>h__TransparentIdentifier0.c.SApellidos
               ),
            Dieccion = temp1.<>h__TransparentIdentifier0.c.SDireccion,
            Coche = ((temp1.v.SMarca + " ") + temp1.v.SModelo)
         }
   )

  • La consulta T-SQL que es enviada a la BD, y que como vimos en este post, es generada por el objeto data context, que es el auténtico interprete y traductor de las consultas LINQ a las correspondiente sintaxis T-SQL. En este caso, el correspondiente objeto data context ha generado la siguiente consulta:

SELECT [t0].[ID_Cliente] AS [NIF], ([t0].[sNombre] + @p0) +
[t0].[sApellidos] AS [Nombre], [t0].[sDireccion] AS [Dieccion],
([t2].[sMarca] + @p1) + [t2].[sModelo] AS [Coche]
FROM [MD_Clientes] AS [t0]
INNER JOIN [MD_ClienteVehiculo] AS [t1] ON
[t0].[ID_Cliente] = [t1].[ID_Cliente]
INNER JOIN [MD_Vehiculos] AS [t2] ON
[t1].[ID_Vehiculo] = [t2].[ID_Vehiculo]
ORDER BY [t0].[ID_Cliente] DESC

-- @p0: Input NVarChar (Size = 1; Prec = 0; Scale = 0) [ ]
-- @p1: Input NVarChar (Size = 1; Prec = 0; Scale = 0) [ ]
-- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 3.5.21022.8

¿Y que más...?

Además de servirnos como herramienta de pruebas para nuestras consultas LINQ, LINQPad viene con un montón de ejemplos precargados (más de 200) que aparecen en el libro C# 3.0 in a Nutshell de Joseph y Ben Albahari, autores de esta interesantísima herramienta. En la propia página de la herramienta tenéis disponible todos los listados de código que aparecen en dicho libro (me parece que habrá que echarle un vistazo profundo), así como un pequeño Quiz para demostrar lo que sabemos de C# 3.0.

Sin más, esto es lo que os quería contar sobre LINQPad...os animo a probarla, es realmente chula y pude darnos mucho juego para probar nuestras consultas LINQ.

Published 17/12/2007 23:54 por Juan Carlos González Martín

Archivado en: ,
Comparte este post:

Comentarios

# re: LINQPad: ¿Adios a SQL Server Management Studio?...Creo que no, pero...@ Tuesday, December 18, 2007 8:59 AM

Muchas gracias Juan Carlos, me ha parecido una estupenda utilidad.

La acabo de probar y me ha parecido muy muy muy útil. :-)

Un saludo

Jorge Serrano

# re: LINQPad: ¿Adios a SQL Server Management Studio?...Creo que no, pero...@ Tuesday, December 18, 2007 9:23 AM

Hola Jorge!

Pues sí, la herramienta es chula...lo que no he visto es como permite hacer consultas contra un XML u objetos...

JC's

Juan Carlos González Martín

# re: LINQPad: ¿Adios a SQL Server Management Studio?...Creo que no, pero...@ Tuesday, December 18, 2007 11:50 AM

Hola, Juan Carlos!

Para ejecutar consultas contra objetos, parece que hay crear una nueva consulta, indicar que Type es "C# statements" (si utilizas C#) y Database es "None". Entonces se puede teclear código C# en la ventana de la consulta, que la herramienta compila y ejecuta...

Por ejemplo, teclea esto:

string[] paises = { "España", "Cuba" };

foreach (string p in paises)

p.Dump ("Nombre: ");

¿Me permites que ponga un post en mi blog con lo que averigüe?

Saludos - Octavio

Octavio Hernández

# re: LINQPad: ¿Adios a SQL Server Management Studio?...Creo que no, pero...@ Tuesday, December 18, 2007 11:53 AM

Hola Octavio,

Eso ni se pregunta...je je, de hecho espero que lo pongas rápido...otra cosa que también me dejé en el tintero (por si lo quieres poner) es analizar el archivo que genera el LINQPad con la consulta definida.

Lo dicho, a ver con que nos sorprendes de esta utilidad tan chula.

JC's

Juan Carlos González Martín

# re: LINQPad: ¿Adios a SQL Server Management Studio?...Creo que no, pero...@ Wednesday, December 19, 2007 9:22 AM

Hola Espinete,

Ahora mismo creo que no existe algo similar para LINQ a lo que te da SQL para planificar y optimizar consultas. Básicamente, la idea es que si tu consulta está bien definida en tiempo de diseño (en VS), el motor de LINQ se encargará de traducirlo a la sentencia T-SQL adecuada para no penalizar el rendieminto de tu aplicación. Ya se han publicado numerosos posts sobre aspectos de rendimiento de LINQ y los resultados son francamente buenos:

Este es el artículo más interesante: visualstudiomagazine.com/.../article.aspx

www.singingeels.com/.../Improving_Performance_With_LINQ.aspx

blogs.msdn.com/.../dlinq-linq-to-sql-performance-part-1.aspx

www.davepeck.org/.../linq-collection-perf.html

De todos modos, queda apuntado el interés en un artículo que profundice sobre LINQ y rendimiento...que seguro que es algo que se va a preguntar mucho.

Saludos

JC

Juan Carlos González Martín

# VLINQ: Dise&ntilde;ador de consultas para LINQ To SQL! &laquo; Pasi??n por la tecnolog??a&#8230;@ Sunday, April 13, 2008 11:47 PM

PingBack desde  VLINQ: Dise&ntilde;ador de consultas para LINQ To SQL! &laquo; Pasi??n por la tecnolog??a&#8230;

VLINQ: Diseñador de consultas para LINQ To SQL! « Pasi??n por la tecnolog??a…