Current section
Files
Jump to
Current section
Files
src/sqlode@query_parser.erl
-module(sqlode@query_parser).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/sqlode/query_parser.gleam").
-export([error_to_string/1, parse_file/4]).
-export_type([parse_error/0, pending_query/0]).
-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.
-type parse_error() :: {invalid_annotation, binary(), integer(), binary()} |
{missing_sql, binary(), integer(), binary()} |
{invalid_placeholder,
binary(),
integer(),
binary(),
sqlode@model:engine(),
binary()} |
{wrong_engine_upsert,
binary(),
integer(),
binary(),
sqlode@model:engine(),
binary()} |
{sparse_numbered_placeholders,
binary(),
integer(),
binary(),
list(integer())}.
-type pending_query() :: {pending_query,
binary(),
binary(),
sqlode@runtime:query_command(),
integer(),
list(binary())}.
-file("src/sqlode/query_parser.gleam", 355).
-spec extract_line_annotation(binary()) -> gleam@option:option(binary()).
extract_line_annotation(Line) ->
case gleam_stdlib:string_starts_with(Line, <<"-- name:"/utf8>>) of
false ->
none;
true ->
_pipe = Line,
_pipe@1 = gleam@string:replace(
_pipe,
<<"-- name:"/utf8>>,
<<""/utf8>>
),
_pipe@2 = gleam@string:trim(_pipe@1),
{some, _pipe@2}
end.
-file("src/sqlode/query_parser.gleam", 366).
-spec extract_block_annotation(binary()) -> gleam@option:option(binary()).
extract_block_annotation(Line) ->
case gleam_stdlib:string_starts_with(Line, <<"/*"/utf8>>) andalso gleam_stdlib:string_ends_with(
Line,
<<"*/"/utf8>>
) of
false ->
none;
true ->
Inner = begin
_pipe = Line,
_pipe@1 = gleam@string:drop_start(_pipe, 2),
gleam@string:drop_end(_pipe@1, 2)
end,
case gleam_stdlib:contains_string(Inner, <<"*/"/utf8>>) of
true ->
none;
false ->
Inner_trimmed = gleam@string:trim(Inner),
case gleam_stdlib:string_starts_with(
Inner_trimmed,
<<"name:"/utf8>>
) of
false ->
none;
true ->
_pipe@2 = Inner_trimmed,
_pipe@3 = gleam@string:replace(
_pipe@2,
<<"name:"/utf8>>,
<<""/utf8>>
),
_pipe@4 = gleam@string:trim(_pipe@3),
{some, _pipe@4}
end
end
end.
-file("src/sqlode/query_parser.gleam", 348).
?DOC(
" Extracts the annotation payload (the text after `name:` and before any\n"
" terminator) from a trimmed line. Supports both `-- name: ...` and\n"
" `/* name: ... */` forms. Returns None for non-annotation lines so callers\n"
" can treat them as SQL body.\n"
).
-spec extract_annotation_payload(binary()) -> gleam@option:option(binary()).
extract_annotation_payload(Line) ->
case extract_line_annotation(Line) of
{some, Payload} ->
{some, Payload};
none ->
extract_block_annotation(Line)
end.
-file("src/sqlode/query_parser.gleam", 291).
-spec parse_annotation(
sqlode@naming:naming_context(),
binary(),
binary(),
integer()
) -> {ok, gleam@option:option(pending_query())} | {error, parse_error()}.
parse_annotation(Naming_ctx, Line, Path, Line_number) ->
case extract_annotation_payload(Line) of
none ->
{ok, none};
{some, Rest} ->
Parts = begin
_pipe = gleam@string:split(Rest, <<" "/utf8>>),
_pipe@1 = gleam@list:map(_pipe, fun gleam@string:trim/1),
gleam@list:filter(_pipe@1, fun(Part) -> Part /= <<""/utf8>> end)
end,
case Parts of
[Name, Command_text] ->
case gleam_stdlib:string_starts_with(
Command_text,
<<":"/utf8>>
) of
true ->
gleam@result:'try'(
begin
_pipe@2 = sqlode@model:parse_query_command(
Command_text
),
gleam@result:map_error(
_pipe@2,
fun(Detail) ->
{invalid_annotation,
Path,
Line_number,
Detail}
end
)
end,
fun(Command) ->
{ok,
{some,
{pending_query,
Name,
sqlode@naming:to_snake_case(
Naming_ctx,
Name
),
Command,
Line_number,
[]}}}
end
);
false ->
{ok, none}
end;
_ ->
{ok, none}
end
end.
-file("src/sqlode/query_parser.gleam", 393).
-spec is_skip_annotation(binary()) -> boolean().
is_skip_annotation(Line) ->
Line =:= <<"-- sqlode:skip"/utf8>>.
-file("src/sqlode/query_parser.gleam", 452).
-spec is_marker_placeholder(binary()) -> boolean().
is_marker_placeholder(P) ->
gleam_stdlib:string_starts_with(P, <<"__sqlode_param_"/utf8>>) orelse gleam_stdlib:string_starts_with(
P,
<<"__sqlode_slice_"/utf8>>
).
-file("src/sqlode/query_parser.gleam", 457).
-spec extract_marker_index(binary()) -> {ok, integer()} | {error, nil}.
extract_marker_index(P) ->
Body = case gleam_stdlib:string_starts_with(P, <<"__sqlode_param_"/utf8>>) of
true ->
gleam@string:drop_start(P, 15);
false ->
case gleam_stdlib:string_starts_with(P, <<"__sqlode_slice_"/utf8>>) of
true ->
gleam@string:drop_start(P, 15);
false ->
P
end
end,
Without_suffix = case gleam_stdlib:string_ends_with(Body, <<"__"/utf8>>) of
true ->
gleam@string:drop_end(Body, 2);
false ->
Body
end,
gleam_stdlib:parse_int(Without_suffix).
-file("src/sqlode/query_parser.gleam", 404).
?DOC(
" Count parameters from an already-expanded token list.\n"
"\n"
" After macro/`@name` expansion every parameter is represented by a\n"
" `__sqlode_param_<idx>__` or `__sqlode_slice_<idx>__` marker, so the\n"
" parameter count is the highest index that appears. Raw engine\n"
" placeholders (`$1`, `?1`, bare `?`) written directly by the user are\n"
" also counted for back-compat with handwritten SQL.\n"
).
-spec count_parameters_from_tokens(
sqlode@model:engine(),
list(sqlode@lexer:token())
) -> integer().
count_parameters_from_tokens(Engine, Tokens) ->
Placeholders = begin
_pipe = Tokens,
gleam@list:filter_map(_pipe, fun(Token) -> case Token of
{placeholder, P} ->
{ok, P};
_ ->
{error, nil}
end end)
end,
{Markers, Raw} = gleam@list:partition(
Placeholders,
fun(P@1) -> is_marker_placeholder(P@1) end
),
Marker_count = begin
_pipe@1 = Markers,
_pipe@2 = gleam@list:filter_map(_pipe@1, fun extract_marker_index/1),
_pipe@3 = gleam@list:unique(_pipe@2),
erlang:length(_pipe@3)
end,
Raw_count = case Engine of
postgre_s_q_l ->
_pipe@4 = Raw,
_pipe@6 = gleam@list:filter_map(
_pipe@4,
fun(P@2) ->
_pipe@5 = gleam@string:replace(
P@2,
<<"$"/utf8>>,
<<""/utf8>>
),
gleam_stdlib:parse_int(_pipe@5)
end
),
gleam@list:fold(_pipe@6, 0, fun(Max_idx, V) -> case V > Max_idx of
true ->
V;
false ->
Max_idx
end end);
my_s_q_l ->
erlang:length(Raw);
s_q_lite ->
{Anon, Named} = gleam@list:partition(
Raw,
fun(P@3) -> P@3 =:= <<"?"/utf8>> end
),
erlang:length(Anon) + erlang:length(gleam@list:unique(Named))
end,
Marker_count + Raw_count.
-file("src/sqlode/query_parser.gleam", 258).
-spec finalize_ok(
list(sqlode@query_ir:tokenized_query()),
binary(),
binary(),
sqlode@runtime:query_command(),
binary(),
list(sqlode@lexer:token()),
list(sqlode@model:macro()),
sqlode@model:engine()
) -> list(sqlode@query_ir:tokenized_query()).
finalize_ok(
Parsed_rev,
Name,
Function_name,
Command,
Path,
Tokens,
Macros,
Engine
) ->
Expanded_sql = sqlode@lexer:tokens_to_string(
Tokens,
{token_render_options, false, true, {some, Engine}}
),
Param_count = count_parameters_from_tokens(Engine, Tokens),
Parsed = {parsed_query,
Name,
Function_name,
Command,
Expanded_sql,
Path,
Param_count,
Macros},
[{tokenized_query, Parsed, Tokens} | Parsed_rev].
-file("src/sqlode/query_parser.gleam", 524).
-spec format_indices(list(integer())) -> binary().
format_indices(Indices) ->
_pipe = Indices,
_pipe@1 = gleam@list:sort(_pipe, fun gleam@int:compare/2),
_pipe@2 = gleam@list:map(
_pipe@1,
fun(I) -> <<"?"/utf8, (erlang:integer_to_binary(I))/binary>> end
),
gleam@string:join(_pipe@2, <<", "/utf8>>).
-file("src/sqlode/query_parser.gleam", 531).
-spec upsert_hint(sqlode@model:engine()) -> binary().
upsert_hint(Engine) ->
case Engine of
postgre_s_q_l ->
<<"use `ON CONFLICT ... DO UPDATE` or `ON CONFLICT ... DO NOTHING`"/utf8>>;
s_q_lite ->
<<"use `ON CONFLICT ... DO UPDATE` or `ON CONFLICT ... DO NOTHING`"/utf8>>;
my_s_q_l ->
<<"use `ON DUPLICATE KEY UPDATE`"/utf8>>
end.
-file("src/sqlode/query_parser.gleam", 541).
-spec allowed_placeholders_hint(sqlode@model:engine()) -> binary().
allowed_placeholders_hint(Engine) ->
case Engine of
postgre_s_q_l ->
<<"PostgreSQL accepts `$N` or sqlode macros (`@name`, `sqlode.arg(name)`)"/utf8>>;
my_s_q_l ->
<<"MySQL accepts positional `?` or sqlode macros (`sqlode.arg(name)`)"/utf8>>;
s_q_lite ->
<<"SQLite accepts `?`, `?N`, `:name`, `@name`, `$name`, or sqlode macros (`sqlode.arg(name)`)"/utf8>>
end.
-file("src/sqlode/query_parser.gleam", 473).
-spec error_to_string(parse_error()) -> binary().
error_to_string(Error) ->
case Error of
{invalid_annotation, Path, Line, Detail} ->
<<<<<<<<Path/binary, ":"/utf8>>/binary,
(erlang:integer_to_binary(Line))/binary>>/binary,
": invalid query annotation: "/utf8>>/binary,
Detail/binary>>;
{missing_sql, Path@1, Line@1, Name} ->
<<<<<<<<<<Path@1/binary, ":"/utf8>>/binary,
(erlang:integer_to_binary(Line@1))/binary>>/binary,
": query "/utf8>>/binary,
Name/binary>>/binary,
" is missing SQL body"/utf8>>;
{invalid_placeholder, Path@2, Line@2, Name@1, Engine, Token} ->
<<<<<<<<<<<<<<<<<<<<Path@2/binary, ":"/utf8>>/binary,
(erlang:integer_to_binary(
Line@2
))/binary>>/binary,
": query "/utf8>>/binary,
Name@1/binary>>/binary,
": placeholder `"/utf8>>/binary,
Token/binary>>/binary,
"` is not valid for engine "/utf8>>/binary,
(sqlode@model:engine_to_string(Engine))/binary>>/binary,
"; "/utf8>>/binary,
(allowed_placeholders_hint(Engine))/binary>>;
{wrong_engine_upsert, Path@3, Line@3, Name@2, Engine@1, Tail} ->
<<<<<<<<<<<<<<<<<<<<Path@3/binary, ":"/utf8>>/binary,
(erlang:integer_to_binary(
Line@3
))/binary>>/binary,
": query "/utf8>>/binary,
Name@2/binary>>/binary,
": `"/utf8>>/binary,
Tail/binary>>/binary,
"` is not valid for engine "/utf8>>/binary,
(sqlode@model:engine_to_string(Engine@1))/binary>>/binary,
"; "/utf8>>/binary,
(upsert_hint(Engine@1))/binary>>;
{sparse_numbered_placeholders, Path@4, Line@4, Name@3, Indices} ->
<<<<<<<<<<<<<<Path@4/binary, ":"/utf8>>/binary,
(erlang:integer_to_binary(Line@4))/binary>>/binary,
": query "/utf8>>/binary,
Name@3/binary>>/binary,
": sparse SQLite numbered placeholders "/utf8>>/binary,
(format_indices(Indices))/binary>>/binary,
"; numbered placeholders must form a contiguous set starting from ?1 (e.g. ?1, ?2, ?3)"/utf8>>
end.
-file("src/sqlode/query_parser.gleam", 598).
-spec is_positive_int(binary()) -> boolean().
is_positive_int(S) ->
case gleam_stdlib:parse_int(S) of
{ok, N} when N > 0 ->
true;
_ ->
false
end.
-file("src/sqlode/query_parser.gleam", 579).
-spec is_dollar_numbered(binary()) -> boolean().
is_dollar_numbered(P) ->
case gleam_stdlib:string_starts_with(P, <<"$"/utf8>>) of
false ->
false;
true ->
is_positive_int(gleam@string:drop_start(P, 1))
end.
-file("src/sqlode/query_parser.gleam", 586).
-spec is_sqlite_placeholder_syntax(binary()) -> boolean().
is_sqlite_placeholder_syntax(P) ->
case P of
<<"?"/utf8>> ->
true;
_ ->
case gleam@string:first(P) of
{ok, <<"?"/utf8>>} ->
is_positive_int(gleam@string:drop_start(P, 1));
{ok, <<":"/utf8>>} ->
string:length(P) > 1;
{ok, <<"@"/utf8>>} ->
string:length(P) > 1;
{ok, <<"$"/utf8>>} ->
string:length(P) > 1;
_ ->
false
end
end.
-file("src/sqlode/query_parser.gleam", 571).
-spec is_valid_raw_placeholder(sqlode@model:engine(), binary()) -> boolean().
is_valid_raw_placeholder(Engine, P) ->
case Engine of
postgre_s_q_l ->
is_dollar_numbered(P);
my_s_q_l ->
P =:= <<"?"/utf8>>;
s_q_lite ->
is_sqlite_placeholder_syntax(P)
end.
-file("src/sqlode/query_parser.gleam", 556).
?DOC(
" Validate that every raw placeholder token matches the configured engine.\n"
" Sqlode markers (`__sqlode_param_*` / `__sqlode_slice_*`) are always\n"
" accepted because they are produced by macro expansion and are rewritten\n"
" to engine-specific placeholders at prepare-time.\n"
).
-spec validate_placeholder_syntax(
sqlode@model:engine(),
list(sqlode@lexer:token())
) -> {ok, nil} | {error, binary()}.
validate_placeholder_syntax(Engine, Tokens) ->
case Tokens of
[] ->
{ok, nil};
[{placeholder, P} | Rest] ->
case is_marker_placeholder(P) orelse is_valid_raw_placeholder(
Engine,
P
) of
true ->
validate_placeholder_syntax(Engine, Rest);
false ->
{error, P}
end;
[_ | Rest@1] ->
validate_placeholder_syntax(Engine, Rest@1)
end.
-file("src/sqlode/query_parser.gleam", 638).
-spec extract_sqlite_numbered_index(sqlode@lexer:token()) -> {ok, integer()} |
{error, nil}.
extract_sqlite_numbered_index(Token) ->
case Token of
{placeholder, P} ->
case {gleam@string:first(P), string:length(P) > 1} of
{{ok, <<"?"/utf8>>}, true} ->
gleam_stdlib:parse_int(gleam@string:drop_start(P, 1));
{_, _} ->
{error, nil}
end;
_ ->
{error, nil}
end.
-file("src/sqlode/query_parser.gleam", 613).
?DOC(
" Reject sparse SQLite numbered placeholders.\n"
"\n"
" SQLite accepts `?N` with explicit indices, but sqlode's parameter count\n"
" and runtime expansion assume the declared indices form a contiguous set\n"
" starting from 1. A query that uses `?2` alone, or `?1` and `?3` with no\n"
" `?2`, passes lexing but yields generated metadata that does not match the\n"
" SQL text. Flag the mismatch at parse time so users can either renumber\n"
" their placeholders or switch to the bare `?` / `?1, ?2, ...` forms.\n"
).
-spec validate_sqlite_numbered_placeholders(
sqlode@model:engine(),
list(sqlode@lexer:token())
) -> {ok, nil} | {error, list(integer())}.
validate_sqlite_numbered_placeholders(Engine, Tokens) ->
case Engine of
s_q_lite ->
Indices = begin
_pipe = Tokens,
_pipe@1 = gleam@list:filter_map(
_pipe,
fun extract_sqlite_numbered_index/1
),
gleam@list:unique(_pipe@1)
end,
case Indices of
[] ->
{ok, nil};
_ ->
Max_idx = gleam@list:fold(Indices, 0, fun gleam@int:max/2),
case Max_idx =:= erlang:length(Indices) of
true ->
{ok, nil};
false ->
{error, Indices}
end
end;
_ ->
{ok, nil}
end.
-file("src/sqlode/query_parser.gleam", 654).
?DOC(
" Scan tokens for UPSERT tails that do not belong to the configured engine.\n"
" MySQL uses `ON DUPLICATE KEY UPDATE`; PostgreSQL and SQLite use `ON\n"
" CONFLICT ... DO UPDATE/NOTHING`. Accepting the wrong form silently leaks\n"
" dialect-incompatible SQL into generated code, so reject it early with a\n"
" diagnostic that names the offending tail.\n"
).
-spec validate_upsert_tails(sqlode@model:engine(), list(sqlode@lexer:token())) -> {ok,
nil} |
{error, binary()}.
validate_upsert_tails(Engine, Tokens) ->
case Tokens of
[] ->
{ok, nil};
[{keyword, <<"on"/utf8>>}, {ident, Word} | Rest] ->
case {string:lowercase(Word), Engine} of
{<<"duplicate"/utf8>>, my_s_q_l} ->
validate_upsert_tails(Engine, Rest);
{<<"duplicate"/utf8>>, _} ->
{error, <<"ON DUPLICATE KEY UPDATE"/utf8>>};
{_, _} ->
validate_upsert_tails(Engine, Rest)
end;
[{keyword, <<"on"/utf8>>}, {keyword, <<"conflict"/utf8>>} | Rest@1] ->
case Engine of
my_s_q_l ->
{error, <<"ON CONFLICT"/utf8>>};
_ ->
validate_upsert_tails(Engine, Rest@1)
end;
[_ | Rest@2] ->
validate_upsert_tails(Engine, Rest@2)
end.
-file("src/sqlode/query_parser.gleam", 810).
?DOC(" Collect tokens inside macro parens until the matching RParen.\n").
-spec collect_macro_arg_tokens(
list(sqlode@lexer:token()),
integer(),
list(sqlode@lexer:token())
) -> {list(sqlode@lexer:token()), list(sqlode@lexer:token())}.
collect_macro_arg_tokens(Tokens, Depth, Acc) ->
case Depth =< 0 of
true ->
{lists:reverse(Acc), Tokens};
false ->
case Tokens of
[] ->
{lists:reverse(Acc), []};
[l_paren | Rest] ->
collect_macro_arg_tokens(Rest, Depth + 1, [l_paren | Acc]);
[r_paren | Rest@1] ->
case Depth =:= 1 of
true ->
{lists:reverse(Acc), Rest@1};
false ->
collect_macro_arg_tokens(
Rest@1,
Depth - 1,
[r_paren | Acc]
)
end;
[Token | Rest@2] ->
collect_macro_arg_tokens(Rest@2, Depth, [Token | Acc])
end
end.
-file("src/sqlode/query_parser.gleam", 835).
?DOC(
" Extract the argument name from macro arg tokens.\n"
" Handles: Ident(name), StringLit(name), QuotedIdent(name).\n"
).
-spec extract_arg_name(list(sqlode@lexer:token())) -> binary().
extract_arg_name(Tokens) ->
case Tokens of
[{ident, Name}] ->
Name;
[{string_lit, Name@1}] ->
Name@1;
[{quoted_ident, Name@2}] ->
Name@2;
_ ->
_pipe = Tokens,
_pipe@1 = gleam@list:filter_map(_pipe, fun(T) -> case T of
{ident, N} ->
{ok, N};
{string_lit, N@1} ->
{ok, N@1};
{quoted_ident, N@2} ->
{ok, N@2};
_ ->
{error, nil}
end end),
gleam@string:join(_pipe@1, <<""/utf8>>)
end.
-file("src/sqlode/query_parser.gleam", 855).
-spec engine_placeholder(sqlode@model:engine(), integer()) -> binary().
engine_placeholder(_, Index) ->
sqlode@runtime:param_marker(Index).
-file("src/sqlode/query_parser.gleam", 695).
-spec expand_at_loop(
sqlode@model:engine(),
list(sqlode@lexer:token()),
integer(),
gleam@dict:dict(binary(), integer()),
list(sqlode@lexer:token()),
list(sqlode@model:macro())
) -> {list(sqlode@lexer:token()), list(sqlode@model:macro()), integer()}.
expand_at_loop(Engine, Tokens, Idx, Seen, Token_acc, Macro_acc) ->
case Tokens of
[] ->
{lists:reverse(Token_acc), lists:reverse(Macro_acc), Idx};
[{placeholder, P} | Rest] ->
case gleam_stdlib:string_starts_with(P, <<"@"/utf8>>) of
true ->
Name = gleam@string:drop_start(P, 1),
case {Engine, gleam_stdlib:map_get(Seen, Name)} of
{s_q_lite, {ok, Existing_idx}} ->
Placeholder = engine_placeholder(
Engine,
Existing_idx
),
expand_at_loop(
Engine,
Rest,
Idx,
Seen,
[{placeholder, Placeholder} | Token_acc],
Macro_acc
);
{_, _} ->
Placeholder@1 = engine_placeholder(Engine, Idx),
New_seen = case Engine of
s_q_lite ->
gleam@dict:insert(Seen, Name, Idx);
_ ->
Seen
end,
expand_at_loop(
Engine,
Rest,
Idx + 1,
New_seen,
[{placeholder, Placeholder@1} | Token_acc],
[{macro_arg, Idx, Name} | Macro_acc]
)
end;
false ->
expand_at_loop(
Engine,
Rest,
Idx,
Seen,
[{placeholder, P} | Token_acc],
Macro_acc
)
end;
[Token | Rest@1] ->
expand_at_loop(
Engine,
Rest@1,
Idx,
Seen,
[Token | Token_acc],
Macro_acc
)
end.
-file("src/sqlode/query_parser.gleam", 684).
?DOC(
" Expand @name shorthands in the token list.\n"
" For non-MySQL engines, Placeholder(\"@name\") tokens are replaced\n"
" with engine-appropriate placeholders ($N, ?N).\n"
" The lexer only emits Placeholder(\"@...\") when @ is followed by\n"
" alpha/underscore, so @1 is never matched (it becomes Operator+NumberLit).\n"
).
-spec expand_at_name_tokens(
sqlode@model:engine(),
list(sqlode@lexer:token()),
integer()
) -> {list(sqlode@lexer:token()), list(sqlode@model:macro()), integer()}.
expand_at_name_tokens(Engine, Tokens, Start_idx) ->
case Engine of
my_s_q_l ->
{Tokens, [], Start_idx};
_ ->
expand_at_loop(Engine, Tokens, Start_idx, maps:new(), [], [])
end.
-file("src/sqlode/query_parser.gleam", 864).
-spec engine_slice_placeholder(sqlode@model:engine(), integer()) -> binary().
engine_slice_placeholder(_, Index) ->
sqlode@runtime:slice_marker(Index).
-file("src/sqlode/query_parser.gleam", 768).
-spec expand_macro_loop(
sqlode@model:engine(),
list(sqlode@lexer:token()),
integer(),
list(sqlode@lexer:token()),
list(sqlode@model:macro())
) -> {list(sqlode@lexer:token()), list(sqlode@model:macro())}.
expand_macro_loop(Engine, Tokens, Idx, Token_acc, Macro_acc) ->
case Tokens of
[] ->
{lists:reverse(Token_acc), lists:reverse(Macro_acc)};
[{ident, Mod}, dot, {ident, Kind}, l_paren | Rest] when (((Mod =:= <<"sqlode"/utf8>>) orelse (Mod =:= <<"Sqlode"/utf8>>)) orelse (Mod =:= <<"SQLODE"/utf8>>)) andalso (((Kind =:= <<"arg"/utf8>>) orelse (Kind =:= <<"narg"/utf8>>)) orelse (Kind =:= <<"slice"/utf8>>)) ->
{Arg_tokens, Remaining} = collect_macro_arg_tokens(Rest, 1, []),
Name = extract_arg_name(Arg_tokens),
Placeholder = case Kind of
<<"slice"/utf8>> ->
engine_slice_placeholder(Engine, Idx);
_ ->
engine_placeholder(Engine, Idx)
end,
Macro_entry = case Kind of
<<"narg"/utf8>> ->
{macro_narg, Idx, Name};
<<"slice"/utf8>> ->
{macro_slice, Idx, Name};
_ ->
{macro_arg, Idx, Name}
end,
expand_macro_loop(
Engine,
Remaining,
Idx + 1,
[{placeholder, Placeholder} | Token_acc],
[Macro_entry | Macro_acc]
);
[Token | Rest@1] ->
expand_macro_loop(
Engine,
Rest@1,
Idx,
[Token | Token_acc],
Macro_acc
)
end.
-file("src/sqlode/query_parser.gleam", 760).
?DOC(
" Expand sqlode.arg(name), sqlode.narg(name), sqlode.slice(name) macros\n"
" by walking the token list and replacing the token span with a Placeholder.\n"
" Pattern: Ident(\"sqlode\") Dot Ident(\"arg\"|\"narg\"|\"slice\") LParen ...arg... RParen\n"
).
-spec expand_macro_tokens(
sqlode@model:engine(),
list(sqlode@lexer:token()),
integer()
) -> {list(sqlode@lexer:token()), list(sqlode@model:macro())}.
expand_macro_tokens(Engine, Tokens, Start_idx) ->
expand_macro_loop(Engine, Tokens, Start_idx, [], []).
-file("src/sqlode/query_parser.gleam", 177).
-spec finalize_pending(
sqlode@naming:naming_context(),
gleam@option:option(pending_query()),
binary(),
sqlode@model:engine(),
list(sqlode@query_ir:tokenized_query())
) -> {ok, list(sqlode@query_ir:tokenized_query())} | {error, parse_error()}.
finalize_pending(_, Pending, Path, Engine, Parsed_rev) ->
case Pending of
none ->
{ok, Parsed_rev};
{some,
{pending_query, Name, Function_name, Command, Start_line, Body_rev}} ->
Sql = begin
_pipe = Body_rev,
_pipe@1 = lists:reverse(_pipe),
_pipe@2 = gleam@string:join(_pipe@1, <<"\n"/utf8>>),
gleam@string:trim(_pipe@2)
end,
case Sql =:= <<""/utf8>> of
true ->
{error, {missing_sql, Path, Start_line, Name}};
false ->
Tokens = sqlode@lexer:tokenize(Sql, Engine),
{Tokens@1, At_macros, Next_idx} = expand_at_name_tokens(
Engine,
Tokens,
1
),
{Tokens@2, Expanded_macros} = expand_macro_tokens(
Engine,
Tokens@1,
Next_idx
),
Macros = lists:append(At_macros, Expanded_macros),
case validate_placeholder_syntax(Engine, Tokens@2) of
{error, Token} ->
{error,
{invalid_placeholder,
Path,
Start_line,
Name,
Engine,
Token}};
{ok, nil} ->
case validate_upsert_tails(Engine, Tokens@2) of
{error, Tail} ->
{error,
{wrong_engine_upsert,
Path,
Start_line,
Name,
Engine,
Tail}};
{ok, nil} ->
case validate_sqlite_numbered_placeholders(
Engine,
Tokens@2
) of
{error, Indices} ->
{error,
{sparse_numbered_placeholders,
Path,
Start_line,
Name,
Indices}};
{ok, nil} ->
{ok,
finalize_ok(
Parsed_rev,
Name,
Function_name,
Command,
Path,
Tokens@2,
Macros,
Engine
)}
end
end
end
end
end.
-file("src/sqlode/query_parser.gleam", 67).
-spec parse_lines(
sqlode@naming:naming_context(),
list(binary()),
binary(),
sqlode@model:engine(),
integer(),
gleam@option:option(pending_query()),
list(sqlode@query_ir:tokenized_query()),
boolean()
) -> {ok, list(sqlode@query_ir:tokenized_query())} | {error, parse_error()}.
parse_lines(
Naming_ctx,
Lines,
Path,
Engine,
Line_number,
Pending,
Parsed_rev,
Skip_next
) ->
case Lines of
[] ->
finalize_pending(Naming_ctx, Pending, Path, Engine, Parsed_rev);
[Line | Rest] ->
Trimmed = gleam@string:trim(Line),
case is_skip_annotation(Trimmed) of
true ->
gleam@result:'try'(
finalize_pending(
Naming_ctx,
Pending,
Path,
Engine,
Parsed_rev
),
fun(Parsed_rev@1) ->
parse_lines(
Naming_ctx,
Rest,
Path,
Engine,
Line_number + 1,
none,
Parsed_rev@1,
true
)
end
);
false ->
case parse_annotation(
Naming_ctx,
Trimmed,
Path,
Line_number
) of
{ok, {some, Next_pending}} ->
gleam@result:'try'(
finalize_pending(
Naming_ctx,
Pending,
Path,
Engine,
Parsed_rev
),
fun(Parsed_rev@2) -> case Skip_next of
true ->
parse_lines(
Naming_ctx,
Rest,
Path,
Engine,
Line_number + 1,
none,
Parsed_rev@2,
false
);
false ->
parse_lines(
Naming_ctx,
Rest,
Path,
Engine,
Line_number + 1,
{some, Next_pending},
Parsed_rev@2,
false
)
end end
);
{ok, none} ->
Pending@1 = case Pending of
{some,
{pending_query,
Name,
Function_name,
Command,
Start_line,
Body_rev}} ->
{some,
{pending_query,
Name,
Function_name,
Command,
Start_line,
[Line | Body_rev]}};
none ->
none
end,
parse_lines(
Naming_ctx,
Rest,
Path,
Engine,
Line_number + 1,
Pending@1,
Parsed_rev,
Skip_next
);
{error, Error} ->
{error, Error}
end
end
end.
-file("src/sqlode/query_parser.gleam", 48).
-spec parse_file(
binary(),
sqlode@model:engine(),
sqlode@naming:naming_context(),
binary()
) -> {ok, list(sqlode@query_ir:tokenized_query())} | {error, parse_error()}.
parse_file(Path, Engine, Naming_ctx, Content) ->
_pipe = parse_lines(
Naming_ctx,
gleam@string:split(Content, <<"\n"/utf8>>),
Path,
Engine,
1,
none,
[],
false
),
gleam@result:map(_pipe, fun lists:reverse/1).