Ecto

https://ecto.hexdocs.pm/
Admin
Ecto is a powerful database wrapper and language integrated query (LIQ) for Elixir that provides a...
Tokens:319,675
Snippets:2,385
Trust Score:9
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### mappings/2 examples with schema

Source: https://ecto.hexdocs.pm/Ecto.Enum.md

Examples of calling mappings/2 with the example schema, showing the mappings for string and integer enums.

```elixir
Ecto.Enum.mappings(MySchema, :my_string_enum)
#=> [foo: "foo", bar: "bar", baz: "baz"]
```

```elixir
Ecto.Enum.mappings(MySchema, :my_integer_enum)
#=> [foo: 1, bar: 2, baz: 5]
```

--------------------------------

### all_by/3 examples

Source: https://ecto.hexdocs.pm/Ecto.Repo.md

Examples of using all_by/3 with a schema and with a query.

```elixir
MyRepo.all_by(Post, author_id: 1)
```

```elixir
query = from p in Post
MyRepo.all_by(query, author_id: 1)
```

--------------------------------

### apply_changes/1 example

Source: https://ecto.hexdocs.pm/Ecto.Changeset.md

Example showing apply_changes/1 returning the data with changes applied.

```elixir
iex> changeset = change(%Post{author: "bar"}, %{title: "foo"})
iex> apply_changes(changeset)
%Post{author: "bar", title: "foo"}
```

--------------------------------

### windows example with partition_by

Source: https://ecto.hexdocs.pm/Ecto.Query.md

Defines a window named `:department` partitioned by `e.depname` and uses `over(avg(e.salary), :department)` to get the average salary per department.

```elixir
# Compare each employee's salary with the average salary in his or her department
from e in Employee,
  select: {e.depname, e.empno, e.salary, over(avg(e.salary), :department)},
  windows: [department: [partition_by: e.depname]]
```

--------------------------------

### Repo.checkout example

Source: https://ecto.hexdocs.pm/Ecto.Adapter.md

Example usage of Repo.checkout to run multiple inserts against the same connection.

```elixir
Repo.checkout(fn ->
  for _ <- 1..100 do
    Repo.insert!(%Post{})
  end
end)
```

--------------------------------

### load/2 examples

Source: https://ecto.hexdocs.pm/Ecto.Type.md

Examples of load/2 for string and integer types, showing successful loads and an error case.

```elixir
iex> load(:string, nil)
{:ok, nil}
iex> load(:string, "foo")
{:ok, "foo"}

iex> load(:integer, 1)
{:ok, 1}
iex> load(:integer, "10")
:error
```

--------------------------------

### get!/3 usage examples

Source: https://ecto.hexdocs.pm/Ecto.Repo.md

Example calls to get!/3. The first fetches a Post with id 42 or raises; the second adds the :prefix option to run the query on the "public" prefix.

```elixir
MyRepo.get!(Post, 42)
```

```elixir
MyRepo.get!(Post, 42, prefix: "public")
```

--------------------------------

### base?/1 examples

Source: https://ecto.hexdocs.pm/Ecto.Type.md

Examples of base?/1 usage: returns true for :string, false for :array and Custom.

```elixir
iex> base?(:string)
true
iex> base?(:array)
false
iex> base?(Custom)
false
```

--------------------------------

### include?/3 examples

Source: https://ecto.hexdocs.pm/Ecto.Type.md

Examples of include?/3 checking membership with structural and semantical comparisons.

```elixir
iex> include?(:integer, 1, 1..3)
true
iex> include?(:decimal, Decimal.new("1"), [Decimal.new("1.00"), Decimal.new("2.00")])
true
```

--------------------------------

### change/2 examples in IEx

Source: https://ecto.hexdocs.pm/Ecto.Changeset.md

Interactive Elixir examples demonstrating change/2 with a struct, keyword changes, and merging into an existing changeset. The examples show that changes are only added when they differ from the current field values.

```elixir
iex> changeset = change(%Post{})
%Ecto.Changeset{...}
iex> changeset.valid?
true
iex> changeset.changes
%{}
```

```elixir
iex> changeset = change(%Post{author: "bar"}, title: "title")
iex> changeset.changes
%{title: "title"}
```

