使用SQL函数而不是SELECT的优点

Question

In a Postgresql 9.0 database, I can create a url for a webpage with a SELECT statement using an integer (profile_id) in the WHERE clause.

In the past I've simply done this SELECT whenever it is convenient, for instance using a subquery as a column/field in a view. But I recently realized I could create a SQL function to do the same thing. (This is a SQL function, NOT plpgsql).

I want to know if there is an advantage , mostly in terms of resources that are being spent, in using a function rather than a SELECT in a case like this? See below and thanks in advance. I could not find anything on this topic elsewhere on this site. (Long-time reader, first-time caller).

The function is below.

CREATE OR REPLACE FUNCTION msurl(integer)
RETURNS text AS
$BODY$    
SELECT (('https://www.thenameofmywebsite/'::text || 
    CASE
        WHEN prof.type = 1 THEN 'm'::text
        ELSE 'f'::text
    END) || '/handler/'::text) || prof.profile_id AS profile_url
FROM profile prof
WHERE prof.profile_id = $1;
$BODY$
LANGUAGE sql

To get my url I can either use

SELECT prof.name,     
SELECT (('https://www.thenameofmywebsite/'::text || 
    CASE
        WHEN prof.type = 1 THEN 'm'::text
        ELSE 'f'::text
    END) || '/handler/'::text) || prof.profile_id AS profile_url, prof.start_date
FROM profile prof, 
WHERE prof.profile_id = id_number;

OR the tidier version:

SELECT prof.name, msurl(id_number) as profile_url, prof.start_date FROM profile prof;

Answer 1

The way you are using the function will not have any advantage - the opposite is the case: it will slow down your select drastically. Because for each row that is retrieved from the main select statement (the one calling the function) you are running another select on the same table.

Functions do have an advantage when you want to encapsulate the logic of building the url. But you need to write the function differently to be more efficient by passing it the row you want to work with:

CREATE OR REPLACE FUNCTION msurl(profile)
RETURNS text AS
$BODY$    
SELECT (('https://www.thenameofmywebsite/' || 
    CASE
        WHEN $1.type = 1 THEN 'm'
        ELSE 'f'
    END) || '/handler/' || $1.profile_id:: AS profile_url;
$BODY$
LANGUAGE sql;

Another option would have been to pass all columns that you need separately, but by passing the row (type) the function signature (and thus calls to it) will not need to be changed if the logic changes and you need more or less columns from the table.

You can then call this with the following syntax:

SELECT prof.name, 
       msurl( (prof) ) as profile_url, 
       prof.start_date 
FROM profile prof;

Note that the alias must be enclosed in parentheses (prof) when passing it to the function. The additional parentheses are not optional here.

That way the function still gets called for each row, but it doesn't run another select on the profile table.

Due to the object oriented way Postgres treats such a function you can even call it as it it was a column of the table:

SELECT prof.name, 
       prof.msurl as profile_url, 
       prof.start_date 
FROM profile prof;

Answer 2

Sense of functions (sql functions) is encapsulation. With functions some fragments of your SQL statements has name, semantics - you can reuse it, you can build a libraries. There are no any other benefits like performance - it has impact just only on your code readability.