关联关系 #

User (用户)
├── has_one: Profile (个人资料)
├── has_many: Posts (文章)
├── has_many: Comments (评论)
└── many_to_many: Roles (角色)

Post (文章)
├── belongs_to: Author (作者/用户)
├── has_many: Comments (评论)
└── many_to_many: Tags (标签)

defmodule Hello.Blog.Post do
  use Ecto.Schema

  schema "posts" do
    field :title, :string
    field :body, :text
    belongs_to :author, Hello.Accounts.User
  end
end

create table(:posts) do
  add :title, :string
  add :body, :text
  add :author_id, references(:users, on_delete: :delete_all)

  timestamps()
end

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

def create_post(attrs, user) do
  %Post{author_id: user.id}
  |> Post.changeset(attrs)
  |> Repo.insert()
end

defmodule Hello.Accounts.User do
  use Ecto.Schema

  schema "users" do
    field :email, :string
    has_one :profile, Hello.Accounts.Profile
  end
end

defmodule Hello.Accounts.Profile do
  use Ecto.Schema

  schema "profiles" do
    field :bio, :string
    field :location, :string
    belongs_to :user, Hello.Accounts.User
  end
end

create table(:profiles) do
  add :bio, :text
  add :location, :string
  add :user_id, references(:users, on_delete: :delete_all)

  timestamps()
end

def get_user_with_profile(id) do
  Repo.get!(User, id) |> Repo.preload(:profile)
end

def create_profile(user, attrs) do
  %Profile{user_id: user.id}
  |> Profile.changeset(attrs)
  |> Repo.insert()
end

defmodule Hello.Accounts.User do
  use Ecto.Schema

  schema "users" do
    field :email, :string
    has_many :posts, Hello.Blog.Post
    has_many :comments, Hello.Blog.Comment
  end
end

defmodule Hello.Blog.Post do
  use Ecto.Schema

  schema "posts" do
    field :title, :string
    belongs_to :author, Hello.Accounts.User
    has_many :comments, Hello.Blog.Comment
  end
end

def get_user_posts(user_id) do
  Repo.get!(User, user_id)
  |> Repo.preload(:posts)
  |> Map.get(:posts)
end

def list_posts_by_user(user_id) do
  from(p in Post, where: p.author_id == ^user_id)
  |> Repo.all()
end

defmodule Hello.Blog.Post do
  use Ecto.Schema

  schema "posts" do
    field :title, :string
    field :body, :text
    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

create table(:posts_tags, primary_key: false) do
  add :post_id, references(:posts, on_delete: :delete_all)
  add :tag_id, references(:tags, on_delete: :delete_all)
end

create unique_index(:posts_tags, [:post_id, :tag_id])

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

def add_tag_to_post(post, tag) do
  post
  |> Repo.preload(:tags)
  |> Ecto.Changeset.change()
  |> Ecto.Changeset.put_assoc(:tags, [tag | post.tags])
  |> Repo.update()
end

def sync_tags(post, tags) do
  post
  |> Repo.preload(:tags)
  |> Ecto.Changeset.change()
  |> Ecto.Changeset.put_assoc(:tags, tags)
  |> Repo.update()
end

defmodule Hello.Accounts.Address do
  use Ecto.Schema

  embedded_schema do
    field :street, :string
    field :city, :string
    field :zip, :string
    field :country, :string
  end
end

defmodule Hello.Accounts.User do
  use Ecto.Schema

  schema "users" do
    field :email, :string
    embeds_one :address, Hello.Accounts.Address
  end
end

create table(:users) do
  add :email, :string
  add :address, :map

  timestamps()
end

def create_user_with_address(attrs) do
  %User{}
  |> User.changeset(attrs)
  |> Ecto.Changeset.cast_embed(:address, with: &Address.changeset/2)
  |> Repo.insert()
end

def update_address(user, address_attrs) do
  user
  |> Ecto.Changeset.change()
  |> Ecto.Changeset.put_embed(:address, address_attrs)
  |> Repo.update()
end

defmodule Hello.Accounts.PhoneNumber do
  use Ecto.Schema

  embedded_schema do
    field :type, :string
    field :number, :string
  end
end

defmodule Hello.Accounts.User do
  use Ecto.Schema

  schema "users" do
    field :email, :string
    embeds_many :phone_numbers, Hello.Accounts.PhoneNumber
  end
end

def list_posts_with_author do
  Repo.all(Post) |> Repo.preload(:author)
end

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

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

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

def list_posts_with_recent_comments do
  from(p in Post,
    preload: [
      comments: from(c in Comment,
        where: c.inserted_at > ago(7, "day"),
        order_by: [desc: c.inserted_at]
      )
    ]
  )
  |> Repo.all()
end

def create_post_with_author(attrs, user) do
  %Post{}
  |> Post.changeset(attrs)
  |> Ecto.Changeset.put_assoc(:author, user)
  |> Repo.insert()
end

def add_comment_to_post(post, comment_attrs) do
  comment_changeset = Ecto.Changeset.change(%Comment{}, comment_attrs)

  post
  |> Repo.preload(:comments)
  |> Ecto.Changeset.change()
  |> Ecto.Changeset.put_assoc(:comments, [comment_changeset | post.comments])
  |> Repo.update()
end

defmodule Hello.Blog.Post do
  use Ecto.Schema
  import Ecto.Changeset

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

  def changeset(post, attrs) do
    post
    |> cast(attrs, [:title])
    |> cast_assoc(:comments)
  end
end

defmodule Hello.Blog.Post do
  use Ecto.Schema

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

def posts_by_author_name(name) do
  from(p in Post,
    join: u in assoc(p, :author),
    where: ilike(u.name, ^"%#{name}%")
  )
  |> Repo.all()
end

def users_with_posts_count do
  from(u in User,
    left_join: p in assoc(u, :posts),
    group_by: u.id,
    select: {u, count(p.id)}
  )
  |> Repo.all()
end

def posts_with_comments_ordered do
  from(p in Post,
    preload: [comments: ^from(c in Comment, order_by: [desc: c.inserted_at])]
  )
  |> Repo.all()
end