```elixir
iex> changeset = change(%Post{title: "title"}, title: "title")
iex> changeset.changes
%{}
```

```elixir
iex> changeset = change(changeset, %{title: "new title", body: "body"})
iex> changeset.changes.title
"new title"
iex> changeset.changes.body
"body"
```

--------------------------------

### mappings/2 examples with types map

Source: https://ecto.hexdocs.pm/Ecto.Enum.md

Example of calling mappings/2 with a types map, showing how to initialize parameterized types and retrieve mappings.

```elixir
schemaless_types = %{
  my_enum: Ecto.ParameterizedType.init(Ecto.Enum, values: [:foo, :bar, :baz]),
  my_integer_enum: Ecto.ParameterizedType.init(Ecto.Enum, values: [foo: 1, bar: 2, baz: 5])
}
```

```elixir
Ecto.Enum.mappings(schemaless_types, :my_enum)
#=> [foo: "foo", bar: "bar", baz: "baz"]
Ecto.Enum.mappings(schemaless_types, :my_integer_enum)
#=> [foo: 1, bar: 2, baz: 5]
```

--------------------------------

### force_change/3 example

Source: https://ecto.hexdocs.pm/Ecto.Changeset.md

Example showing force_change/3 overriding an existing change and adding a new forced change.

```elixir
iex> changeset = change(%Post{author: "bar"}, %{title: "foo"})
iex> changeset = force_change(changeset, :title, "bar")
iex> changeset.changes
%{title: "bar"}

iex> changeset = force_change(changeset, :author, "bar")
iex> changeset.changes
%{title: "bar", author: "bar"}
```

--------------------------------

### Define and configure an Ecto repository

Source: https://ecto.hexdocs.pm/

Define an Ecto repository with the Postgres adapter, configure it in the application environment (either with individual fields or a URL), and start it as a supervisor in the application's start callback. The repository must be started before use, typically via the supervision tree.

```elixir
defmodule Repo do
  use Ecto.Repo,
    otp_app: :my_app,
    adapter: Ecto.Adapters.Postgres
end
```

```elixir
config :my_app, Repo,
  database: "ecto_simple",
  username: "postgres",
  password: "postgres",
  hostname: "localhost",
  # OR use a URL to connect instead
  url: "postgres://postgres:postgres@localhost/ecto_simple"
```

```elixir
def start(_type, _args) do
  children = [
    MyApp.Repo,
  ]

  opts = [strategy: :one_for_one, name: MyApp.Supervisor]
  Supervisor.start_link(children, opts)
end
```

--------------------------------

### Create database, migrate, and run query

Source: https://ecto.hexdocs.pm/multi-tenancy-with-query-prefixes.md

Commands to create the database, run migrations, and start an IEx session. The query returns an empty list because the table exists in the default 'public' prefix.

```bash
$ mix ecto.create
$ mix ecto.migrate
$ iex -S mix
Interactive Elixir - press Ctrl+C to exit
iex(1)> MyApp.Repo.all MyApp.Sample
[]
```

--------------------------------

### Start primary and replica repositories in supervision tree

Source: https://ecto.hexdocs.pm/replicas-and-dynamic-repositories.md

Lists all repositories to be started in the supervision tree, including the primary and all four replicas. This is required for the repositories to be available at runtime.

```elixir
children = [
  MyApp.Repo,
  MyApp.Repo.Replica1,
  MyApp.Repo.Replica2,
  MyApp.Repo.Replica3,
  MyApp.Repo.Replica4
]
```

--------------------------------

### Use RepoCase in test module

Source: https://ecto.hexdocs.pm/testing-with-ecto.md

Use the RepoCase template in a test module to get the sandbox setup.

```elixir
defmodule MyApp.MyTest do
  use MyApp.RepoCase

  # Tests etc...
end

```

--------------------------------

### Get struct metadata with Ecto.get_meta/2

Source: https://ecto.hexdocs.pm/Ecto.html

Shows how to use Ecto.get_meta/2 to retrieve the metadata state of a struct, returning :built in this example.

```elixir
iex> Ecto.get_meta(changeset.data, :state)
:built
```

--------------------------------

### Install dependencies with mix deps.get

Source: https://ecto.hexdocs.pm/getting-started.md

Run this command to install the dependencies added to mix.exs. Without this step, querying the database would not be possible.

