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:
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...
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.
Comparte este post: