PostgreSQL provides a fast-path interface to send function calls to the backend. This is a trapdoor into system internals and can be a potential security hole. Most users will not need this feature.
PQfn
	Request execution of a backend function via the fast-path interface.
PGresult* PQfn(PGconn* conn,
               int fnid,
               int *result_buf,
               int *result_len,
               int result_is_int,
               const PQArgBlock *args,
               int nargs);
     The fnid argument is the object identifier of the function to be
     executed.
     result_buf is the buffer in which
     to place the return value.  The caller must  have  allocated
     sufficient space to store the return value (there is no check!).
     The actual result length will be returned in the integer pointed
     to  by  result_len.   If a 4-byte integer result is expected, set
     result_is_int to 1; otherwise set it to 0.  (Setting result_is_int to 1
     tells libpq to byte-swap the value if necessary, so that it is
     delivered as a proper int value for the client machine.  When
     result_is_int is 0, the byte string sent by the backend is returned
     unmodified.)
     args and nargs specify the arguments to be passed to the function.
typedef struct {
    int len;
    int isint;
    union {
        int *ptr;
        int integer;
    } u;
} PQArgBlock;
     PQfn always returns a valid PGresult*. The result status
     should be checked before the result is used.   The
     caller is responsible for  freeing  the  PGresult  with
     PQclear when it is no longer needed.