```shell
mix deps.get
```

--------------------------------

### windows :partition_by example

Source: https://ecto.hexdocs.pm/Ecto.Query.md

Shows the `:partition_by` window expression, which takes a list of fields to partition the window by.

```elixir
windows: [department: [partition_by: e.depname]]
```

--------------------------------

### Start a dynamic repository with credentials

Source: https://ecto.hexdocs.pm/replicas-and-dynamic-repositories.md

Starts a repository with a given set of credentials dynamically. The `name` option is set to `:some_client` and `start_link` accepts the same options as the database configuration.

```elixir
MyApp.Repo.start_link(
  name: :some_client,
  hostname: "client.example.com",
  username: "...",
  password: "...",
  pool_size: 1
)
```

--------------------------------

### Migrate and query with custom prefix

Source: https://ecto.hexdocs.pm/multi-tenancy-with-query-prefixes.md

Runs migrations and starts an IEx session to query the Sample schema. The empty list confirms the query runs against the newly created prefix.

```bash
$ mix ecto.migrate
$ iex -S mix
Interactive Elixir - press Ctrl+C to exit
iex(1)> MyApp.Repo.all MyApp.Sample
[]
```

--------------------------------

### dump_values/2 examples

Source: https://ecto.hexdocs.pm/Ecto.Enum.md

Examples of calling dump_values/2 with the example schema, showing the dumped values for string and integer enums.

```elixir
Ecto.Enum.dump_values(MySchema, :my_string_enum)
#=> ["foo", "bar", "baz"]
```

```elixir
Ecto.Enum.dump_values(MySchema, :my_integer_enum)
#=> [1, 2, 5]
```

--------------------------------

### having expression example

Source: https://ecto.hexdocs.pm/Ecto.Query.md

Pipeline expression example for having.

```elixir
Post
|> group_by([p], p.category)
|> having([p], avg(p.num_comments) > 10)
|> select([p], count(p.id))
```

--------------------------------

### MyRepo.update_all examples

Source: https://ecto.hexdocs.pm/Ecto.Repo.md

Examples of using MyRepo.update_all/3 with different update operations: setting a field, incrementing a field, using a select, using the update keyword, parameterized values, fragments, and arithmetic on existing fields. These demonstrate the various ways to construct update queries.

```elixir
MyRepo.update_all(Post, set: [title: "New title"])
```

```elixir
MyRepo.update_all(Post, inc: [visits: 1])
```

```elixir
from(p in Post, where: p.id < 10, select: p.visits)
|> MyRepo.update_all(set: [title: "New title"])
```

```elixir
from(p in Post, where: p.id < 10, update: [set: [title: "New title"]])
|> MyRepo.update_all([])
```

```elixir
from(p in Post, where: p.id < 10, update: [set: [title: ^new_title]])
|> MyRepo.update_all([])
```

```elixir
from(p in Post, where: p.id < 10, update: [set: [title: fragment("upper( ? )", ^new_title)]])
|> MyRepo.update_all([])
```

```elixir
from(p in Post, where: p.id < 10, update: [set: [visits: p.visits * 1000]])
|> MyRepo.update_all([])
```

--------------------------------

### having keyword example

Source: https://ecto.hexdocs.pm/Ecto.Query.md

Keyword example for having with group_by and an aggregate condition.

```elixir
# Returns the number of posts in each category where the
# average number of comments is above ten
from(p in Post,
  group_by: p.category,
  having: avg(p.num_comments) > 10,
  select: {p.category, count(p.id)})
```

--------------------------------

### group_by expression example

Source: https://ecto.hexdocs.pm/Ecto.Query.md

Pipeline expression example for group_by.

```elixir
Post |> group_by([p], p.category) |> select([p], count(p.id))
```

--------------------------------

### reset_fields/2 spec and example

Source: https://ecto.hexdocs.pm/Ecto.html

Specification and example for the reset_fields/2 function, which resets fields in a struct to their default values. The example shows resetting :title and :author after preloading the author.

```elixir
@spec reset_fields(Ecto.Schema.t(), list()) :: Ecto.Schema.t()
```

