Definir o valor padrão de uma coluna para a concatenação dos valores de duas outras colunas?

Use um gatilho.

Aqui está um código que você pode usar como base. Se você também precisar lidar com UPDATEs, apenas uma pequena alteração será necessária.

 create table people
 (
   first_name varchar(20),
   last_name varchar(20),
   display_name varchar(40)
 );
CREATE TABLE
 CREATE OR REPLACE FUNCTION people_insert() RETURNS trigger AS '
     BEGIN
         NEW.display_name := NEW.first_name||'' ''||NEW.last_name;
         RETURN NEW;
     END;
 ' LANGUAGE plpgsql;

 postgres=# CREATE FUNCTION


 CREATE TRIGGER people_insert BEFORE INSERT OR UPDATE ON people FOR 
 EACH ROW EXECUTE PROCEDURE people_insert();

postgres=# CREATE TRIGGER
 insert into people values ('Larry','Ellison');

postgres=# INSERT 0 1

 postgres=# select * from people;
 first_name | last_name | display_name
------------+-----------+---------------
 Larry      | Ellison   | Larry Ellison
(1 row)

postgres=#

Você não precisa realmente armazenar o valor; você pode criar uma função que pode ser referenciada como uma coluna gerada. A única ressalva é que as referências devem sempre ser qualificadas com o nome da tabela ou do alias.

CREATE TABLE person
  (
    id int PRIMARY KEY,
    first_name text,
    last_name text NOT NULL
  );

INSERT INTO person
  VALUES
    (1, 'John', 'Smith'),
    (2, 'Jane', 'Doe'),
    (3, NULL, 'Prince');

CREATE FUNCTION display_name(rec person)
  RETURNS text
  STABLE
  LANGUAGE SQL
  COST 5
AS $$
  SELECT
    CASE
      WHEN $1.first_name IS NULL THEN ''
      ELSE $1.first_name || ' '
    END || $1.last_name;
$$;

SELECT p.id, p.display_name FROM person p;

Os resultados:

identificação | Nome em Exibição
----+--------------
  1 | John Smith
  2 | Jane Doe
  3 | Principe
(3 linhas)

Você pode até indexar o valor gerado, inclusive usando pesquisas KNN com base na semelhança de trigramas. Por exemplo:

CREATE EXTENSION pg_trgm;

CREATE INDEX person_trgm_name
  ON person
  USING gist
  (display_name(person) gist_trgm_ops);

SELECT
    p.id,
    p.display_name,
    similarity(p.display_name, 'Jane')
  FROM person p
  ORDER BY p.display_name <-> 'Jane'
  LIMIT 2;

Esse tipo de pesquisa retorna linhas da varredura de índice em ordem de "distância" da string de pesquisa. Se você quiser ver o quão "perto" eles estavam, você pode usar o operador de distância ( <->) ou a similarity()função (que é 1 - distância). Uma pesquisa KNN pode retornar os K "vizinhos mais próximos" muito rapidamente, mesmo com um conjunto de dados muito grande.

Com a configuração DEFAULT em uma tabela de colunas, não.

Sua melhor aposta aqui é um TRIGGER com o valor NOVO para cada coluna que você deseja computar.

Use Colunas Geradas (desde Postgres 12).

CREATE TABLE users (
                       first_name   text NOT NULL,
                       last_name    text NOT NULL,
                       full_name    text, -- we can overwrite the display name here
                       display_name text GENERATED ALWAYS AS (coalesce(full_name, first_name || ' ' || last_name)) STORED
);

DB Fiddle