Associations et schémas intégrés

Linking Your Data Together

One User, Many Posts

Coding `has_many` and `belongs_to`

defmodule MyApp.User do
  use Ecto.Schema
  schema "users" do
    field :name, :string
    has_many :posts, MyApp.Post # A user has many posts

    timestamps()
  end
end

defmodule MyApp.Post do
  use Ecto.Schema
  schema "posts" do
    field :title, :string
    field :content, :string
    belongs_to :user, MyApp.User # A post belongs to one user

    timestamps()
  end
end

Working with Linked Records

defmodule MyScript do
  # Mock schemas for demonstration (assuming they are defined)
  defmodule User do
    defstruct [:id, :name, :posts]
  end
  defmodule Post do
    defstruct [:id, :title, :content, :user_id]
  end

  def run do
    IO.puts "--- Demonstrating One-to-Many ---"
    # Simulate creating a user
    user = %User{id: 1, name: "Alice"}
    IO.inspect user, label: "Created User"

    # Simulate creating posts linked to the user
    post1 = %Post{id: 101, title: "My First Post", content: "Hello world!", user_id: user.id}
    post2 = %Post{id: 102, title: "Elixir Fun", content: "Learning Elixir!", user_id: user.id}

    # In a real app, you'd use Repo.insert! and Repo.preload
    # To show the concept of preloading, we manually add posts to the user struct
    user_with_posts = %{user | posts: [post1, post2]}

    IO.inspect user_with_posts, label: "User with preloaded posts"
  end
end

MyScript.run()

Multiple Connections: `many_to_many`

Coding `many_to_many`

defmodule MyApp.Student do
  use Ecto.Schema
  schema "students" do
    field :name, :string
    many_to_many :courses, MyApp.Course, join_through: MyApp.Enrollment

    timestamps()
  end
end

defmodule MyApp.Course do
  use Ecto.Schema
  schema "courses" do
    field :title, :string
    many_to_many :students, MyApp.Student, join_through: MyApp.Enrollment

    timestamps()
  end
end

defmodule MyApp.Enrollment do
  use Ecto.Schema
  schema "enrollments" do
    # These are foreign keys to Student and Course
    belongs_to :student, MyApp.Student
    belongs_to :course, MyApp.Course

    timestamps()
  end
end

Accessing Many-to-Many Links

defmodule MyScript.Many do
  # Mock schemas for demonstration
  defmodule Student do
    defstruct [:id, :name, :courses]
  end
  defmodule Course do
    defstruct [:id, :title, :students]
  end
  defmodule Enrollment do
    defstruct [:id, :student_id, :course_id]
  end

  def run do
    IO.puts "--- Demonstrating Many-to-Many ---"
    # Simulate creating a student and courses
    student1 = %Student{id: 1, name: "Maria"}
    courseA = %Course{id: 101, title: "Elixir Basics"}
    courseB = %Course{id: 102, title: "Phoenix Framework"}

    # Simulate enrollments (join table entries)
    _enrollment1 = %Enrollment{student_id: student1.id, course_id: courseA.id}
    _enrollment2 = %Enrollment{student_id: student1.id, course_id: courseB.id}

    # Simulate preloading courses for student1
    student1_with_courses = %{student1 | courses: [courseA, courseB]}

    IO.inspect student1_with_courses, label: "Student with preloaded courses"
  end
end

MyScript.Many.run()

Data Within Data: Embedded Schemas

Coding Embedded Schemas

defmodule MyScript.Embed do
  defmodule Address do
    use Ecto.Schema
    @primary_key false # Embedded schemas don't have their own primary key
    @foreign_key_type :binary_id # Or false if no ID needed at all
    schema "addresses" do # Table name is ignored for embeds
      field :street, :string
      field :city, :string
      field :zip_code, :string
    end
  end

  defmodule Profile do
    use Ecto.Schema
    schema "profiles" do
      field :username, :string
      embeds_one :address, MyScript.Embed.Address, on_replace: :delete # Embeds one address

      timestamps()
    end
  end

  def run do
    IO.puts "--- Demonstrating Embedded Schemas ---"
    # Create a profile with an embedded address
    profile_changeset =
      Ecto.Changeset.change(%Profile{}, %{username: "john_doe"})
      |> Ecto.Changeset.put_embed(:address, %{
        street: "123 Main St",
        city: "Anytown",
        zip_code: "12345"
      })

    # In a real app: Repo.insert!(profile_changeset)
    # Simulate the resulting struct
    profile_with_address = %Profile{
      id: 1,
      username: "john_doe",
      address: %Address{street: "123 Main St", city: "Anytown", zip_code: "12345"}
    }

    IO.inspect profile_with_address, label: "Profile with embedded address"
  end
end

MyScript.Embed.run()

Check Your Understanding

Associations & Embeds: Key Takeaways