resetting preloaded parents on update doesnt happen if parent is nil

[tom-carscan]

Elixir version

1.18.3

Database and Version

PostgreSQL 14.15

Ecto Versions

3.13.2

Database Adapter and Versions (postgrex, myxql, etc)

postgrex 0.21.1

Current behavior

Ecto.Repo.Schema

defp reset_parent?(changes, data, assoc) do
    %{field: field, owner_key: owner_key, related_key: related_key} = assoc

    with %{^owner_key => owner_value} <- changes,
         %{^field => %{^related_key => related_value}} when owner_value != related_value <- data do
      true
    else
      _ -> false
    end
  end

This function is used to check if preloaded parents need to be reset when you change the id the child is associated to. but this does not work if the preloaded association was empty.

To reproduce this:

Let's say you have a Child which has a parent_id that refers to Parent. So the schema for Child would have a belongs_to(Parent)

By default you will have something like this if you were to look at a Child

%Child{ parent_id: 2, parent: #Ecto.Association.NotLoaded<association :parent is not loaded> }

you can use ecto to preload that association which would give the following:

%Child{ parent_id: 2, parent: %Parent{id: 2} }

If you were to use this child with preloaded parent in an update statement like this:

%Child{ parent_id: 2, parent: %Parent{id: 2} } |> Child.changeset(%{parent_id: 3}) |> My.Repo.update()

Then the result would be:

%Child{ parent_id: 3, parent: #Ecto.Association.NotLoaded<association :parent is not loaded> }

Because the reset_parent? function would notice that the parent_id (3) does not the id in the parent (which is still 2 from the preload) which then resets that.

So far so good.

Now the problem:

If we do this same thing with a Child that does not have a parent:

%Child{ parent_id: nil, parent: #Ecto.Association.NotLoaded<association :parent is not loaded> }

So we preload it

%Child{ parent_id: nil, parent: nil }

And then change this

%Child{ parent_id: nil, parent: nil } |> Child.changeset(%{parent_id: 3}) |> My.Repo.update()

then the result is

%Child{ parent_id: 3, parent: nil }

Because it cannot match the part in the reset_parent? function where he checks if the id's are different.
This also causes the preload functions to not work for this because it has already been preloaded, it just contains the old (empty) value.

Expected behavior

I would expect the association to be reset in this case even if it started from nil.

[josevalim]

Thank you for the report. Can you please provide a script that reproduces those steps or a failing test? Whatever works best for you. Thank you!

[tom-carscan]

I'm unfamiliar with how to do this properly, especially without including way too much code for all of the context stuff and the test and the support fixtures for the tests and.......
so i tried making it compact like this.
for database you would just need a children table which has a parent_id that can be nil
and a parents table which has a name

defmodule Parent do
  use Ecto.Schema

  schema "parents" do
    field(:name, :string)
  end

  def changeset(parent, attrs) do
    cast(parent, attrs, [:name])
  end
end

defmodule Child do
  use Ecto.Schema

  schema "children" do
    belongs_to(:parent, Parent)
  end

  def changeset(child, attrs) do
    cast(child, attrs, [:parent_id])
  end
end

defmodule Family.Script do
  def test do
    {:ok, parent} =
      %Parent{}
      |> Parent.changeset(%{name: "test"})
      |> My.Repo.insert()

    {:ok, child} =
      %Child{}
      |> Child.changeset(%{parent_id: nil})
      |> My.Repo.insert()

    child = My.Repo.preload(child, [:parent])
    IO.inspect("these should both be nil")
    IO.inspect(child.parent_id)
    IO.inspect(child.parent)
    IO.inspect("--------")

    {:ok, updated_child} = child |> Child.changeset(%{parent_id: parent.id}) |> My.Repo.update()
    IO.inspect("these should be the id of the parent (not nil) and a 'not loaded' parent because it was reset after the update")
    IO.inspect(updated_child.parent_id)
    IO.inspect(updated_child.parent)
  end