Ecto Embedded Schema always register change with changeset

CheersThankYou

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 4701 7

2020-08-28 16:28:55 UTC

Showing Posts 1 to 7

Show Best Posts
Show All (oldest first)
Show All (newest first)

dimitarvp

If you change this:

embeds_many :items, Item

to this:

embeds_many :items, Item, default: []

…is the problem still there?

Post #1

CheersThankYou

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

Post #2

dimitarvp

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

Post #3

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

CheersThankYou

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

Post #5

dimitarvp

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

Post #6

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

— All posts loaded —