```elixir
iex> post = post |> Repo.preload(:author)
%Post{title: "hello world", author: %Author{}}
iex> Ecto.reset_fields(post, [:title, :author])
%Post{
  title: "default title",
  author: #Ecto.Association.NotLoaded<association :author is not loaded>
}
```

--------------------------------

### from/2 hints examples

Source: https://ecto.hexdocs.pm/Ecto.Query.md

Shows how to use the `hints` keyword in `from` to specify query hints, add statements after the `from` clause (e.g., table sampling), and use unsafe fragments for dynamic hints. Unsafe fragments are injected directly into SQL without escaping and should never be used with uncontrolled input.

```elixir
from p in Post,
  hints: ["USE INDEX FOO"],
  where: p.title == "title"
```

```elixir
from p in Post,
  hints: "TABLESAMPLE SYSTEM(1)"
```

```elixir
sample = "SYSTEM_ROWS(1)"

from p in Post,
  hints: ["TABLESAMPLE", unsafe_fragment(^sample)]
```

--------------------------------

### all/2 example

Source: https://ecto.hexdocs.pm/Ecto.Repo.md

Example usage of all/2 to fetch all post titles.

```elixir
# Fetch all post titles
query = from p in Post,
          select: p.title
MyRepo.all(query)
```

--------------------------------

### Use the with_dynamic_repo function

Source: https://ecto.hexdocs.pm/replicas-and-dynamic-repositories.md

Uses the `with_dynamic_repo/2` function with a credentials list and a callback that queries `Post`. This encapsulates the dynamic connection setup and cleanup.

```elixir
credentials = [
  hostname: "client.example.com",
  username: "...",
  password: "..."
]

MyApp.Repo.with_dynamic_repo(credentials, fn ->
  MyApp.Repo.all(Post)
end)
```

--------------------------------

### Start a repository with no name and clean up

Source: https://ecto.hexdocs.pm/replicas-and-dynamic-repositories.md

Starts a repository with `name: nil`, matches on the returned PID, and uses `put_dynamic_repo` to run a query. The `after` block restores the default dynamic repo and stops the new repository with `Supervisor.stop/1`.

```elixir
default_dynamic_repo = MyApp.Repo.get_dynamic_repo()

{:ok, repo} =
  MyApp.Repo.start_link(
    name: nil,
    hostname: "client.example.com",
    username: "...",
    password: "...",
    pool_size: 1
  )

try do
  MyApp.Repo.put_dynamic_repo(repo)
  MyApp.Repo.all(Post)
after
  MyApp.Repo.put_dynamic_repo(default_dynamic_repo)
  Supervisor.stop(repo)
end
```

--------------------------------

### Create the database with mix ecto.create

Source: https://ecto.hexdocs.pm/getting-started.md

Creates the database for the current repository. If successful, the message 'The database for Friends.Repo has been created.' is displayed. If an error occurs, check the configuration in config/config.exs for authentication issues.

```shell
mix ecto.create
```

--------------------------------

### traverse_validations/2 identity example

Source: https://ecto.hexdocs.pm/Ecto.Changeset.md

Example of traverse_validations/2 with the identity function, returning the validations unchanged.

```elixir
iex> traverse_validations(changeset, &(&1))
%{title: [format: ~r/pattern/, length: [min: 1, max: 20]]}
```

--------------------------------

### merge/2 example

Source: https://ecto.hexdocs.pm/Ecto.Changeset.md

Example of merging two changesets with the same data, showing the resulting changes.

```elixir
iex> changeset1 = cast(%Post{}, %{title: "Title"}, [:title])
iex> changeset2 = cast(%Post{}, %{title: "New title", body: "Body"}, [:title, :body])
iex> changeset = merge(changeset1, changeset2)
iex> changeset.changes
%{body: "Body", title: "New title"}
```

--------------------------------

### get_change/3 example

Source: https://ecto.hexdocs.pm/Ecto.Changeset.md

Example of get_change/3 returning the change value or nil when the field is not changed.

```elixir
iex> changeset = change(%Post{body: "foo"}, %{title: "bar"})
iex> get_change(changeset, :title)
"bar"
iex> get_change(changeset, :body)
nil
```

--------------------------------

### Using over/2 with inline window definition

Source: https://ecto.hexdocs.pm/Ecto.Query.WindowAPI.md

