Przejdź do treści
Biblioteka skilli
Programowanie · Analiza

ecto-queries-performance

/ecto-queries-performance

Pomaga przyspieszać i składać zapytania Ecto: preload a join-preload, dynamic, subquery, Repo.stream, FOR UPDATE, insert_all, Repo.explain i indeksy.

Licencja
MIT
Ostatnia zmiana repozytorium
15.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
2
Skrypty
0
Komentarze HTML
2
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 15.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co sprawdzić przed instalacją
  • SKILL.md zawiera komentarze HTML (2). Nie widać ich w podglądzie Markdown, a model je czyta.

Co robi i kiedy

Pomaga przyspieszać i składać zapytania Ecto: preload a join-preload, dynamic, subquery, Repo.stream, FOR UPDATE, insert_all, Repo.explain i indeksy.

Oryginalny opis (EN)

Use when a query is slow, N+1 or hard to compose — preload vs join-preload, dynamic/2, subquery/exists, Repo.aggregate, Repo.stream, FOR UPDATE, optimistic_lock, insert_all, Repo.explain, indexes, prepare_query. Not for schemas or scoped contexts (use ecto-essentials).

Jak działa

  1. RULES — Follow these with no exceptions
  2. Spotting N+1
  3. Preloading: separate queries vs one join
  4. Composable queries
  5. Counting without loading
  6. Large result sets
  7. Concurrency and correctness
  8. Bulk writes with insertall
  9. Measuring
  10. Indexes for the queries you run
Sekcje z nagłówków SKILL.md, w oryginale · 400 linii, 2 959 słów
Podgląd SKILL.md
---
name: ecto-queries-performance
description: "Use when a query is slow, N+1 or hard to compose — preload vs join-preload, dynamic/2, subquery/exists, Repo.aggregate, Repo.stream, FOR UPDATE, optimistic_lock, insert_all, Repo.explain, indexes, prepare_query. Not for schemas or scoped contexts (use ecto-essentials)."
---

# Ecto Queries & Performance

> Verified against Elixir 1.20, Phoenix 1.8, Ecto 3.14, ecto_sql 3.14 (PostgreSQL 16) — October 2026

## RULES — Follow these with no exceptions

1. **Preload in the context, once for the whole list.** Use `preload:` in the query or one `Repo.preload(list, ...)`. Never call `Repo.preload`, `Repo.get` or a context function per row, whether in `Enum.map`, a HEEx `:for` or a JSON view.
2. **Use separate-query preloads by default.** Join-preload only a `belongs_to`/`has_one` that you also filter or sort on. Joining a `has_many` multiplies rows, and `limit` then counts children instead of parents.
3. **A `limit` in a preload query is global, not per parent.** For "latest N per post", use a `row_number()` window restricted to the parents' ids.
4. **Count and check without loading rows.** Use `Repo.aggregate(q, :count)`, `Repo.exists?/1`, `group_by` + `count()`, or `select_merge` into a virtual field. Never `length(Repo.all(q))`.
5. **Compose with named bindings and `dynamic/2`.** Put `as:` on joins and use `with_named_binding/3` so a join is added only once. For "has any child", use `exists/1` with `parent_as/1` instead of a join plus `distinct`.
6. **Run `Repo.stream` only inside `Repo.transact`.** The function must return `{:ok, _}`, the transaction needs `timeout: :infinity`, and streams don't support preloads. For long jobs, batch by keyset (`where: p.id > ^last_id`), never `OFFSET`.
7. **Never read-modify-write a counter or balance.** Use `update_all(inc: ...)`, a conditional `update_all`, `lock: "FOR UPDATE"` inside `Repo.transact`, or `optimistic_lock/3` with `stale_error_field:`.
8. **`insert_all` and `update_all` bypass changesets.** Nothing is validated and no timestamps are generated. Set `inserted_at`/`updated_at` yourself, and chunk so rows × fields stays under Postgres's 65,535 parameters.
9. **Measure, then index the query you actually run.** Use `Repo.explain(:all, q, analyze: true)` and the `[:my_app, :repo, :query]` telemetry. Put equality columns first in a composite index. A partial or expression index is only used when the query repeats its predicate or expression.
10. **Tenant isolation comes from the scope, passed explicitly.** `prepare_query/3` is only a guard that raises when the tenant option is missing. Never keep the tenant in the process dictionary.

