CheersThankYou

Ecto Embedded Schema always register change with changeset

I have an embedded schema, and I noticed that it was always writing to the DB, even when it wasn’t updated from its default value [].

Checking with changeset, it appears to always register it as a change. Where am I going wrong with this?

You can test this in debug using the example:

defmodule Order do
  use Ecto.Schema

  schema "orders" do
    embeds_many :items, Item
  end
end

defmodule Item do
  use Ecto.Schema

  embedded_schema do
    field :title
  end
end

# create a blank changeset
order = %Order{}
orderChange = Ecto.Changeset.change(order)

orderChange |> Ecto.Changeset.put_change(:items, [])

I’ve tried this with a regular blank map, but it only appears to be occurring with an embedded_schema. I feel like I’m missing something obvious here.

7 comments

#ecto #changesets #embeds_many #embedded_schema

0 4618 7

2020-08-28 16:28:55 UTC

First Post!

dimitarvp

If you change this:

embeds_many :items, Item

to this:

embeds_many :items, Item, default: []

…is the problem still there?

Post #1

Most Liked

CheersThankYou

You can replicate the code in my original example in an IEX interactive shell.

I’ve done some more playing about with it in iex and here is the process I took:

defmodule Order do
  use Ecto.Schema

  schema "orders" do
    embeds_many :items, Item, on_replace: :delete #added on_replace to allow manipulation
  end
end

defmodule Item do
  use Ecto.Schema

  embedded_schema do
    field :title
  end
end

With zero items attached to the order:

order = %Order{}
changesetWithNoItems = Ecto.Changeset.change(order)

changesetWithNoItems.data
%Order{__meta__: #Ecto.Schema.Metadata<:built, "orders">, id: nil, items: []}

# this doesn't make sens
changesetWithNoItems |> Ecto.Changeset.put_change(:items, [])
#Ecto.Changeset<
  action: nil,
  changes: %{items: []},
  errors: [],
  data: #Order<>,
  valid?: true
>

# Makes sense
changesetWithNoItems |> Ecto.Changeset.put_change(:items, nil)
#Ecto.Changeset<
  action: nil,
  changes: %{},
  errors: [items: {"is invalid", [type: {:array, :map}]}],
  data: #Order<>,
  valid?: false
>

# Makes sense 
changesetWithNoItems |> Ecto.Changeset.put_change(:items, [%Item{id: 1, title: "test"}])
#Ecto.Changeset<
  action: nil,
  changes: %{
    items: [
      #Ecto.Changeset<action: :insert, changes: %{}, errors: [], data: #Item<>,
       valid?: true>
    ]
  },
  errors: [],
  data: #Order<>,
  valid?: true
>

Then with an order that has a single item attached:


order = %Order{items: [%Item{id: 1, title: "what"}]}
changesetWithItem = Ecto.Changeset.change(order)

changesetWithItem.data 
%Order{
  __meta__: #Ecto.Schema.Metadata<:built, "orders">,
  id: nil,
  items: [%Item{id: 1, title: "what"}]
}

# Makes sense
changesetWithItem |> Ecto.Changeset.put_change(:items, [%Item{id: 1, title: "what"}])
#Ecto.Changeset<action: nil, changes: %{}, errors: [], data: #Order<>,
 valid?: true>

# Doesn't make sense
 changesetWithItem |> Ecto.Changeset.put_change(:items, [%Item{id: 1, title: "huh"}]) 
#Ecto.Changeset<action: nil, changes: %{}, errors: [], data: #Order<>,
 valid?: true>

# confirming
 (changesetWithItem |> Ecto.Changeset.put_change(:items, [%Item{id: 1, title: "huh"}])).data
%Order{
  __meta__: #Ecto.Schema.Metadata<:built, "orders">,
  id: nil,
  items: [%Item{id: 1, title: "what"}]
}

# Doesn't make sense
changesetWithItem |> Ecto.Changeset.put_change(:items, [%Item{id: 2, title: "huh"}])
#Ecto.Changeset<
  action: nil,
  changes: %{
    items: [
      #Ecto.Changeset<action: :replace, changes: %{}, errors: [], data: #Item<>,
       valid?: true>,
      #Ecto.Changeset<action: :insert, changes: %{}, errors: [], data: #Item<>,
       valid?: true>
    ]
  },
  errors: [],
  data: #Order<>,
  valid?: true
>

# Confirming
((changesetWithItem |> Ecto.Changeset.put_change(:items, [%Item{id: 1, title: "huh"}, %Item{id: 2, title: "something new"}])).changes.items |> hd).data
%Item{id: 1, title: "huh"}

Post #4

Last Post!

Adzz

I think this bit:

# this doesn't make sens
changesetWithNoItems |> Ecto.Changeset.put_change(:items, [])
#Ecto.Changeset<
  action: nil,
  changes: %{items: []},
  errors: [],
  data: #Order<>,
  valid?: true
>

Makes sense because you are effectively telling Ecto to delete all the relations (or embeds in this case). Meaning it is always a change I think.

I also think you shouldn’t use put_change but should use cast_embed or put_embed for embeds, that may be the source of the confusion.

Post #7