SSQL, обертка для генерации sql

ssql.hrl

-ifndef(__SSQL_SSQL__).
-define(__SSQL_SSQL__, true).


-define(SVAR,       "$").
-define(SDOT,       ".").
-define(SCOMMA,     ",").
-define(SWC,        " ").
-define(SLBR,       "(").
-define(SRBR,       ")").

%%% -----------------------------------------------------------------

-define(SSELECT,            "select").
-define(SFROM,              "from").

-define(SWHERE,             "where").

-define(SAS,                "as").

-define(SINSERT,            "insert into").
-define(SVALUES,            "values").
-define(SUPDATE,            "update").
-define(SDELETE,            "delete from").

-define(SJOIN,              "join").
-define(SON,                "on").

-define(SSET,               "set").
-define(SIN,                "in").
-define(SNOTIN,             "not in").
-define(SUNION,             "union").
-define(SAND,               "and").
-define(SOR,                "or").
-define(SEQ,                "=").
-define(SNEQ,               "!=").
-define(SLT,                "<").
-define(SGT,                ">").
-define(SASSIGN,            "=").

-define(SRETURNING,         "returning").

%%% -----------------------------------------------------------------

% -> fun /1
-define(s1,
    convert:to_list
).

% -> fun /2
-define(s2,
    lists:append
).

% -> E
-define(s(E),
    ?s1(E)
).

% -> E1E2
-define(s(E1, E2),
    ?s2(?s(E1), ?s(E2))
).

% -> E1E2E3
-define(s(E1, E2, E3),
    ?s(E1, ?s(E2, E3))
).

% -> E1E2E3E4
-define(s(E1, E2, E3, E4),
    ?s(?E1, ?s(E2, E3, E4))
).

% -> (E)
-define(sbr(E),
    ?s(?SLBR, E, ?SRBR)
).

% -> ' 'E' '
-define(swc(E),
    ?s(?SWC, E, ?SWC)
).

% -> E1 E2
-define(swc(E1, E2),
    ?s(E1, ?SWC, E2)
).


% -> E1.E2
-define(sdot(E1, E2),
    ?s(E1, ?SDOT, E2)
).

-define(scomma(E1, E2),
    ?s(E1, ?SCOMMA, E2)
).

% -> $E
-define(svar(E),
    ?s(?SVAR, E)
).

% -> ' 'Op' '
-define(sop(Op),
    ?swc(Op)
).

% -> Op E1
-define(sop(Op, E1),
    ?swc(Op, E1)
).

% -> E1 Op E2
-define(sop(E1, Op, E2),
    ?s(E1, ?sop(Op), E2)
).

% -> E1 union E2
-define(sunion(E1, E2),
    ?sop(
        ?sbr(E1),
        ?SUNION,
        ?sbr(E2)
    )
).

% -> E1 in (E2)
-define(sin(E1, E2),
    ?sop(
        E1,
        ?SIN,
        ?sbr(E2)
    )
).

% -> E1 not in (E2)
-define(snotin(E1, E2),
    ?sop(
        E1,
        ?SNOTIN,
        ?sbr(E2)
    )
).

% -> E1 and E2
-define(sand(E1, E2),
    ?sop(E1, ?SAND, E2)
).

% -> E1 or E2
-define(sor(E1, E2),
    ?sop(E1, ?SOR, E2)
).

% -> E1 as E2
-define(sas(E1, E2),
    ?sop(E1, ?SAS, E2)
).

% -> E1 Op E2
-define(scmp(E1, Op, E2),
    ?sop(E1, Op, E2)
).

-define(scmpvar(E1, Op, E2),
    ?sop(E1, Op, ?svar(E2))
).


% -> E1 = E2
-define(seq(E1, E2),
    ?scmp(E1, ?SEQ, E2)
).

% -> E1 = $E2
-define(seqvar(E1, E2),
    ?scmpvar(E1, ?SEQ, E2)
).

% -> E1 != E2
-define(sneq(E1, E2),
    ?scmp(E1, ?SNEQ, E2)
).

% -> E1 != $E2
-define(sneqvar(E1, E2),
    ?scmpvar(E1, ?SNEQ, E2)
).

% -> E1 < E2
-define(slt(E1, E2),
    ?scmp(E1, ?SLT, E2)
).

% -> E1 < $E2
-define(sltvar(E1, E2),
    ?scmpvar(E1, ?SLT, E2)
).

% -> E1 > E2
-define(sgt(E1, E2),
    ?scmp(E1, ?SGT, E2)
).

% -> E1 > $E2
-define(sgtvar(E1, E2),
    ?scmpvar(E1, ?SGT, E2)
).


% -> E1 = E2
-define(sassign(E1, E2),
    ?sop(E1, ?SASSIGN, E2)
).


-define(sassignvar(E1, E2),
    ?sassign(E1, ?svar(E2))
).

-define(sassignvar(E),
    ?sassignvar(E, E)
).


% -> E1 = E2
-define(sto(E1, E2),
    ?sassign(E1, E2)
).

% -> I1,I2,I3,...
-define(slist(List, Fun),
    string:join(
        [
            Fun(Item) || Item <- List
        ],
        ?SCOMMA
    )
).

% -> I1,I2,I3,...
-define(slist(List),
    ?slist(List, ?s1)
).

% -> $I1,$I2,$I3,...
-define(slistvar(List),
    ?slist(List, fun(X) -> ?svar(X) end)
).

% -> I1 = $I1,I1 = $I2,I3 = $I3,...
-define(slistassignvar(List),
    ?slist(List, fun(X) -> ?sassignvar(X) end)
).

% -> (O, M1), (O, M2), ...
-define(slistone2many(One, Many),
    ?slist(Many, fun(X) -> ?sbr(?scomma(One, X)) end)
).

