Schema与迁移 #

defmodule Hello.Accounts.User do
  use Ecto.Schema

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

  schema "users" do
    field :email, :string
    field :name, :string
    field :age, :integer
    field :active, :boolean, default: true
    field :bio, :string
    field :settings, :map, default: %{}
    field :tags, {:array, :string}, default: []

    timestamps(type: :utc_datetime)
  end
end

schema "users" do
  field :email, :string
  field :name, :string, default: "Anonymous"
  field :age, :integer, default: 0
  field :password, :string, virtual: true
  field :metadata, :map, default: %{}
  field :scores, {:array, :integer}, default: []
  field :inserted_at, :naive_datetime
  field :updated_at, :naive_datetime
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
    embeds_many :phone_numbers, Hello.Accounts.PhoneNumber
  end
end

mix ecto.gen.migration create_users

defmodule Hello.Repo.Migrations.CreateUsers do
  use Ecto.Migration

  def change do
    create table(:users) do
      add :email, :string, null: false
      add :name, :string
      add :age, :integer
      add :active, :boolean, default: true
      add :bio, :text

      timestamps()
    end

    create unique_index(:users, [:email])
    create index(:users, [:name])
  end
end

mix ecto.migrate
mix ecto.rollback
mix ecto.reset

def change do
  create table(:users) do
    add :email, :string, null: false
    add :name, :string
    add :age, :integer
    timestamps()
  end
end

def change do
  drop table(:users)
end

def change do
  alter table(:users) do
    add :phone, :string
    modify :name, :string, null: false
    remove :age
  end
end

def change do
  rename table(:users), :email, to: :email_address
end

create table(:users) do
  add :email, :string, null: false
  add :name, :string, default: "Anonymous"
  add :age, :integer, default: 0
  add :uuid, :binary_id, primary_key: true
  add :price, :decimal, precision: 10, scale: 2
  add :tags, {:array, :string}, default: []
end

def change do
  create index(:users, [:name])
  create unique_index(:users, [:email])
  create index(:users, [:name, :email])
end

def change do
  create index(:users, [:email],
    where: "active = true"
  )
end

def change do
  drop index(:users, [:name])
end

create table(:comments) do
  add :post_id, references(:posts, on_delete: :delete_all)
  add :user_id, references(:users, on_delete: :nilify_all)
  add :body, :text

  timestamps()
end

create constraint(:users, :price_must_be_positive, check: "price >= 0")

defmodule Hello.Blog.Comment do
  use Ecto.Schema

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

defmodule Hello.Blog.Post do
  use Ecto.Schema

  schema "posts" do
    field :title, :string
    field :body, :text
    has_many :comments, Hello.Blog.Comment
    belongs_to :author, Hello.Accounts.User
  end
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.Blog.Post do
  use Ecto.Schema

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

def change do
  create table(:users) do
    add :email, :string
  end
end

def up do
  execute "CREATE EXTENSION IF NOT EXISTS citext"

  alter table(:users) do
    modify :email, :citext
  end
end

def down do
  alter table(:users) do
    modify :email, :string
  end
end

def up do
  alter table(:users) do
    add :full_name, :string
  end

  flush()

  from(u in User, select: u)
  |> Repo.all()
  |> Enum.each(fn user ->
    full_name = "#{user.first_name} #{user.last_name}"
    Repo.update_all(from(u in User, where: u.id == ^user.id),
      set: [full_name: full_name]
    )
  end)

  alter table(:users) do
    remove :first_name
    remove :last_name
  end
end

mix phx.gen.schema Accounts User users email:string name:string age:integer

mix phx.gen.html Accounts User users email:string name:string

mix phx.gen.json Accounts User users email:string name:string

mix phx.gen.live Accounts User users email:string name:string

defmodule Hello.Accounts do
  alias Hello.Repo
  alias Hello.Accounts.User

  def list_users, do: Repo.all(User)

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

  def create_user(attrs) do
    %User{}
    |> User.changeset(attrs)
    |> Repo.insert()
  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

  def change_user(%User{} = user, attrs \\ %{}) do
    User.changeset(user, attrs)
  end
end

lib/hello/
├── accounts/
│   ├── accounts.ex      # Context模块
│   ├── user.ex          # User Schema
│   └── user_token.ex    # UserToken Schema
└── blog/
    ├── blog.ex          # Context模块
    ├── post.ex          # Post Schema
    └── comment.ex       # Comment Schema