Shows an equivalent query to the named window example, but with the window definition given directly as the second argument to over. Both queries are equivalent, but defining a window reduces query size when reusing the same partitioning.

```elixir
from e in Employee,
  select: {e.depname, e.empno, e.salary, over(avg(e.salary), partition_by: e.depname)}
```

--------------------------------

### equal?/3 examples

Source: https://ecto.hexdocs.pm/Ecto.Type.md

Examples of equal?/3 performing structural and semantical comparisons.

```elixir
iex> equal?(:integer, 1, 1)
true
iex> equal?(:decimal, Decimal.new("1"), Decimal.new("1.00"))
true
```

--------------------------------

### delete_all usage examples

Source: https://ecto.hexdocs.pm/Ecto.Repo.md

Examples of using delete_all with a queryable, a query with a where clause, and a query with a select to return results. The last example shows how to capture the returned posts when the database supports returning data from DELETEs.

```elixir
MyRepo.delete_all(Post)
```

```elixir
from(p in Post, where: p.id < 10) |> MyRepo.delete_all()
```

```elixir
# With returning results, if supported by the database.
{_count, posts} = from(p in Post, where: p.id < 10, select: p) |> MyRepo.delete_all()
```

--------------------------------

### Basic query with import and Repo.all

Source: https://ecto.hexdocs.pm/Ecto.Query.md

Shows a basic keyword-based query using from/2, filtering with where, selecting a field, and sending the query to the repository with Repo.all. The import is limited to from/2.

```elixir
# Imports only from/2 of Ecto.Query
import Ecto.Query, only: [from: 2]

# Create a query
query = from u in "users",
          where: u.age > 18,
          select: u.name

# Send the query to the repository
Repo.all(query)
```

--------------------------------

### Keywords examples: unordered and ordered results

Source: https://ecto.hexdocs.pm/Ecto.Query.md

Keyword-based union_all examples. The first returns an unordered result; the second wraps the combination in a subquery to apply an order_by.

```elixir
# Unordered result
supplier_query = from s in Supplier, select: s.city
from c in Customer, select: c.city, union_all: ^supplier_query
```

```elixir
# Ordered result
supplier_query = from s in Supplier, select: s.city
union_all_query = from c in Customer, select: c.city, union_all: ^supplier_query
from s in subquery(union_all_query), order_by: s.city
```

--------------------------------

### merge/2 error example

Source: https://ecto.hexdocs.pm/Ecto.Changeset.md

Example showing that merge/2 raises an ArgumentError when the changesets have different data.

```elixir
iex> changeset1 = cast(%Post{body: "Body"}, %{title: "Title"}, [:title])
iex> changeset2 = cast(%Post{}, %{title: "New title"}, [:title])
iex> merge(changeset1, changeset2)
** (ArgumentError) different :data when merging changesets
```

--------------------------------

### Run queries and insert on the connection_prefix

Source: https://ecto.hexdocs.pm/multi-tenancy-with-query-prefixes.md

Shows basic repository operations (all/2 and insert/2) running on the default prefix, which is set to "connection_prefix" via the :after_connect callback. The output shows an empty list before insert and the inserted struct after.

```iex
iex(1)> alias MyApp.Sample
MyApp.Sample
iex(2)> MyApp.Repo.all(Sample)
[]
iex(3)> MyApp.Repo.insert(%Sample{name: "mary"})
{:ok, %MyApp.Sample{...}}
iex(4)> MyApp.Repo.all(Sample)
[%MyApp.Sample{...}]
```

--------------------------------

### apply_action!/2 examples

Source: https://ecto.hexdocs.pm/Ecto.Changeset.md

Examples showing successful application and an invalid changeset raising Ecto.InvalidChangesetError.

```elixir
iex> changeset = change(%Post{author: "bar"}, %{title: "foo"})
iex> apply_action!(changeset, :update)
%Post{author: "bar", title: "foo"}
```

```elixir
iex> changeset = change(%Post{author: "bar"}, %{title: :bad})
iex> apply_action!(changeset, :update)
** (Ecto.InvalidChangesetError) could not perform update because changeset is invalid.
```

--------------------------------

### update/2 usage example

Source: https://ecto.hexdocs.pm/Ecto.Repo.md

Example of updating a changeset with update/2, handling success and error cases.

