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.

If you change this:

embeds_many :items, Item

to this:

embeds_many :items, Item, default: []

…is the problem still there?

I am not sure if that option is available while defining a schema. Though I can do that while creating a migration. Unfortunately I did try that before with add :items, {:array, :map} and it did not affect it.

Thanks for the input though

If you set up a skeleton GitHub project demonstrating the problem, I’ll try and help you further.

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"}
1 Like

I am getting nowhere with this so I opened a bug. I’ll update here if I get a response.

There’s no point supplying IDs if the structures are not persisted. Ecto will happily accept them without question in this case.