Se me ocurrió que esta pregunta no sería difícil de responder empíricamente por mi cuenta. Sin embargo, como funcionó, me encontré respondiendo dos preguntas: una planteada por mí, otra planteada por otros que comentaron.

Mi pregunta primero:

 CREATE OR REPLACE FUNCTION sys.return_jsonb_tester(return_code shared.return_code, return_msg shared.return_msg) RETURNS jsonb LANGUAGE plpgsql AS $function$ declare return_jsonb jsonb; BEGIN FOR i IN 1 .. 100000 LOOP -- v1 --SELECT sys.return_jsonb(return_code, return_msg) INTO return_jsonb; -- v2 --SELECT format('{"result": "%s","message": "%s"}', return_code, return_msg)::jsonb INTO return_jsonb; END LOOP; RETURN return_jsonb; END ; $function$ ;

La llamada a la función (v1) tardó aproximadamente 0,2 segundos. la versión en línea (v2) tomó alrededor de 0,2 segundos.

Esencialmente no hay diferencia. Entonces puedo abstraer el código repetitivo sin costo alguno, lo mejor que puedo decir.

Comparto mi pregunta y mi propia respuesta para la próxima persona que pueda encontrar este resultado informativo.

Pero nuestra historia no acaba aquí.

En mi OP, utilicé LANGUAGE plpgsql para la rutina de llamada sys.return_jsonb(). De hecho, en este punto encontré que la llamada era un poco más costosa que la línea, pero no lo suficiente como para preocuparme. Sin embargo, un comentario de_horse_with_no_name sugirió que usara LANGUAGE sql en su lugar.

Probé esta sugerencia. Y fue terriblemente ineficiente salir por la puerta: órdenes de magnitud más lentos. Así que me quedé con LANGUAGE plpgsql .

Luego, otro comentarista, Laurenz Albe, sugirió rehacer, esta vez sin IMMUTABLE. Así que volví a hacer los experimentos. Cuatro sabores como lo implican los nombres proporcionados aquí. Con los tiempos mostrados:

 SELECT sys.sql_immutable('00001', 'It''s awesome!'); -- 1.10s SELECT sys.sql_not_immutable('00001', 'It''s awesome!'); -- 0.19s SELECT sys.plpgsql_immutable('00001', 'It''s awesome!'); -- 0.24s SELECT sys.plpgsql_not_immutable('00001', 'It''s awesome!'); -- 0.26s

Entonces, el resultado de todo esto es que, gracias a estos comentarios, usé la llamada, pero con la estrategia ideal de usar LANGUAGE sql pero no usar IMMUTABLE .

Cuando terminé, la llamada básicamente tenía la misma velocidad que la línea. Los resultados finales son lo que publiqué en la parte superior al responder a mi propia pregunta. No hay costo por usar una llamada. Laurenz señala que "en realidad, se está alineando de esa manera, porque PostgreSQL alineará las funciones de SQL cuando corresponda, y la eliminación de IMMUTABLE lo hizo apropiado en este caso". Los números cuentan la misma historia, así que tiene sentido.

Irónicamente, mi línea de asunto OP preguntó acerca de las llamadas a las funciones IMMUTABLE , pero ahora lo he modificado. Cuando todo estuvo dicho y hecho, la mejor opción fue llamar a una función SQL "MUTABLE".