Add an error under an error key (a column, an association, or a synthetic key like base), marking the changeset invalid. The key is a plain string because errors attach to more than just columns; for a typed column use field.name(person_email()).

Set the action and return the row only if the changeset is valid; otherwise return the accumulated errors (mirrors apply_action/2).

Merge changes onto data and rebuild the typed row, regardless of validity (mirrors Ecto.Changeset.apply_changes/1).

Cast params into changes, keeping only permitted fields and validating each against its field type. Unknown/absent params are skipped; cast failures add an is invalid error.

Params are keyed by field name; the recorded changes are keyed by the field’s column source (which defaults to the name), so changes line up with the column-keyed maps dump produces and the adapters consume — a with_source rename works end-to-end.

Build child changesets from a list of param maps and stage them for writing (Ecto’s cast_assoc(..., with:)). data is the base record new children are built from; with turns each param map into a child changeset (typically a cast). If any child changeset is invalid the parent is marked invalid, with an is invalid error on the association plus each invalid child’s own errors re-keyed "<name>.<field>" (tagged association/child_index).

changeset.change(post, post_schema()) |> changeset.cast_assoc( name: “comments”, data: Comment(0, 0, 0, “”, None), params: comment_params, with: fn(c, p) { changeset.cast(c, comment_schema(), p, [“body”]) }, )

cast_assoc with id-based matching (Ecto’s default): each param map whose key_param (e.g. "id") equals an existing child’s child_key casts that child — an update preserving its other columns — while a param with no match casts blank (an insert). Existing children matched by no param are left to the association’s on_replace policy when the parent is written. Pass the currently-loaded children as existing (e.g. from a preload). Invalid children mark the parent invalid exactly like cast_assoc (association-level is invalid plus "<name>.<field>" child errors, child_index counting params order).

Start an empty changeset over data (no changes, valid).

Convert a database ConstraintError into a ChangesetInvalid when the changeset declared a constraint with the same database name — mirroring how Ecto turns a constraint violation into {:error, changeset} with a field error (e.g. "has already been taken") ready for form rendering. Returns None when no declared constraint matches, so the repo propagates the raw ConstraintError. Used by repo.insert/repo.update. The many_to_many join-table twin is association.join_constraint.

Map an exclusion-constraint violation (Postgres EXCLUDE) to a field error (Ecto’s exclusion_constraint).

A pending change for a field, if any (does not fall back to data).

The effective value of a field: a pending change if present, else the value from data. None if absent or NULL.

Map a foreign-key violation triggered by still-associated rows to a field error (Ecto’s no_assoc_constraint) — e.g. deleting a parent that a child still references. The name is the child’s foreign-key constraint.

Apply an optimistic lock on field (Ecto’s optimistic_lock/3): the current version is read from the changeset’s data, repo.update / repo.delete_changeset add WHERE <field> = <current> to the write, and an update also SETs <field> = <current> + 1. When another writer got there first the version no longer matches, zero rows are affected, and the write returns Error(error.StaleEntry) — Ecto’s raised Ecto.StaleEntryError as a Result.

The field must be an integer column with a value in data (give it a database default, e.g. 1); anything else marks the changeset invalid. The incrementer is a fixed + 1.

changeset.change(post, post_schema()) |> changeset.put_change_typed(field.field(“title”), primitive.string(), t) |> changeset.optimistic_lock(field.field(“lock_version”))

Stage child rows to be written for a named association when the parent changeset is inserted/updated (Ecto’s put_assoc). The association must be registered on the parent schema as writable (has_many/has_one); the children are erased and persisted by the repo after the parent is saved, honoring the association’s on_replace policy.

If any staged child changeset is invalid, the repo write fails with ChangesetInvalid before any child row is written: every invalid child’s errors are re-keyed "<name>.<field>" and tagged with association and child_index (its 0-based position in children) metadata.

changeset.change(post, post_schema()) |> changeset.put_assoc(“comments”, [ changeset.change(Comment(..), comment_schema()), ])

Put a raw Value change directly under a column key (no casting, no name-to-source mapping). Prefer put_change_typed.

Put a typed change, casting through the given LodeType and recording an error on failure. Like cast, the change is stored under the field’s column source.

Set the Postgres schema prefix for writes built from this changeset (Ecto’s struct-meta prefix). repo.insert/repo.update then render the table as "<schema>"."<table>". Apply it when building the changeset, or inline at the call site to override.

Reorder and filter child param maps before cast_assoc (Ecto’s :sort_param / :drop_param). Identify each param by its key_param value; drop removes params whose key is listed, and sort lists keys in the desired order (params whose key isn’t in sort, including brand-new ones, keep their relative order after the sorted ones).

Validate that the field was changed to true (mirrors Ecto.Changeset.validate_acceptance/3 — terms-of-service checkboxes). Only a change counts: an absent or false value is rejected. The field is typically a schema.virtual_field of primitive.boolean().

Run a custom validation, returning a list of FieldErrors for the field.

Validate that a change matches its <field>_confirmation change (mirrors Ecto.Changeset.validate_confirmation/3). Declare the confirmation field on the schema — typically as a schema.virtual_field — and cast it, or the comparison never sees it. Like Ecto’s default, a missing confirmation is accepted; pair with validate_required([field <> "_confirmation"]) to insist on one.

Validate that a field’s value is NOT one of forbidden.

Validate that a string field’s pending change matches a regular expression (mirrors Ecto.Changeset.validate_format/4 — like Ecto, only a change is validated, never the existing data).

Validate that a field’s value is one of allowed.

Validate that a string field’s length is within optional min/max bounds. (For list fields, counts elements.)

Validate that a numeric field satisfies all given comparisons.

Require that each named field has a present, non-blank value.

Validate that every element of a list field is one of allowed (mirrors Ecto.Changeset.validate_subset/4).