Extrair texto após a ocorrência N

select array_to_string((string_to_array('1:723:NVDA:NSDQ::Z4189274321:Snapshot Report:10:COMPUTER & TECHNOLOGY:241:Semiconductor', ':'))[3:], ':');

NVDA:NSDQ::Z4189274321:Snapshot Report:10:COMPUTER & TECHNOLOGY:241:Semiconductor

Isto usa string_to_arraydaqui:

https://www.postgresql.org/docs/current/functions-string.html

string_to_array ( string texto, delimitador texto [, null_string texto ] ) → texto[]

Divide a string em ocorrências de delimiter e forma os campos resultantes em uma matriz de texto. Se delimiter for NULL, cada caractere na string se tornará um elemento separado na matriz. Se delimiter for uma string vazia, a string será tratada como um único campo. Se null_string for fornecido e não for NULL, os campos correspondentes a essa string serão substituídos por NULL. Veja também array_to_string.

string_to_array('xx~~yy~~zz', '~~', 'yy') → {xx,NULL,zz}

Isso quebra a string em suas partes componentes e faz um array delas. O [3:]seleciona do terceiro ao fim dos elementos do array do array.

Então daqui:

https://www.postgresql.org/docs/current/functions-array.html

array_to_string ( array qualquerarray, delimitador texto [, null_string texto ] ) → texto

Converte cada elemento do array para sua representação de texto e concatena aqueles separados pela string delimitadora. Se null_string for fornecido e não for NULL, então entradas NULL do array serão representadas por essa string; caso contrário, elas serão omitidas. Veja também string_to_array.

array_to_string(ARRAY[1, 2, 3, NULO, 5], ',', ' ') → 1,2,3, ,5

Isso reconstitui a string concatenando os elementos da matriz com o delimitador.

O mais curto

substring()com uma expressão regular:

SELECT substring(string, '^.+?:.+?:(.*$)');

A expressão regular explicada:

^... âncora no início da string (opcional)
.... qualquer caractere
+?... 1 ou mais vezes, não ganancioso
:... o caractere literal
(2 vezes)
(.*$)... qualquer caractere 0 ou mais vezes, ganancioso; na captura de parênteses

test=> SELECT substring('1:723:NVDA:NSDQ::Z4189274321:Snapshot Report:10:COMPUTER & TECHNOLOGY:241:Semiconductor', '^.+?:.+?:(.*$)');
                                     substring                                     
-----------------------------------------------------------------------------------
 NVDA:NSDQ::Z4189274321:Snapshot Report:10:COMPUTER & TECHNOLOGY:241:Semiconductor
(1 row)

Mais rápido

Se o desempenho importa...

O acima é simples e curto, então ele tem um desempenho decente. Mas expressões regulares são caras. Até mesmo converter (custoso) para um array e voltar como Adrian demonstra é tipicamente mais rápido.

Isso é algumas vezes mais rápido do que qualquer coisa sugerida até agora:

SELECT substring(string, length(split_part(string, ':', 1))
                       + length(split_part(string, ':', 2))
                       + 3);

Este retorna uma matriz, dividindo o conteúdo em:

SELECT (regexp_split_to_array('1:723:NVDA:NSDQ::Z4189274321:Snapshot Report:10:COMPUTER & TECHNOLOGY:241:Semiconductor',':'))[3:];

Se você precisar de uma única string:

SELECT array_to_string((regexp_split_to_array('1:723:NVDA:NSDQ::Z4189274321:Snapshot Report:10:COMPUTER & TECHNOLOGY:241:Semiconductor',':'))[3:], ':');

Este usa uma expressão regular para dividir o conteúdo e também retorna uma matriz, mas apenas um elemento, o que é fácil de converter em uma única string:

SELECT (regexp_matches('1:723:NVDA:NSDQ::Z4189274321:Snapshot Report:10:COMPUTER & TECHNOLOGY:241:Semiconductor', '^[^:]*:[^:]*:(.*)', 'g'))[1];

