Se você já teve e/ou tem bastante vivência com a linguagem T-SQL e hoje se depara com o um software que tenha um ORM para fazer as transações com o banco de dados, pode ser que aparecem algumas dúvidas sobre como “converter” uma querie T-SQL na “linguagem” que o ORM entende.
Se você se deparar com essa situação e tiver alguma dúvida quanto a alguma consulta que precisa converter, esse post é destinado a você.
Nesse post vamos utilizar o Entity Framework como ORM e a linguagem LINQ to Entities que permite aos desenvolvedores escreverem consultas nesse modelo usando VB ou C#.
Abaixo segue o modelo que utilizei para facilitar o entendimento das consultas.
SELECT COM UM TOP
T-SQL: SELECT TOP 2 Nome FROM Artista;
LINQ: var result = (from a in context.Artista select a.Nome).Take(2);
LAMBDA: var result = context.Artista.Select(a => a.Nome).Take(2);
SELECT COM UM WHERE
T-SQL: SELECT Nome FROM Artista WHERE Nome = ‘Led Zeppelin’;
LINQ: var result = (from a in context.Artista
where a.Nome.Equals(“Led Zeppelin”)
select a.Nome).ToList();
LAMBDA: var result = context.Artista
.Where(a => a.Nome.Equals(“Led Zeppelin”))
.Select(a => a.Nome).ToList();
SELECT COM UM INNER JOIN
T-SQL: SELECT a.Nome, al.Titulo FROM Artista a
INNER JOIN Album al ON al.ArtistaId = a.ArtistaId;
LINQ: var result = (from a in context.Artista
join al in context.Album on a.ArtistaId equals al.ArtistaId
select new
{
a.Nome,
al.Titulo
}).ToList();
LAMBDA: var result = context.Artista
.Join(context.Album, artista => artista.ArtistaId, album => album.ArtistaId,
(artista, album) => new { Artista = artista, Album = album })
.Select(a => new {
Nome = a.Artista.Nome,
Titulo = a.Album.Titulo
}).ToList();
SELECT COM DUAS CONDIÇÕES NO MESMO INNER JOIN
T-SQL: SELECT DISTINCT a.Nome, al.Titulo FROM Artista a
INNER JOIN Album al ON al.ArtistaId = a.ArtistaId AND al.Titulo = a.Nome;
LINQ: var result = (from a in context.Artista
join al in context.Album on
new { C1 = a.ArtistaId, C2 = a.Nome } equals
new { C1 = al.ArtistaId, C2 = al.Titulo }
select new
{
a.Nome,
al.Titulo
}).ToList();
LAMBDA: var result = context.Artista
.Join(context.Album, artista => new { C1 = artista.ArtistaId, C2 = artista.Nome },
album => new { C1 = album.ArtistaId, C2 = album.Titulo },
(artista, album) => new { Artista = artista, Album = album })
.Select(a => new {
Nome = a.Artista.Nome,
Titulo = a.Album.Titulo
}).ToList();
SELECT COM DOIS INNER JOINS
T-SQL: SELECT a.Nome, al.Titulo, f.Nome FROM Artista a
INNER JOIN Album al ON al.ArtistaId = a.ArtistaId
INNER JOIN Faixa f ON f.AlbumId = al.AlbumId;
LINQ: var result = (from a in context.Artista
join al in context.Album on a.ArtistaId equals al.ArtistaId
join f in context.Faixa on al.AlbumId equals f.AlbumId
select new
{
Artista = a.Nome,
Album = al.Titulo,
Faixa = f.Nome
}).ToList();
LAMBDA: var result = context.Artista
.Join(context.Album, artista => artista.ArtistaId, album => album.ArtistaId,
(artista, album) => new { Artista = artista, Album = album })
.Join(context.Faixa, album => album.Album.AlbumId, faixa => faixa.AlbumId,
(album, faixa) => new { Album = album, Faixa = faixa })
.Select(a => new {
Nome = a.Album.Artista.Nome,
Titulo = a.Album.Album.Titulo,
Faixa = a.Faixa.Nome
}).ToList();
SELECT COM UM LEFT JOIN
T-SQL: SELECT a.Nome, al.Titulo FROM Artista a
LEFT JOIN Album al ON al.ArtistaId = a.ArtistaId;
LINQ: var result = (from a in context.Artista
join al in context.Album on a.ArtistaId equals al.ArtistaId
into All from al in All.DefaultIfEmpty()
select new
{
a.Nome,
al.Titulo
}).ToList();
LAMBDA: var result = context.Artista
.GroupJoin(context.Album, artista => artista.ArtistaId, album => album.ArtistaId,
(artista, album) => new { Artista = artista, Album = album.DefaultIfEmpty() })
.SelectMany(a => a.Album, (a, album) => new {
a.Artista.Nome,
album.Titulo
}).ToList();
SELECT COM DOIS LEFT JOINS, GROUP BY e COUNT
T-SQL: SELECT DISTINCT a.Nome, (SELECT COUNT(*) AS Album FROM Album WHERE ArtistaId = a.ArtistaId) AS Album,
COUNT(f.FaixaId) AS Faixa
FROM Artista a
LEFT JOIN Album al ON al.ArtistaId = a.ArtistaId
LEFT JOIN Faixa f ON f.AlbumId = al.AlbumId
GROUP BY a.Nome, a.ArtistaId;
LINQ: var result = (from a in context.Artista
join al in context.Album on a.ArtistaId equals al.ArtistaId
into All1 from al in All1.DefaultIfEmpty()
join f in context.Faixa on al.AlbumId equals f.AlbumId
into All2
from f in All2.DefaultIfEmpty()
group a by a into grouped
let totalAlbuns = grouped.Key.Album.Count()
let totalFaixas = grouped.Count(x => x.Album.Count > 0)
select new
{
Artista = grouped.Key.Nome,
Albuns = totalAlbuns,
Faixas = totalFaixas
}).ToList();
LAMBDA: var result = context.Artista
.GroupJoin(context.Album, artista => artista.ArtistaId, album => album.ArtistaId,
(artista, album) => album.Select(x => new {
Artista = artista,
Album = x
})
.DefaultIfEmpty(new {
Artista = artista,
Album = (Albuns)null
}))
.SelectMany(x => x)
.GroupJoin(context.Faixa,
album => album.Album.AlbumId,
faixa => faixa.Album.AlbumId,
(album, faixa) => faixa.Select(y => new {
Artista = album.Artista,
Album = album.Album,
Faixa = y
})
.DefaultIfEmpty(new {
Artista = album.Artista,
Album = album.Album,
Faixa = (Faixas)null
}))
.SelectMany(y => y)
.GroupBy(grouped => new { grouped.Artista })
.Select(g => new
{
Artista = g.Key.Artista.Nome,
Albuns = g.Key.Artista.Album.Count(),
Faixas = g.Count(x => x.Album.Faixa.Count > 0)
}).ToList();
Como vocês puderam ver a ideia desse artigo foi de ser o mais direto ao ponto possível. Obviamente, é impossivel cobrir todos os cenários possíveis de se fazer consultas T-SQL, então tentei colocar desde um exemplo simples até um exemplo um pouco mais complexo.
Espero que tenham gostado e até a próxima.