Ecto简介 #

Ecto架构
├── Repository
│   ├── 数据库连接
│   ├── 事务管理
│   └── 基础CRUD
├── Schema
│   ├── 数据模型
│   ├── 字段定义
│   └── 关联关系
├── Changeset
│   ├── 数据验证
│   ├── 类型转换
│   └── 错误处理
└── Query
    ├── 查询构建
    ├── 条件过滤
    └── 关联预加载

defmodule Hello.Repo do
  use Ecto.Repo,
    otp_app: :hello,
    adapter: Ecto.Adapters.Postgres
end

config :hello, Hello.Repo,
  username: "postgres",
  password: "postgres",
  hostname: "localhost",
  database: "hello_dev",
  pool_size: 10

defmodule Hello.Application do
  use Application

  def start(_type, _args) do
    children = [
      Hello.Repo
    ]

    Supervisor.start_link(children, strategy: :one_for_one)
  end
end

def create_user(attrs \\ %{}) do
  %User{}
  |> User.changeset(attrs)
  |> Repo.insert()
end

def list_users do
  Repo.all(User)
end

def get_user!(id), do: Repo.get!(User, id)

def get_user(id), do: Repo.get(User, id)

def get_user_by_email(email) do
  Repo.get_by(User, email: email)
end

def update_user(%User{} = user, attrs) do
  user
  |> User.changeset(attrs)
  |> Repo.update()
end

def delete_user(%User{} = user) do
  Repo.delete(user)
end

defmodule Hello.Accounts.User do
  use Ecto.Schema

  schema "users" do
    field :email, :string
    field :name, :string
    field :age, :integer
    field :active, :boolean, default: true
    field :bio, :string

    timestamps()
  end
end

schema "users" do
  field :id, :binary_id, primary_key: true
  field :email, :string
end

@primary_key {:id, :binary_id, autogenerate: true}
@foreign_key_type :binary_id

schema "users" do
  field :email, :string
end

defmodule Hello.Accounts.User do
  use Ecto.Schema
  import Ecto.Changeset

  schema "users" do
    field :email, :string
    field :name, :string
    field :password, :string, virtual: true
    field :hashed_password, :string

    timestamps()
  end

  def changeset(user, attrs) do
    user
    |> cast(attrs, [:email, :name])
    |> validate_required([:email, :name])
    |> validate_format(:email, ~r/@/)
    |> unique_constraint(:email)
  end

  def registration_changeset(user, attrs) do
    user
    |> changeset(attrs)
    |> cast(attrs, [:password])
    |> validate_required([:password])
    |> validate_length(:password, min: 8)
    |> put_hashed_password()
  end

  defp put_hashed_password(changeset) do
    case get_change(changeset, :password) do
      nil -> changeset
      password -> put_change(changeset, :hashed_password, hash_password(password))
    end
  end
end

cast(struct, params, allowed_fields)

changeset
|> validate_required([:email, :name])
|> validate_format(:email, ~r/@/)
|> validate_length(:name, min: 2, max: 100)
|> validate_number(:age, greater_than: 0)
|> validate_inclusion(:status, ["active", "inactive"])
|> validate_exclusion(:role, ["admin"])
|> unique_constraint(:email)
|> foreign_key_constraint(:post_id)

import Ecto.Query

def list_active_users do
  from(u in User, where: u.active == true)
  |> Repo.all()
end

def list_users_ordered do
  from(u in User, order_by: [desc: u.inserted_at])
  |> Repo.all()
end

def search_users(name) do
  from(u in User, where: ilike(u.name, ^"%#{name}%"))
  |> Repo.all()
end

def get_users_by_age(min, max) do
  from(u in User, where: u.age >= ^min and u.age <= ^max)
  |> Repo.all()
end

def list_user_names do
  from(u in User, select: u.name)
  |> Repo.all()
end

def list_user_summaries do
  from(u in User, select: %{id: u.id, name: u.name, email: u.email})
  |> Repo.all()
end

def list_users_paginated(page, per_page) do
  offset = (page - 1) * per_page

  from(u in User,
    order_by: [desc: u.inserted_at],
    limit: ^per_page,
    offset: ^offset
  )
  |> Repo.all()
end

def transfer_money(from_id, to_id, amount) do
  Repo.transaction(fn ->
    from_account = Repo.get!(Account, from_id)
    to_account = Repo.get!(Account, to_id)

    {:ok, _} = update_balance(from_account, from_account.balance - amount)
    {:ok, _} = update_balance(to_account, to_account.balance + amount)
  end)
end

def create_user_with_profile(attrs) do
  Ecto.Multi.new()
  |> Ecto.Multi.insert(:user, User.changeset(%User{}, attrs))
  |> Ecto.Multi.insert(:profile, fn %{user: user} ->
    Profile.changeset(%Profile{user_id: user.id}, attrs)
  end)
  |> Repo.transaction()
end

def complex_operation(attrs) do
  Ecto.Multi.new()
  |> Ecto.Multi.insert(:user, User.changeset(%User{}, attrs))
  |> Ecto.Multi.run(:account, fn repo, %{user: user} ->
    create_account(repo, user)
  end)
  |> Ecto.Multi.update(:stats, fn %{user: user} ->
    update_user_stats(user)
  end)
  |> Repo.transaction()
  |> case do
    {:ok, result} -> {:ok, result.user}
    {:error, :user, changeset, _} -> {:error, changeset}
    {:error, :account, error, _} -> {:error, error}
  end
end

defmodule Hello.Blog.Post do
  use Ecto.Schema

  schema "posts" do
    field :title, :string
    field :body, :string
    has_many :comments, Hello.Blog.Comment
  end
end

defmodule Hello.Blog.Comment do
  use Ecto.Schema

  schema "comments" do
    field :body, :string
    belongs_to :post, Hello.Blog.Post
  end
end

defmodule Hello.Blog.Post do
  use Ecto.Schema

  schema "posts" do
    field :title, :string
    many_to_many :tags, Hello.Blog.Tag, join_through: "posts_tags"
  end
end

defmodule Hello.Blog.Tag do
  use Ecto.Schema

  schema "tags" do
    field :name, :string
    many_to_many :posts, Hello.Blog.Post, join_through: "posts_tags"
  end
end

def list_posts_with_comments do
  from(p in Post, preload: [:comments])
  |> Repo.all()
end

def get_post_with_comments!(id) do
  Repo.get!(Post, id) |> Repo.preload(:comments)
end

def count_users do
  from(u in User, select: count(u.id))
  |> Repo.one()
end

def count_active_users do
  from(u in User, where: u.active == true, select: count(u.id))
  |> Repo.one()
end

def average_age do
  from(u in User, select: avg(u.age))
  |> Repo.one()
end

def total_posts do
  from(p in Post, select: sum(p.view_count))
  |> Repo.one()
end

def posts_count_by_author do
  from(p in Post,
    group_by: p.author_id,
    select: {p.author_id, count(p.id)}
  )
  |> Repo.all()
end