```elixir
post = MyRepo.get!(Post, 42)
post = Ecto.Changeset.change(post, title: "New title")
case MyRepo.update(post) do
  {:ok, struct}       -> # Updated with success
  {:error, changeset} -> # Something went wrong
end
```

--------------------------------

### Use MyApp.Factory in tests

Source: https://ecto.hexdocs.pm/test-factories.md

Imports the factory module and shows example calls to build/1, build/2, and insert!/2 with their expected outputs.

```elixir
import MyApp.Factory

build(:post)
#=> %MyApp.Post{id: nil, title: "hello world", ...}

build(:post, title: "custom title")
#=> %MyApp.Post{id: nil, title: "custom title", ...}

insert!(:post, title: "custom title")
#=> %MyApp.Post{id: ..., title: "custom title"}
```

--------------------------------

### windows :order_by example

Source: https://ecto.hexdocs.pm/Ecto.Query.md

Shows the `:order_by` window expression, which takes a list of fields to order the window by. It works exactly as the keyword query version of `order_by/3`.

```elixir
windows: [ordered_names: [order_by: e.name]]
```

--------------------------------

### embedded_dump/2 example

Source: https://ecto.hexdocs.pm/Ecto.html

Example of dumping an embedded schema struct to a map using the :json format.

```elixir
iex> Ecto.embedded_dump(%Post{}, :json)
%{title: "hello"}
```

--------------------------------

### Point replicas to main repo in test setup

Source: https://ecto.hexdocs.pm/replicas-and-dynamic-repositories.md

In each test setup, points every replica repository at the `MyApp.Repo` connection pool via `put_dynamic_repo/1`. Note that `put_dynamic_repo` is per process; new processes reset to the default until called again.

```elixir
@replicas [
  MyApp.Repo.Replica1,
  MyApp.Repo.Replica2,
  MyApp.Repo.Replica3,
  MyApp.Repo.Replica4
]

setup do
  for replica <- @replicas do
    replica.put_dynamic_repo(MyApp.Repo)
  end

  :ok
end
```

--------------------------------

### Start unnamed repository

Source: https://ecto.hexdocs.pm/Ecto.Repo.md

Starts a repository without a name by explicitly setting the name to nil.

```elixir
MyApp.Repo.start_link(name: nil, hostname: "temp.example.com")
```

--------------------------------

### Configure primary and replicas for development and test

Source: https://ecto.hexdocs.pm/replicas-and-dynamic-repositories.md

Configures all repositories in config/config.exs for development and test environments, using the same database credentials and hostname for each. This example points every repository to localhost with a pool size of 10.

```elixir
replicas = [
  MyApp.Repo,
  MyApp.Repo.Replica1,
  MyApp.Repo.Replica2,
  MyApp.Repo.Replica3,
  MyApp.Repo.Replica4
]

for repo <- replicas do
  config :my_app, repo,
    username: "postgres",
    password: "postgres",
    database: "my_app_prod",
    hostname: "localhost",
    pool_size: 10
end
```

--------------------------------

### MyRepo.load/2 examples

Source: https://ecto.hexdocs.pm/Ecto.Repo.md

Examples of using MyRepo.load/2 with different data formats: map, keyword list, {fields, values} tuple, a types map, and raw query results. Fields not in the schema are ignored, and invalid types raise an error.

```elixir
iex> MyRepo.load(User, %{name: "Alice", age: 25})
%User{name: "Alice", age: 25}
```

```elixir
iex> MyRepo.load(User, [name: "Alice", age: 25])
%User{name: "Alice", age: 25}
```

```elixir
iex> MyRepo.load(User, {[:name, :age], ["Alice", 25]})
%User{name: "Alice", age: 25, ...}
```

```elixir
iex> types = %{name: :string, age: :integer}
iex> MyRepo.load(types, %{name: "Alice", age: 25})
%{name: "Alice", age: 25}
```

```elixir
iex> result = Ecto.Adapters.SQL.query!(MyRepo, "SELECT * FROM users", [])
iex> Enum.map(result.rows, &MyRepo.load(User, {result.columns, &1}))
[%User{...}, ...]
```

--------------------------------

### Except expression examples

Source: https://ecto.hexdocs.pm/Ecto.Query.md