%%% -----------------------------------------------------------------

-define(sselect(E),
    ?sop(?SSELECT, E)
).


-define(sfrom(E),
    ?sop(?SFROM, E)
).

-define(swhere(E),
    ?sop(?SWHERE, E)
).

-define(sif(E),
    ?swhere(E)
).

-define(sinsert(E),
    ?sop(?SINSERT, E)
).

-define(supdate(E),
    ?sop(?SUPDATE, E)
).

-define(sset(E),
    ?sop(?SSET, E)
).

-define(svalues(E),
    ?sop(?SVALUES, E)
).

-define(sreturning(E),
    ?sop(?SRETURNING, E)
).

-define(sdelete(T),
    ?sop(?SDELETE, T)
).

-define(sjoin(T),
    ?sop(?SJOIN, T)
).

-define(son(T),
    ?sop(?SON, T)
).


%%% -----------------------------------------------------------------
%%%
%%% Макросы sselect и sget отличаются порядком аргументов,
%%% Для sselect оставлен естественный порядок
%%%     <что>, <откуда>, <почему>
%%%

%%% 
%%% ?sselect(
%%%     [id, login],
%%%     ?sfrom(customer)
%%% ).
%%%
-define(sselect(F, P),
    ?sop(?sselect(?slist(F)), P)
).

%%%
%%% ?sselect(
%%%     [id, login],
%%%     ?sfrom(customer),
%%%     ?swhere("id = $id")
%%% ).
%%%
-define(sselect(F, P1, P2),
    ?sop(?sselect(F, P1), P2)
).

%%%
%%% ?sselect(
%%%     [id, login],
%%%     ?sfrom(customer),
%%%     ?sjoin(
%%%         customer_type,
%%%         ?son(
%%%             ?seq(
%%%                 customer_type.id,
%%%                 customer.type_id
%%%             )
%%%         )
%%%     ),
%%%     ?swhere("id = $id")
%%% ).
%%%
-define(sselect(F, P1, P2, P3),
    ?sop(?sselect(F, P1, P2), P3)
).


%%%
%%% ?sselectf(
%%%     [id, login],
%%%     customer
%%% ).
%%%
-define(sselectf(F, T),
    ?sselect(F, ?sfrom(T))
).

%%%
%%% ?sselectf(
%%%     [id, login],
%%%     customer,
%%%     ?swhere("id = $id")
%%% ).
%%%
-define(sselectf(F, T, W),
    ?sop(?sselectf(F, T), W)
).

%%%
%%% ?sselectfw(
%%%     [id, login],
%%%     customer,
%%%     "id = $id"
%%% ).
%%%
-define(sselectfw(F, T, W),
    ?sselectf(F, T, ?swhere(W))
).

%%%
%%% ?sget(
%%%     customer,
%%%     [id, login]
%%% ).
%%%
-define(sget(T, F),
    ?sselectf(F, T)
).

%%%
%%% ?sget(
%%%     customer,
%%%     [id, login],
%%%     ?sif("id = $id")
%%% ).
%%%
-define(sget(T, F, P),
    ?sselectf(F, T, P)
).

%%%
%%% ?sget(
%%%     customer,
%%%     [id, login],
%%%     "id = $id"
%%% ).
%%%
-define(sgetc(T, F, W),
    ?sselectf(F, T, ?sif(W))
).


%%% -----------------------------------------------------------------

-define(sinsert_into(T, F),
    ?sop(
        ?sop(
            ?sinsert(T),
            ?sbr(?slist(F))
        ),
        ?SVALUES
    )
).

-define(sinsert_into(T, F, P),
    ?sop(
        ?sinsert_into(T, F),
        P
    )
).

-define(sinsert(T, F),
    ?sinsert_into(
        T,
        F,
        ?sbr(
            ?slistvar(F)
        )
    )
).

-define(sinsert_one2many(T, F, O, M),
    ?sinsert_into(
        T,
        F, 
        ?slistone2many(O, M)
    )
).


-define(sinsert(T, F, P),
    ?sop(
        ?sinsert(T, F),
        ?s(P)
    )
).

-define(sinsertret(T, F, P),
    ?sinsert(
        T,
        F,
        ?sreturning(P)
    )
).


-define(supdate(T, F),
    ?sop(
        ?supdate(T),
        ?sset(
            ?slistassignvar(F)
        )
    )
).

-define(supdate(T, F, P),
    ?sop(
        ?supdate(T, F),
        P
    )
).

-define(supdate_where(T, F, W),
    ?sop(
        ?supdate(T, F),
        ?swhere(W)
    )
).

-define(sdelete(T, P),
    ?sop(?sdelete(T), P)
).

-define(sdelete_where(T, W),
    ?sdelete(T, ?swhere(W))
).

-define(sjoin(T, P),
    ?sop(?sjoin(T), P)
).

-define(sjoin(T, O, P),
    ?sop(?sjoin(T, O), P)
).

-define(sljoin(T, P),
    ?sop(left, ?sjoin(T, P))
).

-define(sljoin(T, O, P),
    ?sop(left, ?sjoin(T, O, P))
).

-define(srjoin(T, P),
    ?sop(right, ?sjoin(T, P))
).

-define(srjoin(T, O, P),
    ?sop(right, ?sjoin(T, O, P))
).

-define(son(F, P),
    ?sop(?son(F), P)
).

-define(sjoinon(T, F),
    ?sop(?sjoin(T), ?son(F))
).

-define(sjoinon(T, F, P),
    ?sop(?sjoinon(T, F), P)
).



-endif. %%% __SSQL_SSQL__

Создает строки вида "select name from table where id = $id", Все выражения типа "$<что-то>" заменяются или на реальные значения, или на $1, $2 ... , как того требует https://github.com/wg/epgsql