Extend timestamp type handling in sql macros

prefiks · prefiks · commit 7a5319251e80 · 2025-12-05T19:42:31.000+01:00
diff --git a/include/ejabberd_sql.hrl b/include/ejabberd_sql.hrl
@@ -36,11 +36,14 @@
 		    flags :: non_neg_integer(),
 		    loc :: {module(), {pos_integer(), pos_integer()}}}).
 
--record(sql_escape, {string :: fun((binary()) -> binary()),
-		     integer :: fun((integer()) -> binary()),
-		     boolean :: fun((boolean()) -> binary()),
-		     in_array_string :: fun((binary()) -> binary()),
-		     like_escape :: fun(() -> binary())}).
+-record(sql_escape, {
+          string :: fun((binary()) -> binary() | atom()),
+          integer :: fun((integer()) -> binary() | atom()),
+          boolean :: fun((boolean()) -> binary() | atom()),
+          timestamp :: fun((calendar:datetime()) -> binary() | atom()),
+          in_array_string :: fun((binary()) -> binary() | atom()),
+          like_escape :: fun(() -> binary() | atom())
+         }).
 
 
 -record(sql_index, {columns,
diff --git a/src/ejabberd_sql.erl b/src/ejabberd_sql.erl
@@ -52,6 +52,7 @@
          to_string_literal/2,
          to_string_literal_t/1,
 	 to_bool/1,
+         to_timestamp/2,
 	 sqlite_db/1,
 	 sqlite_file/1,
 	 encode_term/1,
@@ -286,6 +287,23 @@ to_bool(true) -> true;
 to_bool(1) -> true;
 to_bool(_) -> false.
 
+escape_timestamp({{Y, Mo, D}, {H, Mi, S}}) ->
+    list_to_binary(io_lib:format("~4..0B-~2..0B-~2..0B "
+                                 "~2..0B:~2..0B:~2..0B",
+                                 [Y, Mo, D, H, Mi, S])).
+
+
+to_timestamp({Y, {H, M, S, _}}, mysql_prepared) -> {Y, {H, M, S}};
+to_timestamp(<<TS:64/signed-big-integer>>, pgsql_prepared) ->
+    calendar:gregorian_seconds_to_datetime(
+      calendar:datetime_to_gregorian_seconds({{2000, 1, 1}, {0, 0, 0}}) + TS div 1_000_000);
+to_timestamp(<<Y:4/binary, $-, Mo:2/binary, $-, D:2/binary, " ",
+               H:2/binary, $:, Mi:2/binary, $:, S:2/binary>>,
+             _) ->
+    {{binary_to_integer(Y), binary_to_integer(Mo), binary_to_integer(D)},
+     {binary_to_integer(H), binary_to_integer(Mi), binary_to_integer(S)}}.
+
+
 to_list(EscapeFun, Val) ->
     Escaped = lists:join(<<",">>, lists:map(EscapeFun, Val)),
     [<<"(">>, Escaped, <<")">>].
@@ -813,7 +831,8 @@ select_sql_query([{_, _} | Rest], Type, Version, Query) ->
 generic_sql_query(SQLQuery) ->
     sql_query_format_res(
       sql_query_internal(generic_sql_query_format(SQLQuery)),
-      SQLQuery).
+      SQLQuery,
+      generic).
 
 generic_sql_query_format(SQLQuery) ->
     Args = (SQLQuery#sql_query.args)(generic_escape()),
@@ -825,14 +844,16 @@ generic_escape() ->
 		boolean = fun(true) -> <<"1">>;
                              (false) -> <<"0">>
                           end,
+      timestamp = fun(X) -> <<"'", (escape_timestamp(X))/binary, "'">> end,
 		in_array_string = fun(X) -> <<"'", (escape(X))/binary, "'">> end,
                 like_escape = fun() -> <<"">> end
                }.
 
 pgsql_sql_query(SQLQuery) ->
     sql_query_format_res(
       sql_query_internal(pgsql_sql_query_format(SQLQuery)),
-      SQLQuery).
+      SQLQuery,
+      pgsql).
 
 pgsql_sql_query_format(SQLQuery) ->
     Args = (SQLQuery#sql_query.args)(pgsql_escape()),
@@ -844,14 +865,16 @@ pgsql_escape() ->
 		boolean = fun(true) -> <<"'t'">>;
                              (false) -> <<"'f'">>
                           end,
+      timestamp = fun(X) -> <<"E'", (escape_timestamp(X))/binary, "'">> end,
 		in_array_string = fun(X) -> <<"E'", (escape(X))/binary, "'">> end,
                 like_escape = fun() -> <<"ESCAPE E'\\\\'">> end
                }.
 
 sqlite_sql_query(SQLQuery) ->
     sql_query_format_res(
       sql_query_internal(sqlite_sql_query_format(SQLQuery)),
-      SQLQuery).
+      SQLQuery,
+      sqlite).
 
 sqlite_sql_query_format(SQLQuery) ->
     Args = (SQLQuery#sql_query.args)(sqlite_escape()),
@@ -863,6 +886,7 @@ sqlite_escape() ->
 		boolean = fun(true) -> <<"1">>;
                              (false) -> <<"0">>
                           end,
+      timestamp = fun(X) -> <<"'", (escape_timestamp(X))/binary, "'">> end,
 		in_array_string = fun(X) -> <<"'", (standard_escape(X))/binary, "'">> end,
                 like_escape = fun() -> <<"ESCAPE '\\'">> end
                }.
