-module(cake@where).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/cake/where.gleam").
-export([col/1, float/1, int/1, string/1, null/0, date/1, true/0, false/0, bool/1, sub_query/1, fragment_value/1, 'not'/1, 'and'/1, 'or'/1, 'xor'/1, xor_parity/1, none/0, is_bool/2, is_not_bool/2, is_false/1, is_true/1, is_null/1, is_not_null/1, eq/2, lt/2, lte/2, gt/2, gte/2, neq/2, eq_any_query/2, lt_any_query/2, lte_any_query/2, gt_any_query/2, gte_any_query/2, neq_any_query/2, eq_all_query/2, lt_all_query/2, lte_all_query/2, gt_all_query/2, gte_all_query/2, neq_all_query/2, in_query/2, in/2, exists_in_query/1, between/3, like/2, ilike/2, similar_to/3, fragment/1]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(
    " Builds `WHERE` and `HAVING` conditions for `SELECT`, `UPDATE`, and `DELETE`\n"
    "\n"
    " Where clauses are used to filter rows in a table.\n"
    "\n"
    " Also used to build `HAVING` clauses for SQL queries, because they work the\n"
    " same way as `WHERE` clauses, but are used to filter rows after `GROUP BY`\n"
    " has been applied.\n"
    "\n"
    " ## Aliases\n"
    "\n"
    " ```gleam\n"
    " import cake/where as w\n"
    " ```\n"
    "\n"
    " > The `Where` type is identical for both `WHERE` and `HAVING` contexts.\n"
    " > Use the same `cake/where` functions in `s.having(...)` calls.\n"
    "\n"
    " ---\n"
    "\n"
    " ## Concept\n"
    "\n"
    " A `Where` is a tree of conditions. Leaf nodes are comparisons; branch nodes\n"
    " are logical combinators (`AND`, `OR`, `XOR`). You compose them freely and pass\n"
    " the result to query builder functions like `s.where(...)`, `u.where(...)`, etc.\n"
    "\n"
    " ```mermaid\n"
    " flowchart TD\n"
    "     ROOT[AndWhere] --> A[eq: active = TRUE]\n"
    "     ROOT --> B[OrWhere]\n"
    "     B --> C[eq: role = admin]\n"
    "     B --> D[eq: role = mod]\n"
    " ```\n"
    "\n"
    " Corresponding code:\n"
    "\n"
    " ```gleam\n"
    " w.and([\n"
    "   w.eq(w.col(\"active\"), w.bool(True)),\n"
    "   w.or([\n"
    "     w.eq(w.col(\"role\"), w.string(\"admin\")),\n"
    "     w.eq(w.col(\"role\"), w.string(\"mod\")),\n"
    "   ]),\n"
    " ])\n"
    " ```\n"
    "\n"
    " ---\n"
    "\n"
    " ## WhereValue constructors\n"
    "\n"
    " A `WhereValue` is one operand in a comparison. It can be a column reference,\n"
    " a literal parameter, a sub-query, or a fragment.\n"
    "\n"
    " | Function                   | Produces                              |\n"
    " | -------------------------- | ------------------------------------- |\n"
    " | `col(\"table.column\")`      | Column reference                      |\n"
    " | `bool(value)`              | Boolean param                         |\n"
    " | `true()`                   | `TRUE` param                          |\n"
    " | `false()`                  | `FALSE` param                         |\n"
    " | `float(value)`             | Float param                           |\n"
    " | `int(value)`               | Integer param                         |\n"
    " | `string(value)`            | String param                          |\n"
    " | `null()`                   | `NULL` param                          |\n"
    " | `date(value)`              | Date param                            |\n"
    " | `sub_query(query)`         | Sub-query (must return single column) |\n"
    " | `fragment_value(fragment)` | Raw SQL fragment                      |\n"
    "\n"
    " ---\n"
    "\n"
    " ## Logical combinators\n"
    "\n"
    " ### `and(wheres) -> Where`\n"
    "\n"
    " All conditions must be true (`AND`).\n"
    "\n"
    " ```gleam\n"
    " w.and([\n"
    "   w.eq(w.col(\"active\"), w.bool(True)),\n"
    "   w.gt(w.col(\"age\"), w.int(18)),\n"
    " ])\n"
    " // active = $1 AND age > $2\n"
    " ```\n"
    "\n"
    " ### `or(wheres) -> Where`\n"
    "\n"
    " At least one condition must be true (`OR`).\n"
    "\n"
    " ```gleam\n"
    " w.or([\n"
    "   w.eq(w.col(\"status\"), w.string(\"pending\")),\n"
    "   w.eq(w.col(\"status\"), w.string(\"processing\")),\n"
    " ])\n"
    " // status = $1 OR status = $2\n"
    " ```\n"
    "\n"
    " ### `not(where) -> Where`\n"
    "\n"
    " Negates a condition.\n"
    "\n"
    " ```gleam\n"
    " w.not(w.is_null(w.col(\"deleted_at\")))\n"
    " // NOT (deleted_at IS NULL)\n"
    " ```\n"
    "\n"
    " ### `xor(wheres) -> Where`\n"
    "\n"
    " Exactly **one** condition must be true.\n"
    "\n"
    " ```gleam\n"
    " w.xor([w.eq(w.col(\"a\"), w.int(1)), w.eq(w.col(\"b\"), w.int(2))])\n"
    " ```\n"
    "\n"
    " | True conditions | Result |\n"
    " | --------------- | ------ |\n"
    " | 0               | FALSE  |\n"
    " | 1               | TRUE   |\n"
    " | 2+              | FALSE  |\n"
    "\n"
    " ### `xor_parity(wheres) -> Where`\n"
    "\n"
    " An **odd number** of conditions must be true (matches MySQL's native `XOR`).\n"
    "\n"
    " ```gleam\n"
    " w.xor_parity([cond_a, cond_b, cond_c])\n"
    " ```\n"
    "\n"
    " | True conditions | Result |\n"
    " | --------------- | ------ |\n"
    " | 0               | FALSE  |\n"
    " | 1               | TRUE   |\n"
    " | 2               | FALSE  |\n"
    " | 3               | TRUE   |\n"
    "\n"
    " > On 🦭 MariaDB / 🐬 MySQL: uses native `XOR`.\n"
    " > On 🐘 PostgreSQL / 🪶 SQLite: emulated via integer arithmetic.\n"
    "\n"
    " ### `none() -> Where`\n"
    "\n"
    " An empty / no-op condition. Useful as a default when building conditions\n"
    " conditionally.\n"
    "\n"
    " ```gleam\n"
    " let age_filter = case min_age {\n"
    "   Some(age) -> w.gte(w.col(\"age\"), w.int(age))\n"
    "   None -> w.none()\n"
    " }\n"
    " ```\n"
    "\n"
    " ---\n"
    "\n"
    " ## Comparison operators\n"
    "\n"
    " All comparisons take two `WhereValue`s.\n"
    "\n"
    " | Function    | SQL      |\n"
    " | ----------- | -------- |\n"
    " | `eq(a, b)`  | `a = b`  |\n"
    " | `neq(a, b)` | `a <> b` |\n"
    " | `lt(a, b)`  | `a < b`  |\n"
    " | `lte(a, b)` | `a <= b` |\n"
    " | `gt(a, b)`  | `a > b`  |\n"
    " | `gte(a, b)` | `a >= b` |\n"
    "\n"
    " ```gleam\n"
    " w.eq(w.col(\"status\"), w.string(\"active\"))\n"
    " w.gt(w.col(\"score\"), w.int(100))\n"
    " w.lte(w.col(\"created_at\"), w.date(cutoff))\n"
    " ```\n"
    "\n"
    " ---\n"
    "\n"
    " ## NULL checks\n"
    "\n"
    " ```gleam\n"
    " w.is_null(w.col(\"deleted_at\"))        // deleted_at IS NULL\n"
    " w.is_not_null(w.col(\"email\"))         // email IS NOT NULL\n"
    " ```\n"
    "\n"
    " ---\n"
    "\n"
    " ## Boolean checks\n"
    "\n"
    " ```gleam\n"
    " w.is_true(w.col(\"active\"))            // active IS TRUE\n"
    " w.is_false(w.col(\"banned\"))           // banned IS FALSE\n"
    " w.is_bool(w.col(\"verified\"), True)    // verified IS TRUE\n"
    " w.is_not_bool(w.col(\"locked\"), True)  // locked IS NOT TRUE\n"
    " ```\n"
    "\n"
    " ---\n"
    "\n"
    " ## IN and BETWEEN\n"
    "\n"
    " ### `in(value, values) -> Where`\n"
    "\n"
    " ```gleam\n"
    " w.in(w.col(\"status\"), [w.string(\"active\"), w.string(\"pending\")])\n"
    " // status IN ($1, $2)\n"
    " ```\n"
    "\n"
    " ### `in_query(value, sub_query) -> Where`\n"
    "\n"
    " ```gleam\n"
    " import cake/select as s\n"
    "\n"
    " let active_ids =\n"
    "   s.new()\n"
    "   |> s.from_table(\"subscriptions\")\n"
    "   |> s.col(\"user_id\")\n"
    "   |> s.where(w.eq(w.col(\"active\"), w.bool(True)))\n"
    "   |> s.to_query\n"
    "\n"
    " w.in_query(w.col(\"users.id\"), active_ids)\n"
    " // users.id IN (SELECT user_id FROM subscriptions WHERE active = $1)\n"
    " ```\n"
    "\n"
    " ### `exists_in_query(sub_query) -> Where`\n"
    "\n"
    " ```gleam\n"
    " w.exists_in_query(active_ids)\n"
    " // EXISTS (SELECT user_id FROM subscriptions WHERE active = $1)\n"
    " ```\n"
    "\n"
    " ### `between(a, b, c) -> Where`\n"
    "\n"
    " ```gleam\n"
    " w.between(w.col(\"age\"), w.int(18), w.int(65))\n"
    " // age BETWEEN $1 AND $2\n"
    " ```\n"
    "\n"
    " ---\n"
    "\n"
    " ## Pattern matching\n"
    "\n"
    " ### `like(value, pattern) -> Where`\n"
    "\n"
    " Case-sensitive pattern match. Use `%` for any sequence and `_` for any single\n"
    " character.\n"
    "\n"
    " ```gleam\n"
    " w.like(w.col(\"name\"), \"Alice%\")\n"
    " // name LIKE $1\n"
    " ```\n"
    "\n"
    " ### `ilike(value, pattern) -> Where`\n"
    "\n"
    " Case-insensitive variant of `LIKE`.\n"
    "\n"
    " ### `similar_to(value, pattern, escape_with) -> Where`\n"
    "\n"
    " SQL regex pattern matching.\n"
    "\n"
    " > Not supported by 🪶 SQLite.\n"
    "\n"
    " ```gleam\n"
    " w.similar_to(w.col(\"phone\"), \"([0-9]{3}-)?[0-9]{3}-[0-9]{4}\", \"\\\\\")\n"
    " ```\n"
    "\n"
    " ---\n"
    "\n"
    " ## Sub-query comparisons (ANY / ALL)\n"
    "\n"
    " > Not supported by 🪶 SQLite.\n"
    "\n"
    " ### ANY — true if **at least one** row in the sub-query satisfies the comparison\n"
    "\n"
    " | Function              | SQL           |\n"
    " | --------------------- | ------------- |\n"
    " | `eq_any_query(v, q)`  | `v = ANY(q)`  |\n"
    " | `neq_any_query(v, q)` | `v <> ANY(q)` |\n"
    " | `lt_any_query(v, q)`  | `v < ANY(q)`  |\n"
    " | `lte_any_query(v, q)` | `v <= ANY(q)` |\n"
    " | `gt_any_query(v, q)`  | `v > ANY(q)`  |\n"
    " | `gte_any_query(v, q)` | `v >= ANY(q)` |\n"
    "\n"
    " ### ALL — true only if **every** row in the sub-query satisfies the comparison\n"
    "\n"
    " | Function              | SQL           |\n"
    " | --------------------- | ------------- |\n"
    " | `eq_all_query(v, q)`  | `v = ALL(q)`  |\n"
    " | `neq_all_query(v, q)` | `v <> ALL(q)` |\n"
    " | `lt_all_query(v, q)`  | `v < ALL(q)`  |\n"
    " | `lte_all_query(v, q)` | `v <= ALL(q)` |\n"
    " | `gt_all_query(v, q)`  | `v > ALL(q)`  |\n"
    " | `gte_all_query(v, q)` | `v >= ALL(q)` |\n"
    "\n"
    " ```gleam\n"
    " w.gt_all_query(w.col(\"salary\"), avg_salary_query)\n"
    " // salary > ALL(SELECT AVG(salary) FROM ...)\n"
    " ```\n"
    "\n"
    " ---\n"
    "\n"
    " ## Raw fragment condition\n"
    "\n"
    " ```gleam\n"
    " import cake/fragment as f\n"
    "\n"
    " w.fragment(f.prepared(\"? @> ?::jsonb\", [\n"
    "   f.string(\"tags\"),\n"
    "   f.string(\"[\\\"gleam\\\"]\"),\n"
    " ]))\n"
    " ```\n"
    "\n"
    " ---\n"
    "\n"
    " ## Full Example\n"
    "\n"
    " ```gleam\n"
    " import cake/select as s\n"
    " import cake/where as w\n"
    "\n"
    " let query =\n"
    "   s.new()\n"
    "   |> s.from_table(\"users\")\n"
    "   |> s.select_cols([\"id\", \"name\", \"email\"])\n"
    "   |> s.where(w.and([\n"
    "     w.is_not_null(w.col(\"email\")),\n"
    "     w.or([\n"
    "       w.eq(w.col(\"role\"), w.string(\"admin\")),\n"
    "       w.and([\n"
    "         w.eq(w.col(\"role\"), w.string(\"user\")),\n"
    "         w.is_true(w.col(\"active\")),\n"
    "       ]),\n"
    "     ]),\n"
    "     w.gte(w.col(\"created_at\"), w.date(start_date)),\n"
    "   ]))\n"
    "   |> s.order_by_asc(\"name\")\n"
    "   |> s.to_query\n"
    " ```\n"
    "\n"
    "\n"
    " <!-- html assets for docs gen -->\n"
    " <style>\n"
    "  .page {\n"
    "    display: block;\n"
    "  }\n"
    "  .content {\n"
    "    width: auto;\n"
    "    max-width: none;\n"
    "  }\n"
    " </style>\n"
    " <!--<script src=\"https://cdn.jsdelivr.net/npm/@mermaid-js/tiny@11/dist/mermaid.tiny.js\"></script>-->\n"
    " <script\n"
    "   src=\"https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js\"\n"
    "   integrity=\"sha256-cBN+d7snO7LvlyuG6LBADMqL5TyyW/xFkRoYbcmGZd4=\"\n"
    "   crossorigin=\"anonymous\"\n"
    " ></script>\n"
    " <script>\n"
    " (callback => document.readyState !== 'loading' ? callback() : document.addEventListener('DOMContentLoaded', callback, { once: true }))(() => {\n"
    "   mermaid.initialize({ startOnLoad: false })\n"
    "   mermaid.run({\n"
    "     querySelector: \".language-mermaid\",\n"
    "   })\n"
    " })\n"
    " </script>\n"
    "\n"
).

-file("src/cake/where.gleam", 393).
?DOC(" Creates a `WhereValue` from a column name `String`.\n").
-spec col(binary()) -> cake@internal@read_query:where_value().
col(Name) ->
    {where_column_value, Name}.

-file("src/cake/where.gleam", 399).
?DOC(" Creates a `WhereValue` from a `Float`.\n").
-spec float(float()) -> cake@internal@read_query:where_value().
float(Value) ->
    _pipe = {float_param, Value},
    {where_param_value, _pipe}.

-file("src/cake/where.gleam", 405).
?DOC(" Creates a `WhereValue` from an `Int`.\n").
-spec int(integer()) -> cake@internal@read_query:where_value().
int(Value) ->
    _pipe = {int_param, Value},
    {where_param_value, _pipe}.

-file("src/cake/where.gleam", 411).
?DOC(" Creates a `WhereValue` from a `String`.\n").
-spec string(binary()) -> cake@internal@read_query:where_value().
string(Value) ->
    _pipe = {string_param, Value},
    {where_param_value, _pipe}.

-file("src/cake/where.gleam", 417).
?DOC(" Creates a `NULL` `WhereValue`.\n").
-spec null() -> cake@internal@read_query:where_value().
null() ->
    _pipe = null_param,
    {where_param_value, _pipe}.

-file("src/cake/where.gleam", 423).
?DOC(" Creates a `WhereValue` from a `calendar.Date`.\n").
-spec date(gleam@time@calendar:date()) -> cake@internal@read_query:where_value().
date(Value) ->
    _pipe = {date_param, Value},
    {where_param_value, _pipe}.

-file("src/cake/where.gleam", 431).
?DOC(
    " Creates a `TRUE` `WhereValue`.\n"
    "\n"
    " Notice: You probably want to use `where.is_true()` instead.\n"
).
-spec true() -> cake@internal@read_query:where_value().
true() ->
    _pipe = true,
    _pipe@1 = {bool_param, _pipe},
    {where_param_value, _pipe@1}.

-file("src/cake/where.gleam", 439).
?DOC(
    " Creates a `FALSE` `WhereValue`.\n"
    "\n"
    " Notice: You probably want to use `where.is_false()` instead.\n"
).
-spec false() -> cake@internal@read_query:where_value().
false() ->
    _pipe = false,
    _pipe@1 = {bool_param, _pipe},
    {where_param_value, _pipe@1}.

-file("src/cake/where.gleam", 445).
?DOC(" Creates a `WhereValue` from a `Bool`.\n").
-spec bool(boolean()) -> cake@internal@read_query:where_value().
bool(Value) ->
    _pipe = {bool_param, Value},
    {where_param_value, _pipe}.

-file("src/cake/where.gleam", 453).
?DOC(
    " Creates a `WhereValue` off a `ReadQuery`.\n"
    "\n"
    " NOTICE: Usually the sub-query must return a single column.\n"
).
-spec sub_query(cake@internal@read_query:read_query()) -> cake@internal@read_query:where_value().
sub_query(Query) ->
    {where_sub_query_value, Query}.

-file("src/cake/where.gleam", 459).
?DOC(" Creates a `WhereValue` from a `Fragment`.\n").
-spec fragment_value(cake@internal@read_query:fragment()) -> cake@internal@read_query:where_value().
fragment_value(Fragment) ->
    {where_fragment_value, Fragment}.

-file("src/cake/where.gleam", 469).
?DOC(" Negates a `Where`.\n").
-spec 'not'(cake@internal@read_query:where()) -> cake@internal@read_query:where().
'not'(Where) ->
    {not_where, Where}.

-file("src/cake/where.gleam", 475).
?DOC(" Logical AND of multiple `Where`s.\n").
-spec 'and'(list(cake@internal@read_query:where())) -> cake@internal@read_query:where().
'and'(Wheres) ->
    {and_where, Wheres}.

-file("src/cake/where.gleam", 481).
?DOC(" Logical OR of multiple `Where`s.\n").
-spec 'or'(list(cake@internal@read_query:where())) -> cake@internal@read_query:where().
'or'(Wheres) ->
    {or_where, Wheres}.

-file("src/cake/where.gleam", 500).
?DOC(
    " Logical XOR of multiple `Where`s.\n"
    "\n"
    " Returns `TRUE` when **exactly one** condition is true.\n"
    "\n"
    " Unlike `xor_parity`, which returns `TRUE` for any **odd number** of true\n"
    " conditions, `xor` is stricter: two or more true conditions yield `FALSE`.\n"
    "\n"
    " | Number of conditions true | Result |\n"
    " |---------------------------|--------|\n"
    " |                         0 | FALSE  |\n"
    " |                         1 | TRUE   |\n"
    " |                         2 | FALSE  |\n"
    " |                         3 | FALSE  |\n"
    " |                         4 | FALSE  |\n"
).
-spec 'xor'(list(cake@internal@read_query:where())) -> cake@internal@read_query:where().
'xor'(Wheres) ->
    {xor_where, Wheres}.

-file("src/cake/where.gleam", 529).
?DOC(
    " Logical XOR of multiple `Where`s using left-associative binary XOR.\n"
    "\n"
    " Unlike `xor`, which returns `TRUE` when _exactly one_ condition is true,\n"
    " `xor_parity` returns `TRUE` when an **odd number** of conditions are true —\n"
    " matching the behaviour of MySQL's and MariaDB's native `XOR` operator.\n"
    "\n"
    " | Number of conditions true | Result |\n"
    " |---------------------------|--------|\n"
    " |                         0 | FALSE  |\n"
    " |                         1 | TRUE   |\n"
    " |                         2 | FALSE  |\n"
    " |                         3 | TRUE   |\n"
    " |                         4 | FALSE  |\n"
    "\n"
    " **NULL handling:** if any predicate evaluates to `NULL`, the entire\n"
    " expression evaluates to `NULL`, which a `WHERE` clause treats as no\n"
    " match (NULL-poisoning). This is consistent across all adapters:\n"
    "\n"
    " - 🐘PostgreSQL / 🪶SQLite emulate parity via integer arithmetic;\n"
    "   a NULL predicate propagates as NULL through the sum and modulo.\n"
    " - 🦭MariaDB / 🐬MySQL use native `XOR`, where `NULL XOR anything = NULL`.\n"
    "\n"
    " For adapters 🦭MariaDB or 🐬MySQL the native `XOR` syntax will be\n"
    " utilized under the hood.\n"
).
-spec xor_parity(list(cake@internal@read_query:where())) -> cake@internal@read_query:where().
xor_parity(Wheres) ->
    {xor_parity_where, Wheres}.

-file("src/cake/where.gleam", 535).
?DOC(" No where condition.\n").
-spec none() -> cake@internal@read_query:where().
none() ->
    no_where.

-file("src/cake/where.gleam", 540).
?DOC(" Creates a `WHERE` clause that checks if a `WhereValue` matches a `Bool`.\n").
-spec is_bool(cake@internal@read_query:where_value(), boolean()) -> cake@internal@read_query:where().
is_bool(Value, Bool) ->
    _pipe = Value,
    {where_is_bool, _pipe, Bool}.

-file("src/cake/where.gleam", 546).
?DOC(
    " Creates a `WHERE` clause that checks if a `WhereValue` does not match a\n"
    " `Bool`.\n"
).
-spec is_not_bool(cake@internal@read_query:where_value(), boolean()) -> cake@internal@read_query:where().
is_not_bool(Value, Bool) ->
    _pipe = Value,
    {where_is_not_bool, _pipe, Bool}.

-file("src/cake/where.gleam", 551).
?DOC(" Creates a `WHERE` clause that checks if a `WhereValue` is `False`.\n").
-spec is_false(cake@internal@read_query:where_value()) -> cake@internal@read_query:where().
is_false(Value) ->
    _pipe = Value,
    {where_is_bool, _pipe, false}.

-file("src/cake/where.gleam", 556).
?DOC(" Creates a `WHERE` clause that checks if a `WhereValue` is `True`.\n").
-spec is_true(cake@internal@read_query:where_value()) -> cake@internal@read_query:where().
is_true(Value) ->
    _pipe = Value,
    {where_is_bool, _pipe, true}.

-file("src/cake/where.gleam", 562).
?DOC(" Creates a `WHERE` clause that checks if a `WhereValue` is SQL `NULL`.\n").
-spec is_null(cake@internal@read_query:where_value()) -> cake@internal@read_query:where().
is_null(Value) ->
    {where_is_null, Value}.

-file("src/cake/where.gleam", 568).
?DOC(" Creates a `WHERE` clause that checks if a `WhereValue` is not SQL `NULL`.\n").
-spec is_not_null(cake@internal@read_query:where_value()) -> cake@internal@read_query:where().
is_not_null(Value) ->
    {where_is_not_null, Value}.

-file("src/cake/where.gleam", 575).
?DOC(
    " Creates a `WHERE` clause that checks if a `WhereValue` equals another\n"
    " `WhereValue`.\n"
).
-spec eq(
    cake@internal@read_query:where_value(),
    cake@internal@read_query:where_value()
) -> cake@internal@read_query:where().
eq(Value_a, Value_b) ->
    {where_comparison, Value_a, equal, Value_b}.

-file("src/cake/where.gleam", 582).
?DOC(
    " Creates a `WHERE` clause that checks if a `WhereValue` lower than another\n"
    " `WhereValue`.\n"
).
-spec lt(
    cake@internal@read_query:where_value(),
    cake@internal@read_query:where_value()
) -> cake@internal@read_query:where().
lt(Value_a, Value_b) ->
    {where_comparison, Value_a, lower, Value_b}.

-file("src/cake/where.gleam", 589).
?DOC(
    " Creates a `WHERE` clause that checks if a `WhereValue` lower or equal to\n"
    " another `WhereValue`.\n"
).
-spec lte(
    cake@internal@read_query:where_value(),
    cake@internal@read_query:where_value()
) -> cake@internal@read_query:where().
lte(Value_a, Value_b) ->
    {where_comparison, Value_a, lower_or_equal, Value_b}.

-file("src/cake/where.gleam", 596).
?DOC(
    " Creates a `WHERE` clause that checks if a `WhereValue` is greater than\n"
    " another `WhereValue`.\n"
).
-spec gt(
    cake@internal@read_query:where_value(),
    cake@internal@read_query:where_value()
) -> cake@internal@read_query:where().
gt(Value_a, Value_b) ->
    {where_comparison, Value_a, greater, Value_b}.

-file("src/cake/where.gleam", 603).
?DOC(
    " Creates a `WHERE` clause that checks if a `WhereValue` is greater or equal\n"
    " to another `WhereValue`.\n"
).
-spec gte(
    cake@internal@read_query:where_value(),
    cake@internal@read_query:where_value()
) -> cake@internal@read_query:where().
gte(Value_a, Value_b) ->
    {where_comparison, Value_a, greater_or_equal, Value_b}.

-file("src/cake/where.gleam", 610).
?DOC(
    " Creates a `WHERE` clause that checks if a `WhereValue` is not equal to\n"
    " another `WhereValue`.\n"
).
-spec neq(
    cake@internal@read_query:where_value(),
    cake@internal@read_query:where_value()
) -> cake@internal@read_query:where().
neq(Value_a, Value_b) ->
    {where_comparison, Value_a, unequal, Value_b}.

-file("src/cake/where.gleam", 619).
?DOC(
    " Creates a `WHERE` clause that checks if a `WhereValue` matches any\n"
    " in a sub-query.\n"
    "\n"
    " NOTICE: Not supported by 🪶SQLite.\n"
).
-spec eq_any_query(
    cake@internal@read_query:where_value(),
    cake@internal@read_query:read_query()
) -> cake@internal@read_query:where().
eq_any_query(Value, Query) ->
    {where_any_of_sub_query, Value, equal, Query}.

-file("src/cake/where.gleam", 631).
?DOC(
    " Creates a `WHERE` clause that checks if a `WhereValue` is lower than an any\n"
    " in a sub-query.\n"
    "\n"
    " NOTICE: Not supported by 🪶SQLite.\n"
).
-spec lt_any_query(
    cake@internal@read_query:where_value(),
    cake@internal@read_query:read_query()
) -> cake@internal@read_query:where().
lt_any_query(Value, Query) ->
    {where_any_of_sub_query, Value, lower, Query}.

-file("src/cake/where.gleam", 643).
?DOC(
    " Creates a `WHERE` clause that checks if a `WhereValue` is lower or equal to\n"
    " any in a sub-query.\n"
    "\n"
    " NOTICE: Not supported by 🪶SQLite.\n"
).
-spec lte_any_query(
    cake@internal@read_query:where_value(),
    cake@internal@read_query:read_query()
) -> cake@internal@read_query:where().
lte_any_query(Value, Query) ->
    {where_any_of_sub_query, Value, lower_or_equal, Query}.

-file("src/cake/where.gleam", 655).
?DOC(
    " Creates a `WHERE` clause that checks if a `WhereValue` is greater than any\n"
    " in a sub-query.\n"
    "\n"
    " NOTICE: Not supported by 🪶SQLite.\n"
).
-spec gt_any_query(
    cake@internal@read_query:where_value(),
    cake@internal@read_query:read_query()
) -> cake@internal@read_query:where().
gt_any_query(Value, Query) ->
    {where_any_of_sub_query, Value, greater, Query}.

-file("src/cake/where.gleam", 667).
?DOC(
    " Creates a `WHERE` clause that checks if a `WhereValue` is greater or equal\n"
    " to any in a sub-query.\n"
    "\n"
    " NOTICE: Not supported by 🪶SQLite.\n"
).
-spec gte_any_query(
    cake@internal@read_query:where_value(),
    cake@internal@read_query:read_query()
) -> cake@internal@read_query:where().
gte_any_query(Value, Query) ->
    {where_any_of_sub_query, Value, greater_or_equal, Query}.

-file("src/cake/where.gleam", 679).
?DOC(
    " Creates a `WHERE` clause that checks if a `WhereValue` is not equal to any\n"
    " in a sub-query.\n"
    "\n"
    " NOTICE: Not supported by 🪶SQLite.\n"
).
-spec neq_any_query(
    cake@internal@read_query:where_value(),
    cake@internal@read_query:read_query()
) -> cake@internal@read_query:where().
neq_any_query(Value, Query) ->
    {where_any_of_sub_query, Value, unequal, Query}.

-file("src/cake/where.gleam", 691).
?DOC(
    " Creates a `WHERE` clause that checks if a `WhereValue` matches all\n"
    " in a sub-query.\n"
    "\n"
    " NOTICE: Not supported by 🪶SQLite.\n"
).
-spec eq_all_query(
    cake@internal@read_query:where_value(),
    cake@internal@read_query:read_query()
) -> cake@internal@read_query:where().
eq_all_query(Value, Query) ->
    {where_all_of_sub_query, Value, equal, Query}.

-file("src/cake/where.gleam", 703).
?DOC(
    " Creates a `WHERE` clause that checks if a `WhereValue` is lower than all\n"
    " in a sub-query.\n"
    "\n"
    " NOTICE: Not supported by 🪶SQLite.\n"
).
-spec lt_all_query(
    cake@internal@read_query:where_value(),
    cake@internal@read_query:read_query()
) -> cake@internal@read_query:where().
lt_all_query(Value, Query) ->
    {where_all_of_sub_query, Value, lower, Query}.

-file("src/cake/where.gleam", 715).
?DOC(
    " Creates a `WHERE` clause that checks if a `WhereValue` is lower or equal to\n"
    " all in a sub-query.\n"
    "\n"
    " NOTICE: Not supported by 🪶SQLite.\n"
).
-spec lte_all_query(
    cake@internal@read_query:where_value(),
    cake@internal@read_query:read_query()
) -> cake@internal@read_query:where().
lte_all_query(Value, Query) ->
    {where_all_of_sub_query, Value, lower_or_equal, Query}.

-file("src/cake/where.gleam", 727).
?DOC(
    " Creates a `WHERE` clause that checks if a `WhereValue` is greater than all\n"
    " in a sub-query.\n"
    "\n"
    " NOTICE: Not supported by 🪶SQLite.\n"
).
-spec gt_all_query(
    cake@internal@read_query:where_value(),
    cake@internal@read_query:read_query()
) -> cake@internal@read_query:where().
gt_all_query(Value, Query) ->
    {where_all_of_sub_query, Value, greater, Query}.

-file("src/cake/where.gleam", 739).
?DOC(
    " Creates a `WHERE` clause that checks if a `WhereValue` is greater or equal\n"
    " to all in a sub-query.\n"
    "\n"
    " NOTICE: Not supported by 🪶SQLite.\n"
).
-spec gte_all_query(
    cake@internal@read_query:where_value(),
    cake@internal@read_query:read_query()
) -> cake@internal@read_query:where().
gte_all_query(Value, Query) ->
    {where_all_of_sub_query, Value, greater_or_equal, Query}.

-file("src/cake/where.gleam", 751).
?DOC(
    " Creates a `WHERE` clause that checks if a `WhereValue` is not equal to all\n"
    " in a sub-query.\n"
    "\n"
    " NOTICE: Not supported by 🪶SQLite.\n"
).
-spec neq_all_query(
    cake@internal@read_query:where_value(),
    cake@internal@read_query:read_query()
) -> cake@internal@read_query:where().
neq_all_query(Value, Query) ->
    {where_all_of_sub_query, Value, unequal, Query}.

-file("src/cake/where.gleam", 762).
?DOC(
    " Creates a `WHERE` clause that checks if a `WhereValue` is IN a sub-query.\n"
    "\n"
    " NOTICE: Usually the sub-query must return a single column.\n"
).
-spec in_query(
    cake@internal@read_query:where_value(),
    cake@internal@read_query:read_query()
) -> cake@internal@read_query:where().
in_query(Value, Query) ->
    {where_in, Value, [{where_sub_query_value, Query}]}.

-file("src/cake/where.gleam", 769).
?DOC(
    " Creates a `WHERE` clause that checks if a `WhereValue` is in a list of\n"
    " `WhereValue`s.\n"
).
-spec in(
    cake@internal@read_query:where_value(),
    list(cake@internal@read_query:where_value())
) -> cake@internal@read_query:where().
in(Value, Values) ->
    {where_in, Value, Values}.

-file("src/cake/where.gleam", 775).
?DOC(" Creates a `WHERE` clause that checks if it exists in a sub-query.\n").
-spec exists_in_query(cake@internal@read_query:read_query()) -> cake@internal@read_query:where().
exists_in_query(Query) ->
    {where_exists_in_sub_query, Query}.

-file("src/cake/where.gleam", 787).
?DOC(
    " Creates a `WHERE` clause that checks if a `WhereValue` A is between two\n"
    " `WhereValue`s B and C.\n"
).
-spec between(
    cake@internal@read_query:where_value(),
    cake@internal@read_query:where_value(),
    cake@internal@read_query:where_value()
) -> cake@internal@read_query:where().
between(Value_a, Value_b, Value_c) ->
    {where_between, Value_a, Value_b, Value_c}.

-file("src/cake/where.gleam", 801).
?DOC(
    " Creates a `WHERE` clause that checks if a `WhereValue` matches a pattern.\n"
    " The pattern can contain for example the following wildcards:\n"
    "\n"
    " - `%` matches any sequence of characters.\n"
    " - `_` matches any single character.\n"
).
-spec like(cake@internal@read_query:where_value(), binary()) -> cake@internal@read_query:where().
like(Value, Pattern) ->
    {where_like, Value, Pattern}.

-file("src/cake/where.gleam", 809).
?DOC(
    " Creates a `WHERE` clause that checks if a `WhereValue` matches a pattern.\n"
    "\n"
    " `ilike` is the same as `like` but case-insensitive.\n"
).
-spec ilike(cake@internal@read_query:where_value(), binary()) -> cake@internal@read_query:where().
ilike(Value, Pattern) ->
    {where_i_like, Value, Pattern}.

-file("src/cake/where.gleam", 818).
?DOC(
    " Creates a `WHERE` clause that checks if a `WhereValue` is similar to a\n"
    " pattern.\n"
    "\n"
    " NOTICE: Not supported by 🪶SQLite.\n"
).
-spec similar_to(cake@internal@read_query:where_value(), binary(), binary()) -> cake@internal@read_query:where().
similar_to(Value, Pattern, Escape_char) ->
    {where_similar_to, Value, Pattern, Escape_char}.

-file("src/cake/where.gleam", 828).
?DOC(" Creates a `WhereFragment` from a `Fragment`.\n").
-spec fragment(cake@internal@read_query:fragment()) -> cake@internal@read_query:where().
fragment(Fragment) ->
    {where_fragment, Fragment}.