Introdução

Sejam bem-vindos, fico imensamente feliz com seu interesse em aprender um pouco mais sobre o Ecto e suas funcionalidades do modulo Ecto.Query para construir queries SQL

Vamos usar o projeto do post Introdução ao Ecto para brincarmos um pouco com as queries sql.

Recomendo ler o projeto anterior sobre Ecto para melhor compreensão.

Schemas utilizado para este projeto:

Módulo User

defmodule Ecto4noobs.User do
  use Ecto.Schema

  import Ecto.Changeset

  alias Ecto4noobs.Movie

  schema "users" do
    field(:name, :string)
    field(:email, :string)
    field(:age, :integer)

    belongs_to(:movie, Movie)
  end
end

Módulo Movie

defmodule Ecto4noobs.Movie do
  use Ecto.Schema

  import Ecto.Changeset

  alias Ecto4noobs.User

  schema "movies" do
    field(:title, :string)
    field(:director, :string)
    field(:year, :integer)

    has_many(:users, User)
  end
end

Relação Belongs To/Has Many

Vamos iniciar com dois schemas: User e Movie. Vamos implementar uma relação belongs_to/has_many entre os dois: Um filme tem vários (has many) usuários e um usuário pertence a (belongs to) um filme.

Schema Belongs To

Belongs To utiliza a chave estrangeira para tornar o filme associado a um usuário disponível quando executamos a consulta.

Schema Has Many

Has Many não adiciona dados ao banco de dados por si só. O que ela faz é utilizar uma chave estrangeira no schema associado (users).

Listando os filmes

from(m in Movie) |> Repo.all()

Se notarmos, veremos que temos a seguinte mensagem: NotLoadAssociation. Caso a gente queria listar os usuários juntamente aos filmes, apenas essa query não é o suficiente.

Para carregas as associações, faremos:

query = from(m in Movie, preload: [:users]) |> Repo.all()

Exemplos de query com filtros where:

Buscando os usuários com idade menos que 20.

query = from(u in User, where: u.age < 20)

U representa uma linha da tabela User e em seguida a gente passa a condição que queremos filtrar, que no caso queremos filtrar a idade que for menor que 20.

Antes de continuarmos vamos aprender um pouco sobre SQL JOIN

O que é um JOIN?

Bom, o join combina duas tabelas através de alguma chave ou valor comum entre elas.

Existem alguns tipos diferentes de JOIN:

• INNER JOIN: É um comando que permite a seleção de informações em diferentes tabelas, desde que a informação em questão seja compartilhada por ambas.

• LEFT JOIN: É um comando que retorna todos os registros da tabela à esquerda e os registros correspondentes da tabela à direita.

• RIGHT JOIN: Ao contrário do LEFT JOIN, o comando RIGHT JOIN retorna todos os dados encontrados na tabela à direita. Porém, se não tiver dados associados entre as tabelas esquerda e direita, ele retorna valores nulos.

Usando INNER JOIN

query = 
from(u in User, 
inner_join: m in Movie, 
on: u.movie_id == m.id, 
select: [m.title, u.name])

Neste exemplo, estamos buscando os filmes e o nome do usuário que cada um recebeu. Para isso, começamos a nossa query na tabela User, depois fazemos um inner_join na tabela de filmes e cujo a condição do ID do filme do usuário é igual ao ID do filme. Por fim, a gente faz a seleção dos campos que queremos mostrar.

Usando LEFT JOIN

query = 
from(m in Movie, 
left_join: u in User, 
on: u.movie_id == m.id, 
where: u.name == "Floki O Gato" and m.title == "Um Sonho de Liberdade", 
select: [m.title, u.name])

Neste exemplo, buscamos filmes que contém o usuário "Floki O Gato". Para isso, começamos a query na tabela Movie, depois fazemos um left_join na tabela User e cujo a condição do ID do filme do usuário é igual ao ID do filme eu busco por usuário "Floki O Gato" onde o titulo do filme é "Um Sonho de Liberdade". Por fim, a gente faz a seleção dos campos que queremos mostrar.

Usando LEFT EXCLUDING JOIN

Filmes que não tiveram nenhum usuário

Usando RIGHT JOIN

query = 
from(m in Movie, 
right_join: u in User, 
on: u.movie_id == m.id, 
select: [m.title, u.name])

Neste exemplo, estou buscando os filmes com o usuário que foi recebido.

Usando RIGHT EXCLUDING JOIN

Buscar os filmes com os usuário que cada um recebeu

query = 
from(m in Movie, 
right_join: u in User, 
on: u.movie_id == m.id, 
where: not is_nil(u.name), 
select: [m.title, u.name])

Fragment

Forma de chamar funções em SQL puro no Ecto

query = 
from(m in Movie, 
select: fragment("upper(?)", m.title))

Estamos fazendo uma listagem de títulos de filme em uppercase fragment(upper) que é uma função do Postgres.

OU

title = "O Poderoso Chefão"
query = from(m in Movie, 
where: m.title == ^title, 
select: fragment("upper(?)", m.title))

Quando queremos colocar um valor de uma variável dentro da querie a gente precisa colocar operador pinar (^) se não, dará erro de compilação.

LIKE

Forma de busca por campo de texto

title = "O"
query = 
from(m in Movie, 
where: like(m.title, ^"#{title}%"), 
select: fragment("upper(?)", m.title))

Filtrando títulos de filme que começam com a letra O.

Então, nesse nosso exemplo quero buscar os filmes que começam com O, então eu uso a função do Ecto LIKE passando o campo de texto que eu quero interpolar e o sinal de pinar, por fim o porcent % que é para dar match em qualquer termo.

E é isso! =)

Conclusão

Muito obrigado pela leitura até aqui e espero ter ajudado de alguma forma. Tem alguma sugestão ou encontrou algum problema? por favor deixe-me saber. 💜