@@ -894,12 +918,15 @@ pgsql_prepare(SQLQuery, State) ->
     Query = (SQLQuery#sql_query.format_query)(Args),
     pgsql:prepare(State#state.db_ref, SQLQuery#sql_query.hash, Query).
 
+
 pgsql_execute_escape() ->
-    #sql_escape{string = fun(X) -> X end,
-		integer = fun(X) -> [misc:i2l(X)] end,
-		boolean = fun(true) -> "1";
-                             (false) -> "0"
-                          end,
+    #sql_escape{
+      string = fun(X) -> X end,
+      integer = fun(X) -> misc:i2l(X) end,
+      boolean = fun(true) -> <<"1">>;
+                   (false) -> <<"0">>
+                end,
+      timestamp = fun escape_timestamp/1,
 		in_array_string = fun(X) -> <<"\"", (escape(X))/binary, "\"">> end,
                 like_escape = fun() -> ignore end
                }.
@@ -913,33 +940,46 @@ pgsql_execute_sql_query(SQLQuery, State) ->
 %        timer:tc(pgsql, execute, [State#state.db_ref, SQLQuery#sql_query.hash, Args]),
 %    io:format("T ~ts ~p~n", [SQLQuery#sql_query.hash, T]),
     Res = pgsql_execute_to_odbc(ExecuteRes),
-    sql_query_format_res(Res, SQLQuery).
+    sql_query_format_res(Res, SQLQuery, pgsql_prepared).
+
 
 mysql_prepared_execute(#sql_query{hash = Hash} = Query, State) ->
-    ValEsc = #sql_escape{like_escape = fun() -> ignore end, _ = fun(X) -> X end},
-    TypesEsc = #sql_escape{string = fun(_) -> string end,
-			   integer = fun(_) -> integer end,
-			   boolean = fun(_) -> bool end,
+    ValEsc = #sql_escape{
+               like_escape = fun() -> ignore end,
+               timestamp = fun escape_timestamp/1,
+               _ = fun(X) -> X end
+              },
+    TypesEsc = #sql_escape{
+                 string = fun(_) -> string end,
+                 integer = fun(_) -> integer end,
+                 boolean = fun(_) -> bool end,
+                 timestamp = fun(_) -> string end,
 			   in_array_string = fun(_) -> string end,
 			   like_escape = fun() -> ignore end},
     Val = [X || X <- (Query#sql_query.args)(ValEsc), X /= ignore],
     Types = [X || X <- (Query#sql_query.args)(TypesEsc), X /= ignore],
     QueryFn = fun() ->
-	PrepEsc = #sql_escape{like_escape = fun() -> <<>> end, _ = fun(_) -> <<"?">> end},
-	(Query#sql_query.format_query)((Query#sql_query.args)(PrepEsc))
-	end,
+                      PrepEsc = #sql_escape{like_escape = fun() -> <<>> end, _ = fun(_) -> <<"?">> end},
+                      (Query#sql_query.format_query)((Query#sql_query.args)(PrepEsc))
+              end,
     QueryTimeout = query_timeout(State#state.host),
-    Res = p1_mysql_conn:prepared_query(State#state.db_ref, QueryFn, Hash, Val, Types,
-				       self(), [{timeout, QueryTimeout - 1000}]),
+    Res = p1_mysql_conn:prepared_query(State#state.db_ref,
+                                       QueryFn,
+                                       Hash,
+                                       Val,
+                                       Types,
+                                       self(),
+                                       [{timeout, QueryTimeout - 1000}]),
     Res2 = mysql_to_odbc(Res),
-    sql_query_format_res(Res2, Query).
+    sql_query_format_res(Res2, Query, mysql_prepared).
+
 
-sql_query_format_res({selected, _, Rows}, SQLQuery) ->
+sql_query_format_res({selected, _, Rows}, SQLQuery, DbType) ->
     Res =
         lists:flatmap(
           fun(Row) ->
                   try
-                      [(SQLQuery#sql_query.format_res)(Row)]
+                      [(SQLQuery#sql_query.format_res)(Row, DbType)]
                   catch
                       Class:Reason:StackTrace ->
                           ?ERROR_MSG("Error while processing SQL query result:~n"
@@ -950,7 +990,7 @@ sql_query_format_res({selected, _, Rows}, SQLQuery) ->
                   end
           end, Rows),
     {selected, Res};
-sql_query_format_res(Res, _SQLQuery) ->
+sql_query_format_res(Res, _SQLQuery, _DbType) ->
     Res.
 
 sql_query_to_iolist(SQLQuery) ->
diff --git a/src/ejabberd_sql_pt.erl b/src/ejabberd_sql_pt.erl
@@ -293,7 +293,10 @@ parse1([$@, $( | S], Acc, State) ->
             string ->
                 EVar;
             timestamp ->
-                EVar;
+                erl_syntax:application(
+                  erl_syntax:atom(ejabberd_sql),
+                  erl_syntax:atom(to_timestamp),
+                  [EVar, erl_syntax:variable("__DbType")]);
             boolean ->
                 erl_syntax:application(
                   erl_syntax:atom(ejabberd_sql),
@@ -364,19 +367,16 @@ parse1([$%, $( | S], Acc, State) ->
                              param_pos = State2#state.param_pos + 1,
                              used_vars = [Name | State2#state.used_vars]};
             _ ->
-                {TS, Type2} = case Type of
-                            timestamp -> {true, string};
-                            Other -> {State2#state.need_timestamp_pass, Other}
-                        end,
                 Convert =
                     erl_syntax:application(
                       erl_syntax:record_access(
                         erl_syntax:variable(?ESCAPE_VAR),
                         erl_syntax:atom(?ESCAPE_RECORD),
-                        erl_syntax:atom(Type2)),
+                        erl_syntax:atom(Type)),
                       [erl_syntax:variable(Name)]),
-                State2#state{'query' = [{var, Var, Type} | State2#state.'query'],
-                             need_timestamp_pass = TS,
+                State2#state{
+                  'query' = [{var, Var, Type} | State2#state.'query'],
+                  need_timestamp_pass = Type == timestamp orelse State2#state.need_timestamp_pass,
                              args = [Convert | State2#state.args],
                              params = [Var | State2#state.params],
                              param_pos = State2#state.param_pos + 1,
@@ -532,7 +532,7 @@ make_sql_query(State, Type) ->
        erl_syntax:atom(format_res),
         erl_syntax:fun_expr(
           [erl_syntax:clause(
-             [erl_syntax:list(State#state.res_vars)],
+              [erl_syntax:list(State#state.res_vars), erl_syntax:variable("__DbType")],
              none,
              [erl_syntax:tuple(State#state.res)]
             )])),
diff --git a/src/mod_muc_sql.erl b/src/mod_muc_sql.erl
@@ -147,8 +147,8 @@ store_room(LServer, Host, Name, Opts, ChangesHints) ->
 		    end,
     SOpts = misc:term_to_expr(Opts2),
     Timestamp = case lists:keyfind(hibernation_time, 1, Opts) of
-		    false -> <<"1970-01-02 00:00:00">>;
-		    {_, undefined} -> <<"1970-01-02 00:00:00">>;
+                    false -> {{1970, 1, 2}, {0, 0, 0}};
+                    {_, undefined} -> {{1970, 1, 2}, {0, 0, 0}};
 		    {_, Time} -> usec_to_sql_timestamp(Time)
 		end,
     F = fun () ->
@@ -759,9 +759,4 @@ clean_tables(ServerHost) ->
 
 usec_to_sql_timestamp(Timestamp) ->
     TS = misc:usec_to_now(Timestamp),
-    case calendar:now_to_universal_time(TS) of
-	{{Year, Month, Day}, {Hour, Minute, Second}} ->
-	    list_to_binary(io_lib:format("~4..0B-~2..0B-~2..0B "
-					 "~2..0B:~2..0B:~2..0B",
-					 [Year, Month, Day, Hour, Minute, Second]))
-    end.
+    calendar:now_to_universal_time(TS).
