# `Selecto.Subfilter.Registry`

Registry system for managing multiple subfilters with strategy selection and optimization.

The Registry handles:
- Multiple subfilter registration and management
- Strategy selection (EXISTS, IN, ANY, ALL) based on query patterns
- Performance optimization through join analysis
- Conflict detection and resolution
- SQL generation coordination

## Examples

    iex> registry = Selecto.Subfilter.Registry.new(:film_domain)
    iex> registry = Registry.add_subfilter(registry, "film.rating", "R")
    iex> registry = Registry.add_subfilter(registry, "film.category.name", "Action")
    iex> Registry.generate_sql(registry, base_query)
    {:ok, optimized_query_with_subfilters}

# `compound_operation`

```elixir
@type compound_operation() :: %{type: :and | :or, subfilter_ids: [String.t()]}
```

# `t`

```elixir
@type t() :: %Selecto.Subfilter.Registry{
  base_table: atom() | nil,
  compound_ops: [compound_operation()],
  domain_name: atom() | map(),
  join_resolutions: %{
    required(String.t()) =>
      Selecto.Subfilter.JoinPathResolver.JoinResolution.t()
  },
  optimization_hints: keyword(),
  strategy_overrides: %{required(String.t()) => atom()},
  subfilters: %{required(String.t()) => Selecto.Subfilter.Spec.t()}
}
```

# `add_compound`

```elixir
@spec add_compound(
  t(),
  :and | :or,
  [{String.t(), any()}] | [{String.t(), any(), keyword()}],
  keyword()
) :: {:ok, t()} | {:error, Selecto.Subfilter.Error.t()}
```

Add compound subfilter operations (AND/OR).

## Examples

    add_compound(registry, :and, [
      {"film.rating", "R"},
      {"film.release_year", {">", 2000}}
    ])

# `add_subfilter`

```elixir
@spec add_subfilter(t(), String.t(), any(), keyword()) ::
  {:ok, t()} | {:error, Selecto.Subfilter.Error.t()}
```

Add a subfilter to the registry.

## Examples

    add_subfilter(registry, "film.rating", "R")
    add_subfilter(registry, "film.category.name", ["Action", "Drama"], strategy: :in)
    add_subfilter(registry, "film", {:count, ">", 5}, id: "film_count_filter")

# `analyze`

```elixir
@spec analyze(t()) :: %{
  subfilter_count: non_neg_integer(),
  join_complexity: atom(),
  strategy_distribution: %{required(atom()) => non_neg_integer()},
  performance_score: float(),
  optimization_suggestions: [String.t()]
}
```

Get comprehensive analysis of all subfilters in the registry.

Returns information about join patterns, strategy selections,
performance implications, and optimization opportunities.

# `generate_sql`

```elixir
@spec generate_sql(t(), String.t()) ::
  {:ok, String.t(), [any()]} | {:error, Selecto.Subfilter.Error.t()}
```

Generate SQL for all subfilters in the registry.

This coordinates with the SQL generation system to produce optimized
subquery SQL that integrates with the main query.

# `new`

```elixir
@spec new(
  atom() | map(),
  keyword()
) :: t()
```

Create a new subfilter registry for the specified domain.

## Parameters

- `domain_name` - Domain configuration to use (e.g., :film_domain)
- `opts` - Options including :base_table, :optimization_hints

# `override_strategy`

```elixir
@spec override_strategy(t(), String.t(), atom()) ::
  {:ok, t()} | {:error, Selecto.Subfilter.Error.t()}
```

Override the strategy for a specific subfilter.

Useful for performance tuning when the automatic strategy selection
doesn't produce optimal results.

# `remove_subfilter`

```elixir
@spec remove_subfilter(t(), String.t()) :: t()
```

Remove a subfilter from the registry.

---

*Consult [api-reference.md](api-reference.md) for complete listing*