Brincando com Ecto.Question – DEV Neighborhood

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

Vamos usar o projeto do submit 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 Consumer

defmodule Ecto4noobs.Consumer do
  use Ecto.Schema

  import Ecto.Changeset

  alias Ecto4noobs.Film

  schema "customers" do
    discipline(:title, :string)
    discipline(:electronic mail, :string)
    discipline(:age, :integer)

    belongs_to(:film, Film)
  finish
finish

Módulo Film

defmodule Ecto4noobs.Film do
  use Ecto.Schema

  import Ecto.Changeset

  alias Ecto4noobs.Consumer

  schema "films" do
    discipline(:title, :string)
    discipline(:director, :string)
    discipline(:yr, :integer)

    has_many(:customers, Consumer)
  finish
finish

Relação Belongs To/Has Many

Vamos iniciar com dois schemas: Consumer e Film. 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 (customers).

Listando os filmes

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

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

Para carregas as associações, faremos:

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

Exemplos de question com filtros the place:

Buscando os usuários com idade menos que 20.

question = from(u in Consumer, the place: u.age < 20)

U representa uma linha da tabela Consumer 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 be a part of 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

question = 
from(u in Consumer, 
inner_join: m in Film, 
on: u.movie_id == m.id, 
choose: [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 question na tabela Consumer, 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

question = 
from(m in Film, 
left_join: u in Consumer, 
on: u.movie_id == m.id, 
the place: u.title == "Floki O Gato" and m.title == "Um Sonho de Liberdade", 
choose: [m.title, u.name])

Neste exemplo, buscamos filmes que contém o usuário “Floki O Gato”. Para isso, começamos a question na tabela Film, depois fazemos um left_join na tabela Consumer 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

question = 
from(m in Film, 
right_join: u in Consumer, 
on: u.movie_id == m.id, 
choose: [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

question = 
from(m in Film, 
right_join: u in Consumer, 
on: u.movie_id == m.id, 
the place: not is_nil(u.title), 
choose: [m.title, u.name])

Fragment

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

question = 
from(m in Film, 
choose: fragment("higher(?)", m.title))

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

OU

title = "O Poderoso Chefão"
question = from(m in Film, 
the place: m.title == ^title, 
choose: fragment("higher(?)", 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"
question = 
from(m in Film, 
the place: like(m.title, ^"#{title}%"), 
choose: fragment("higher(?)", 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! =)

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. 💜