Examples extend the Phoenix 1.8 generated `Blog.Post` with `belongs_to :user` (replacing `field :user_id, :id`) and `has_many :comments`.

---

## Spotting N+1

The usual cause is a query hidden inside a loop: a context call in a template, a `Repo.preload` per element, or a JSON view that loads data for each item.

<!-- epg:bad -->
```heex
<%!-- One COUNT query per post, on every render --%>
<div :for={{id, post} <- @streams.posts} id={id}>
  {post.title} ({Blog.count_comments(@current_scope, post)} comments)
</div>
```

<!-- epg:bad -->
```elixir
# One comments query per post
posts |> Enum.map(&Repo.preload(&1, :comments))
```

In dev, the repeats are easy to see in the log. The generated `config/dev.exs` sets `stacktrace: true` on the repo, so every query log line ends with `↳ Module.fun/arity, at: file:line`. The same caller and the same SQL repeating with a different `$1` is an N+1. To lock the fix in, assert a query count in a test (see the [query-count helper](reference.md#counting-queries-in-tests)).

```elixir
def list_posts_with_comment_counts(%Scope{} = scope) do
  counts = from c in Comment, group_by: c.post_id, select: %{post_id: c.post_id, n: count(c.id)}

  from(p in Post,
    where: p.user_id == ^scope.user.id,
    left_join: c in subquery(counts),
    on: c.post_id == p.id,
    # comment_count is `field :comment_count, :integer, virtual: true` on Post
    select_merge: %{comment_count: coalesce(c.n, 0)},
    order_by: [desc: p.inserted_at, desc: p.id]
  )
  |> Repo.all()
end
```

The template then renders `{post.comment_count}`. If a template or JSON view needs data, the context function that feeds it has to load it.

## Preloading: separate queries vs one join

```elixir
# Separate queries (default): 1 for posts, then 1 per association for the whole
# list. Independent preloads run in parallel outside a transaction.
Post
|> where(user_id: ^scope.user.id)
|> preload([:user, comments: :user])
|> Repo.all()

# Already have the list? One query per association, not per post:
Repo.preload(posts, comments: :user)

# Join-preload: one query. Right for belongs_to/has_one you filter or sort on.
from(p in Post,
  as: :post,
  join: u in assoc(p, :user),
  as: :author,
  where: p.status == :published,
  order_by: [asc: u.email, desc: p.published_at],
  preload: [user: u]
)
|> Repo.all()
```

| Use | When |
|---|---|
| `preload: [:comments]` (separate query) | `has_many`/`many_to_many`, paginated parents, nested preloads |
| `join` + `preload: [user: u]` | `belongs_to`/`has_one` you also `where`/`order_by` on, so the join is needed anyway |
| `preload: [comments: ^query]` | Filter or order the children (`where: is_nil(c.deleted_at)`, `order_by: c.inserted_at`) |
| `preload_order: [asc: :inserted_at]` on `has_many` | A default child order, used when the preload query has no `order_by` of its own |

**Join-preloading a `has_many` with `limit`:** `from p in Post, join: c in assoc(p, :comments), preload: [comments: c], limit: 3` returns **one** post with three comments, because the limit applies to the joined rows. Paginate the parents, then preload the children with separate queries.

`Repo.preload/3` skips associations that are already loaded. Pass `force: true` to reload them after a write.

### Top N children per parent

A preload query's `limit` applies to all parents together. `preload: [comments: ^from(c in Comment, limit: 2)]` returns two comments in total, not two per post. Rank the children with a window function instead, and filter the ranking to the parents you already have so it doesn't scan the whole table:

```elixir
def preload_latest_comments(posts, n) do
  post_ids = Enum.map(posts, & &1.id)

  ranked =
    from c in Comment,
      where: c.post_id in ^post_ids,
      select: %{id: c.id, rank: over(row_number(), :per_post)},
      windows: [per_post: [partition_by: c.post_id, order_by: [desc: c.inserted_at]]]

  latest = from c in Comment, join: r in subquery(ranked), on: c.id == r.id and r.rank <= ^n

  Repo.preload(posts, comments: latest)
end
```

## Composable queries

Name every binding that other functions will refer to (`as: :post`, `as: :author`). Positional bindings break as soon as a join is added in a different order.

```elixir
def search_posts(%Scope{} = scope, params) do
  from(p in Post, as: :post, where: p.user_id == ^scope.user.id)
  |> maybe_join_author(params)
  |> where(^post_filters(params))
  |> order_by([post: p], desc: p.inserted_at, desc: p.id)
  |> Repo.all()
end

# Allowlist of keys; anything else is ignored. dynamic/2 builds the WHERE.
# Every named binding a dynamic uses must already be joined when where/2 runs,
# otherwise it raises "unknown bind name `:author`" — so join first.
defp post_filters(params) do
  Enum.reduce(params, dynamic(true), fn
    {"status", status}, dyn when status in ~w(draft published) ->
      dynamic([post: p], ^dyn and p.status == ^status)

    {"q", term}, dyn ->
      pattern = "%" <> escape_like(term) <> "%"
      dynamic([post: p], ^dyn and (ilike(p.title, ^pattern) or ilike(p.body, ^pattern)))

    {"author_email", email}, dyn ->
      dynamic([author: a], ^dyn and a.email == ^email)

    {"commented", "true"}, dyn ->
      dynamic([post: p], ^dyn and exists(from c in Comment, where: c.post_id == parent_as(:post).id))

    _other, dyn ->
      dyn
  end)
end

defp maybe_join_author(query, %{"author_email" => _}) do
  with_named_binding(query, :author, fn query, binding ->
    join(query, :inner, [post: p], a in assoc(p, :user), as: ^binding)
  end)
end

defp maybe_join_author(query, _params), do: query
```

- `escape_like/1` is in the `ecto-essentials` skill. Unescaped `%` or `_` in a search term match everything.
- `exists/1` takes a query directly, as in `exists(from c in Comment, ...)`. `exists(subquery(...))` also compiles. It must reference the outer row through `parent_as(:post)`, so the outer query needs `as: :post`. Use `not exists(...)` for "posts with no comments".
- `has_named_binding?/2` returns whether a binding exists, and `with_named_binding/3` adds a binding only if it is missing. The join above runs at most once, however many filters need it.
- Use `subquery/1` to aggregate first and then join, as in the comment counts above. Joining the raw children and then using `group_by` on the parent also works, but it can't be combined with preloads cleanly.

## Counting without loading

```elixir
Repo.aggregate(from(p in Post, where: p.user_id == ^scope.user.id), :count)
Repo.exists?(from c in Comment, where: c.post_id == ^post.id)

from(p in Post, where: p.user_id == ^scope.user.id, group_by: p.status, select: {p.status, count()})
|> Repo.all()
|> Map.new()
#=> %{draft: 4, published: 5}
```

- `count()` with no argument is `count(*)`. `count(c.id)` skips NULLs, which matters with a `left_join`.
- `Repo.aggregate/3` drops `order_by` and preloads, and wraps a query that has `limit`, `offset` or `distinct` in a subquery, so `Repo.aggregate(from(p in Post, limit: 2), :count)` returns 2, not the table count. It raises on a query with `group_by`; use the `group_by` + `select` form above.
- Use `Repo.exists?/1` for `if count > 0` checks. It stops at the first matching row.

## Large result sets

```elixir
def export_posts(%Scope{} = scope, device) do
  query = from p in Post, where: p.user_id == ^scope.user.id, order_by: p.id

  Repo.transact(
    fn ->
      query
      |> Repo.stream(max_rows: 1_000)
      |> Stream.chunk_every(1_000)
      |> Stream.flat_map(&Repo.preload(&1, :comments))
      |> Stream.each(&IO.binwrite(device, csv_line(&1)))
      |> Stream.run()

      {:ok, :exported}
    end,
    timeout: :infinity
  )
end
```

- Enumerating a stream outside a transaction raises `cannot reduce stream outside of transaction`.
- `Repo.transact/2` raises `ArgumentError` unless the function returns `{:ok, _}` or `{:error, _}`. The `Repo.stream` docs' own example returns `Enum.to_list(stream)` and would hit this error.
- `preload:` on a streamed query raises `preloads are not supported on streams`. Chunk the stream and call `Repo.preload/2` per chunk, as above.
- `max_rows` defaults to 500. The transaction's default 15 s timeout applies to the whole stream, so pass `timeout: :infinity`, or a real limit.
- A long-lived transaction holds a snapshot, which blocks vacuum and keeps locks. For backfills and jobs, process keyset batches, each in its own short query:

```elixir
def touch_all_posts(last_id \\ 0) do
  ids = Repo.all(from p in Post, where: p.id > ^last_id, order_by: p.id, limit: 1_000, select: p.id)

  case ids do
    [] ->
      :done

    ids ->
      now = DateTime.utc_now(:second)
      Repo.update_all(from(p in Post, where: p.id in ^ids), set: [updated_at: now])
      touch_all_posts(List.last(ids))
  end
end
```

`OFFSET n` makes Postgres read and discard n rows on every page, and rows that change between pages are skipped or repeated. Keyset pagination for UIs and APIs, with an `(inserted_at, id)` cursor, is covered in the `phoenix-json-api` skill. Run backfills outside migrations; see the `ecto-migrations-safety` skill.

## Concurrency and correctness

**Counters: one atomic statement.** Reading a value, adding to it in Elixir and writing it back loses updates under concurrency.

```elixir
from(p in Post, where: p.id == ^post.id)
|> Repo.update_all(inc: [comments_count: 1], set: [updated_at: DateTime.utc_now(:second)])
# UPDATE posts SET comments_count = comments_count + 1, updated_at = $1 WHERE id = $2
```

**Counter cache with `prepare_changes/2`.** The function runs inside the insert's transaction, and only when the changeset is valid:

```elixir
def create_comment(%Scope{} = scope, %Post{} = post, attrs) do
  post
  |> Ecto.build_assoc(:comments)
  |> Comment.changeset(attrs, scope)
  |> Ecto.Changeset.prepare_changes(fn changeset ->
    post_id = Ecto.Changeset.get_field(changeset, :post_id)
    changeset.repo.update_all(from(p in Post, where: p.id == ^post_id), inc: [comments_count: 1])
    changeset
  end)
  |> Repo.insert()
end
```

`post` must come from a scoped lookup (`get_post!(scope, id)`, or whatever posts this user may comment on). Never cast `post_id`.

**Conditional update** when the rule involves a single row: the `WHERE` enforces it atomically, without a lock.

```elixir
{count, _} =
  from(w in Wallet, where: w.id == ^wallet.id and w.balance >= ^amount)
  |> Repo.update_all(inc: [balance: -amount])

if count == 1, do: :ok, else: {:error, :insufficient_funds}
```

**`FOR UPDATE`** when the decision needs application logic across reads. The lock only lasts as long as the transaction:

```elixir
def transfer(%Scope{} = scope, from_id, to_id, amount) do
  Repo.transact(fn ->
    # One statement ordered by id: concurrent transfers lock rows in the same order
    wallets =
      from(w in Wallet, where: w.id in ^[from_id, to_id], order_by: w.id, lock: "FOR UPDATE")
      |> Repo.all()
      |> Map.new(&{&1.id, &1})

    from_wallet = Map.fetch!(wallets, from_id)
    to_wallet = Map.fetch!(wallets, to_id)
    true = from_wallet.user_id == scope.user.id

    # check_limits/2 returns :ok or {:error, reason}; any {:error, _} rolls back
    with :ok <- check_limits(from_wallet, amount),
         {:ok, _} <- Repo.update(Wallet.debit_changeset(from_wallet, amount)),
         {:ok, _} <- Repo.update(Wallet.credit_changeset(to_wallet, amount)) do
      {:ok, :transferred}
    end
  end)
end
```

Two transactions that lock the same rows in different orders deadlock, so lock them in one ordered statement as above (or always in id order).

**`FOR UPDATE SKIP LOCKED`** lets workers claim rows without blocking each other: `from(j in Job, where: j.state == "available", order_by: j.id, limit: 10, lock: "FOR UPDATE SKIP LOCKED")` inside `Repo.transact`. For background jobs, use Oban (see the `oban-essentials` skill) rather than building your own queue.

**Optimistic locking** for records edited in forms, where two users saving the same post must not silently overwrite each other. Add `add :lock_version, :integer, default: 1, null: false` to the table and `field :lock_version, :integer, default: 1` to the schema:

```elixir
def update_post(%Scope{} = scope, %Post{} = post, attrs) do
  true = post.user_id == scope.user.id

  post
  |> Post.changeset(attrs, scope)
  |> Ecto.Changeset.optimistic_lock(:lock_version)
  |> Repo.update(stale_error_field: :lock_version)
end
```

- Without `stale_error_field:`, a stale update raises `Ecto.StaleEntryError`. With it, the update returns `{:error, changeset}` with `lock_version: {"is stale", [stale: true]}`. The field has no input, so show that error in a flash ("changed by someone else — reload").
- The version comes from the struct you pass in. A LiveView keeps the post it loaded in `mount`, which is the right version. After a successful save, keep the returned post, which has the incremented version.

## Bulk writes with `insert_all`

```elixir
# Migration: create unique_index(:posts, [:user_id, :slug])
def import_posts(%Scope{} = scope, rows) do
  now = DateTime.utc_now(:second)

  entries =
    Enum.map(rows, fn row ->
      %{
        title: row.title,
        body: row.body,
        slug: row.slug,
        user_id: {:placeholder, :user_id},
        inserted_at: {:placeholder, :now},
        updated_at: {:placeholder, :now}
      }
    end)

  Repo.transact(fn ->
    total =
      entries
      |> Enum.chunk_every(5_000)
      |> Enum.reduce(0, fn chunk, acc ->
        {count, _} =
          Repo.insert_all(Post, chunk,
            placeholders: %{now: now, user_id: scope.user.id},
            on_conflict: {:replace, [:title, :body, :updated_at]},
            conflict_target: [:user_id, :slug]
          )

        acc + count
      end)

    {:ok, total}
  end)
end
```

- **No timestamps.** `insert_all` doesn't autogenerate `inserted_at`/`updated_at`, or any field except an `:id`/`:binary_id` primary key. With `null: false` columns, leaving them out fails with `not_null_violation`.
- **No changesets.** Values are dumped to their types, but nothing is validated. Validate user-supplied rows first, for example with a changeset and `apply_action/2`, and set `user_id` from the scope, never from the row.
- **65,535 bind parameters per statement.** Going over raises `postgresql protocol can not handle N parameters`. Each placeholder is sent once, whatever the number of rows, so chunk by `div(65_535, fields_not_in_placeholders)`. Smaller chunks (1k–5k rows) keep locks and memory reasonable.
- **`returning:`** returns structs for the rows written. With `on_conflict: :nothing`, skipped rows are not returned. With `{:replace, fields}`, updated rows are returned too.
- `conflict_target` must match a unique index exactly. Never include the conflict-target columns in `{:replace, ...}`. Upserts through a changeset (`Repo.insert/2`) are covered in the `ecto-essentials` skill.

## Measuring

```elixir
query = from p in Post, where: p.user_id == ^user_id and is_nil(p.deleted_at), order_by: [desc: p.published_at]

Repo.explain(:all, query, analyze: true, buffers: true) |> IO.puts()
# Index Scan Backward using posts_user_id_published_at_index on posts p0 ...

Repo.to_sql(:all, query)
#=> {"SELECT ... WHERE ((p0.\"user_id\" = $1) AND (p0.\"deleted_at\" IS NULL)) ...", [42]}
```

- `Repo.explain/3` is the same as `Ecto.Adapters.SQL.explain(Repo, ...)`. It takes `:all`, `:update_all` or `:delete_all`, and the Postgres options `analyze`, `verbose`, `costs`, `settings`, `buffers`, `timing`, `summary`, `format` (`:text`, `:map`, `:yaml`) and `plan`.
- `analyze: true` executes the query. By default it runs inside a transaction that is rolled back, so analyzing `update_all` is safe. **Inside your own `Repo.transact`, that forced rollback aborts your transaction.** Pass `wrap_in_transaction: false` there. The result then comes back as `{:ok, plan}`.
- Run EXPLAIN against production-sized data. On a dev table with ten rows, Postgres picks a sequential scan regardless of your indexes.
- In production, watch `[:my_app, :repo, :query]` telemetry (`total_time`, `queue_time`) for slow queries and pool pressure; see the `telemetry-essentials` skill. For copy-pasteable SQL with inlined params in dev, the `ecto_dev_logger` package replaces the default logger: set `log: false` on the repo in dev and call `Ecto.DevLogger.install(MyApp.Repo)`.

## Indexes for the queries you run

| Query shape | Index |
|---|---|
| `where user_id = ? order by published_at desc` | `index(:posts, [:user_id, :published_at])`: equality columns first, then the sort or range column |
| Same, plus `is_nil(p.deleted_at)` on every read | `index(:posts, [:user_id, :published_at], where: "deleted_at IS NULL")`: smaller, and only used when the query includes `deleted_at IS NULL` |
| `where state = 'available'` on a mostly-processed table | `index(:jobs, [:inserted_at], where: "state = 'available'")` |
| `fragment("lower(?)", u.email) == ^String.downcase(email)` | `index(:users, ["(lower(email))"], name: :users_lower_email_index)`: the query must use the same expression (or use `citext`) |
| Keyset `(inserted_at, id)` cursor | `index(:posts, [:user_id, :inserted_at, :id])` |

A composite index on `[:user_id, :published_at]` also serves queries on `user_id` alone, but not queries on `published_at` alone. Every foreign key needs its own index (or must lead a composite one) for joins and `on_delete`. Add indexes to large tables with `concurrently: true`; see the `ecto-migrations-safety` skill, and the `ecto-essentials` skill for basic index and constraint syntax.

## Multi-tenancy

**Row-level tenancy (an `org_id` column)** is what Phoenix 1.8 scopes are for. Context functions take the scope and filter explicitly, as in the `ecto-essentials` skill. A repo `prepare_query/3` callback can add a guard, so a forgotten filter raises instead of leaking. The callback is `prepare_query(operation, query, opts)` and returns `{query, opts}`. It raises when a schema with an `org_id` field is queried without `org_id:`, and adds `where(org_id: ^org_id)` when the option is given. Contexts then call `Repo.all(query, org_id: scope.org.id)`. Full code and a coverage table are in the [guard reference](reference.md#prepare_query3-guard).

- It runs for `all`/`get`/`one`/`aggregate`/`exists?`/`stream`/`update_all`/`delete_all`, but **not** for `insert`, `update` or `delete` of a struct. Writes still need the scope check.
- Options reach preload queries, so preloaded tenant tables are filtered too. Joins, subquery sources and bare table strings are **not** filtered.
- Migrations query with `schema_migration: true`, so the guard must let those through.
- Take the tenant from `scope` and pass it as an option. Don't store it in the process dictionary for `default_options/1` to read: it is invisible in the code, and it is lost in parallel preloads, `Task`s and LiveView `assign_async`, which all run in other processes.

**Schema-per-tenant (Postgres schemas)** is covered in the [multi-tenancy reference](reference.md#schema-per-tenant-prefixes): `prefix:` and `put_query_prefix/2` at runtime, and `@schema_prefix` only for fixed schemas.

## Testing

When writing tests for query performance (query counts, lock behavior), invoke `elixir-phoenix-guide:testing-essentials` before writing any `_test.exs` file. The query-count helper is in the [reference](reference.md#counting-queries-in-tests).
Pliki w paczce (2)
  • SKILL.md 22 KB
  • reference.md 6 KB

Wersje

W bazie nie ma innych skilli o nazwie ecto-queries-performance.

Migawka bazy z 13.11.2026 · wersja paczki 343d1f944ed0 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100ecto-essentials
    Pomaga definiować schematy Ecto, pisać zapytania i tworzyć migracje, w tym funkcje kontekstów, Repo.transact, upserty, indeksy i bezpieczne rzutowanie pól.
  • 100ecto-thinking
    Pomaga dodawać tabele, konteksty i pola schematów w Ecto, pisać zapytania, walidować dane formularzy, naprawiać N+1 oraz układać komunikację między kontekstami.
  • 100ecto
    Prowadzi przez schematy Ecto, changesety, zapytania, migracje i Ecto.Multi oraz pomaga wybrać między DSL zapytań Ecto a surowym SQL.
  • 100estack-ecto
    Implementuje dostęp do danych w Ecto: schematy, zapytania, changesety, transakcje i bezpieczne migracje, w tym konteksty ograniczone do tenanta.
  • 100ecto-patterns
    Podpowiada wzorce pracy z Ecto: schematy, changesety, walidacje, zapytania, preloady i Multi, ładowane przed pisaniem kodu Ecto.
  • 100ecto
    Pomaga projektować i debugować warstwę danych w Elixirze z Ecto: schematy, changesety, zapytania, preloady, transakcje, migracje, multi-tenancy oraz wydajność i pulę połączeń.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.