Expression-based except examples: unordered result and ordered result using fragment.

```elixir
# Unordered result
supplier_query = Supplier |> select([s], s.city)
Customer |> select([c], c.city) |> except(^supplier_query)
```

```elixir
# Ordered result
customer_query = Customer |> select([c], c.city) |> order_by(fragment("city"))
supplier_query = Supplier |> select([s], s.city)
except(customer_query, ^supplier_query)
```

--------------------------------

### Except keyword examples

Source: https://ecto.hexdocs.pm/Ecto.Query.md

Keyword-based except examples: unordered result and ordered result using a subquery.

```elixir
# Unordered result
supplier_query = from s in Supplier, select: s.city
from c in Customer, select: c.city, except: ^supplier_query
```

```elixir
# Ordered result
supplier_query = from s in Supplier, select: s.city
except_query = from c in Customer, select: c.city, except: ^supplier_query
from s in subquery(except_query), order_by: s.city
```

--------------------------------

### validations/1 example with output

Source: https://ecto.hexdocs.pm/Ecto.Changeset.md

Builds a changeset with format and length validations, then calls validations/1 to return a keyword list of validations. The output shows the order and structure of the returned validations.

```elixir
%Post{}
|> change()
|> validate_format(:title, ~r/^\w+:\s/, message: "must start with a topic")
|> validate_length(:title, max: 100)
|> validations()
#=> [
  title: {:length, [ max: 100 ]},
  title: {:format, ~r/^\w+:\s/}
]
```

--------------------------------

### Configure repository with database settings

Source: https://ecto.hexdocs.pm/multi-tenancy-with-query-prefixes.md

Configures MyApp.Repo with database connection parameters: username, password, database, hostname, and pool size.

```elixir
# config/config.exs
config :my_app, MyApp.Repo,
  username: "postgres",
  password: "postgres",
  database: "demo",
  hostname: "localhost",
  pool_size: 10
```

--------------------------------

### Ecto.Repo init callback

Source: https://ecto.hexdocs.pm/Ecto.Repo.md

Defines the init/2 callback for Ecto.Repo. It is optional and invoked when the repo starts or when configuration is read. The context is :supervisor when the repo supervisor starts, or :runtime when reading configuration without starting a process. It must return {:ok, keyword} with updated configuration or :ignore (only in the :supervisor case).

```elixir
@callback init(context :: :supervisor | :runtime, config :: Keyword.t()) ::
  {:ok, Keyword.t()} | :ignore
```

--------------------------------

### embedded_load/3 example

Source: https://ecto.hexdocs.pm/Ecto.html

Example of loading embedded data from a database query result using the :json format.

```elixir
iex> result = Ecto.Adapters.SQL.query!(MyRepo, "SELECT users.settings FROM users", [])
iex> Enum.map(result.rows, fn [settings] -> Ecto.embedded_load(Setting, Jason.decode!(settings), :json) end)
[%Setting{...}, ...]
```

--------------------------------

### update_change/3 example

Source: https://ecto.hexdocs.pm/Ecto.Changeset.md

Example of using update_change/3 to increment the impressions field. The change value is updated and the result is 2.

```elixir
iex> changeset = change(%Post{}, %{impressions: 1})
iex> changeset = update_change(changeset, :impressions, &(&1 + 1))
iex> changeset.changes.impressions
2
```

--------------------------------

### Start Ecto repository in application supervision tree

Source: https://ecto.hexdocs.pm/Ecto.html

Starts the repository as a supervisor in the application's supervision tree. Edit the start/2 callback in lib/my_app/application.ex to include the repo in the children list.

```elixir
def start(_type, _args) do
  children = [
    MyApp.Repo,
  ]

  opts = [strategy: :one_for_one, name: MyApp.Supervisor]
  Supervisor.start_link(children, opts)
end
```

--------------------------------

### get_by!/3 usage examples

Source: https://ecto.hexdocs.pm/Ecto.Repo.md

Examples of calling get_by!/3 with a keyword list and with the :prefix option. The first fetches a post by title, the second adds a prefix to run the query on a specific schema path or database.

```elixir
MyRepo.get_by!(Post, title: "My post")
```

```elixir
MyRepo.get_by!(Post, [title: "My post"], prefix: "public")
```
Tokens:
Raw