O seguinte demonstra o uso de NULLIFand REGEXP_REPLACEcom a expressão regular ^(([^:]*:){2}(.*))|(.*)para extrair a parte de uma string que ocorre após um segundo :, ou NULLse não houver caracteres após o segundo ::

WITH
  test_cases (id, test_value, expected_result) AS (
    VALUES
      (1, NULL, NULL),
      (2, '', NULL),
      (3, '1:', NULL),
      (4, '1:2:', NULL),
      (5, '1:2: ', ' '),
      (6,
       '1:723:NVDA:NSDQ::Z4189274321:Snapshot Report:10:COMPUTER & TECHNOLOGY:241:Semiconductor',
        'NVDA:NSDQ::Z4189274321:Snapshot Report:10:COMPUTER & TECHNOLOGY:241:Semiconductor'
      )
  ),
  runs AS (
    SELECT
      tc.id,
      tc.test_value,
      tc.expected_result,
      NULLIF(
        REGEXP_REPLACE(tc.test_value, '^(([^:]*:){2}(.*))|(.*)', '\3'),
        ''
      ) AS actual_result
    FROM
      test_cases tc
  )
SELECT
  runs.id,
  runs.expected_result IS NOT DISTINCT FROM runs.actual_result AS passed,
  runs.actual_result
FROM
  runs
ORDER BY
  runs.id;

O script a seguir mede a sobrecarga associada à geração de strings de teste (expressão de teste s.string||gs.n::TEXT) e o tempo de execução para cada uma das quatro expressões que retornam a parte da string que ocorre após a segunda ::

DROP TABLE IF EXISTS test_runs;

CREATE TEMPORARY TABLE test_runs (
  id INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
  test_case INTEGER,
  test_expression TEXT,
  execution_time_ms NUMERIC
);

DO language plpgsql $BLOCK$
DECLARE
  number_of_iterations CONSTANT INTEGER := 100;
  number_of_rows CONSTANT INTEGER := 10000;
  test_expressions CONSTANT TEXT[] := ARRAY[
    $$s.string||gs.n::TEXT$$,
    $$SUBSTRING(s.string||gs.n::TEXT, '^.+?:.+?:(.*$)')$$,
    $$ARRAY_TO_STRING((STRING_TO_ARRAY(s.string||gs.n::TEXT, ':'))[3:], ':')$$,
    $$ARRAY_TO_STRING((REGEXP_SPLIT_TO_ARRAY(s.string||gs.n::TEXT, ':'))[3:], ':')$$,
    $$REGEXP_REPLACE(s.string||gs.n::TEXT, '^(([^:]*:){2}(.*))|(.*)', '\3')$$
  ];
  iteration INTEGER;
  results JSON;
  test_case INTEGER;
  test_run INTEGER := 0;
BEGIN
  FOR iteration IN 1 .. number_of_iterations LOOP
    FOR test_case IN 1 .. CARDINALITY(test_expressions) LOOP
      EXECUTE
        FORMAT($$
          EXPLAIN (ANALYZE, FORMAT JSON)
          SELECT %1$s
            FROM
              (VALUES ('1:723:NVDA:NSDQ::Z4189274321:Snapshot Report:10:COMPUTER & TECHNOLOGY:241:Semiconductor')) s(string)
              CROSS JOIN GENERATE_SERIES(1, $2) gs(n);$$,
          test_expressions[test_case])
        INTO results
        USING test_case, number_of_rows;
      INSERT INTO test_runs(test_case, test_expression, execution_time_ms)
      VALUES (test_case, test_expressions[test_case], (results -> 0 ->> 'Execution Time')::NUMERIC);
    END LOOP;
  END LOOP;
END;
$BLOCK$;

SELECT AVG(execution_time_ms)::NUMERIC(18,3) AS mean_execution_time_ms, test_expression
  FROM test_runs
  GROUP BY test_case, test_expression
  ORDER BY mean_execution_time_ms, test_case;