Come faccio a trasmettere una stringa in numero intero e ho 0 in caso di errore nel cast con PostgreSQL?

In PostgreSQL ho una tabella con una colonna varchar. I dati dovrebbero essere numeri interi e ne ho bisogno in un numero intero in una query. Alcuni valori sono stringhe vuote. Il seguente:

SELECT myfield::integer FROM mytable

i rendimenti ERROR: invalid input syntax for integer: ""

Come posso eseguire una query su un cast e avere 0 in caso di errore durante il cast in postgres?

Stavo solo lottando con un problema simile, ma non volevo il sovraccarico di una funzione. Ho trovato la seguente domanda:

SELECT myfield::integer FROM mytable WHERE myfield ~ E'^\\d+$';

Postgres abbrevia i suoi condizionali, quindi non dovresti avere nessun non intero che colpisce il tuo cast :: integer. Gestisce anche i valori NULL (non corrisponderanno al regexp).

Se vuoi zeri invece di non selezionarli, allora un'istruzione CASE dovrebbe funzionare:

SELECT CASE WHEN myfield~E'^\\d+$' THEN myfield::integer ELSE 0 END FROM mytable;

È inoltre possibile creare la propria funzione di conversione, all'interno della quale è possibile utilizzare blocchi di eccezioni:

CREATE OR REPLACE FUNCTION convert_to_integer(v_input text)
RETURNS INTEGER AS $$
DECLARE v_int_value INTEGER DEFAULT NULL;
BEGIN
    BEGIN
        v_int_value := v_input::INTEGER;
    EXCEPTION WHEN OTHERS THEN
        RAISE NOTICE 'Invalid integer value: "%".  Returning NULL.', v_input;
        RETURN NULL;
    END;
RETURN v_int_value;
END;
$$ LANGUAGE plpgsql;

test:

=# select convert_to_integer('1234');
 convert_to_integer 
--------------------
               1234
(1 row)

=# select convert_to_integer('');
NOTICE:  Invalid integer value: "".  Returning NULL.
 convert_to_integer 
--------------------

(1 row)

=# select convert_to_integer('chicken');
NOTICE:  Invalid integer value: "chicken".  Returning NULL.
 convert_to_integer 
--------------------

(1 row)

Avevo lo stesso tipo di necessità e ho trovato che funzionava bene per me (Postgres 8.4):

CAST((COALESCE(myfield,'0')) AS INTEGER)

Alcuni casi di test per dimostrare:

db=> select CAST((COALESCE(NULL,'0')) AS INTEGER);
 int4
------
    0
(1 row)

db=> select CAST((COALESCE('','0')) AS INTEGER);
 int4
------
    0
(1 row)

db=> select CAST((COALESCE('4','0')) AS INTEGER);
 int4
------
    4
(1 row)

db=> select CAST((COALESCE('bad','0')) AS INTEGER);
ERROR:  invalid input syntax for integer: "bad"

Se è necessario gestire la possibilità che il campo contenga testo non numerico (come "100bad"), è possibile utilizzare regexp_replace per rimuovere i caratteri non numerici prima del cast.

CAST(REGEXP_REPLACE(COALESCE(myfield,'0'), '[^0-9]+', '', 'g') AS INTEGER)

Quindi anche valori text / varchar come "b3ad5" forniranno numeri

db=> select CAST(REGEXP_REPLACE(COALESCE('b3ad5','0'), '[^0-9]+', '', 'g') AS INTEGER);
 regexp_replace
----------------
             35
(1 row)

Per rispondere alla preoccupazione di Chris Cogdon con la soluzione che non fornisce 0 per tutti i casi, incluso un caso come "cattivo" (nessun carattere di cifre), ho fatto questa dichiarazione modificata:

CAST((COALESCE(NULLIF(REGEXP_REPLACE(myfield, '[^0-9]+', '', 'g'), ''), '0')) AS INTEGER);

Funziona in modo simile alle soluzioni più semplici, tranne che fornirà 0 quando il valore da convertire è solo caratteri non numerici, come "cattivo":

db=> select CAST((COALESCE(NULLIF(REGEXP_REPLACE('no longer bad!', '[^0-9]+', '', 'g'), ''), '0')) AS INTEGER);
     coalesce
----------
        0
(1 row)

Questo potrebbe essere un po 'un trucco, ma ha fatto il lavoro nel nostro caso:

(0 || myfield)::integer

Spiegazione (Testato su Postgres 8.4):

L'espressione sopra menzionata produce NULLvalori NULL in myfielde 0per stringhe vuote (questo comportamento esatto può o meno adattarsi al caso d'uso).

SELECT id, (0 || values)::integer from test_table ORDER BY id

Dati di test:

CREATE TABLE test_table
(
  id integer NOT NULL,
  description character varying,
  "values" character varying,
  CONSTRAINT id PRIMARY KEY (id)
)

-- Insert Test Data
INSERT INTO test_table VALUES (1, 'null', NULL);
INSERT INTO test_table VALUES (2, 'empty string', '');
INSERT INTO test_table VALUES (3, 'one', '1');

La query produrrà il seguente risultato:

 ---------------------
 |1|null        |NULL|
 |2|empty string|0   |
 |3|one         |1   |
 ---------------------

Considerando che solo selezionare values::integergenererà un messaggio di errore.

Spero che questo ti aiuti.

SELECT CASE WHEN myfield="" THEN 0 ELSE myfield::integer END FROM mytable

Non ho mai lavorato con PostgreSQL ma ho controllato il manuale per la sintassi corretta delle istruzioni IF nelle query SELECT.

@La risposta di Matthew è buona. Ma può essere più semplice e veloce. E la domanda chiede di convertire stringhe vuote ( '') in 0, ma non altre "sintassi di input non valide" o input "fuori intervallo":

CREATE OR REPLACE FUNCTION convert_to_int(text)
  RETURNS int AS
$func$
BEGIN
   IF $1 = '' THEN  -- special case for empty string like requested
      RETURN 0;
   ELSE
      RETURN $1::int;
   END IF;

EXCEPTION WHEN OTHERS THEN
   RETURN NULL;  -- NULL for other invalid input

END
$func$  LANGUAGE plpgsql IMMUTABLE;

Questo ritorna 0per una stringa vuota e NULLper qualsiasi altro input non valido.
Può essere facilmente adattato per qualsiasi conversione di tipo di dati .

L'immissione di un blocco di eccezioni è sostanzialmente più costosa. Se le stringhe vuote sono comuni , ha senso catturare quel caso prima di sollevare un'eccezione.
Se le stringhe vuote sono molto rare, vale la pena spostare il test nella clausola di eccezione.

CREATE OR REPLACE FUNCTION parse_int(s TEXT) RETURNS INT AS $$
BEGIN
  RETURN regexp_replace(('0' || s), '[^\d]', '', 'g')::INT;
END;
$$ LANGUAGE plpgsql;

Questa funzione tornerà sempre 0se non ci sono cifre nella stringa di input.

SELECT parse_int('test12_3test');

sarà di ritorno 123

Ho trovato il seguente codice semplice e funzionante. La risposta originale è qui https://www.postgresql.org/message-id/371F1510.F86C876B@sferacarta.com

prova=> create table test(t text, i integer);
CREATE

prova=> insert into test values('123',123);
INSERT 64579 1

prova=> select cast(i as text),cast(t as int)from test;
text|int4
----+----
123| 123
(1 row)

spero che sia d'aiuto

SUBSTRING può aiutare in alcuni casi, è possibile limitare la dimensione dell'int.

SELECT CAST(SUBSTRING('X12312333333333', '([\d]{1,9})') AS integer);

Se i dati dovrebbero essere numeri interi e hai bisogno solo di quei valori come numeri interi, perché non percorri l'intero miglio e converti la colonna in una colonna intera?

Quindi potresti fare questa conversione di valori illegali in zero solo una volta, nel punto del sistema in cui i dati sono inseriti nella tabella.

Con la conversione di cui sopra stai forzando Postgres a convertire quei valori ancora e ancora per ogni singola riga in ogni query per quella tabella - questo può compromettere seriamente le prestazioni se fai molte query contro questa colonna in questa tabella.

La seguente funzione fa

• utilizzare un valore predefinito ( error_result) per risultati non calcolabili, ad esempio abco999999999999999999999999999999999999999999
• continua nullcomenull
• taglia gli spazi e altri spazi bianchi in input
• i valori espressi come validi bigintsvengono confrontati con, lower_boundad esempio, impongono solo valori positivi

CREATE OR REPLACE FUNCTION cast_to_bigint(text) 
RETURNS BIGINT AS $$
DECLARE big_int_value BIGINT DEFAULT NULL;
DECLARE error_result  BIGINT DEFAULT -1;
DECLARE lower_bound   BIGINT DEFAULT 0;
BEGIN
    BEGIN
        big_int_value := CASE WHEN $1 IS NOT NULL THEN GREATEST(TRIM($1)::BIGINT, lower_bound) END;
    EXCEPTION WHEN OTHERS THEN
        big_int_value := error_result;
    END;
RETURN big_int_value;
END;

Ho anche lo stesso bisogno, ma funziona con JPA 2.0 e Hibernate 5.0.2:

SELECT p FROM MatchProfile p WHERE CONCAT(p.id, '') = :keyword

Funziona a meraviglia. Penso che funzioni anche con LIKE.

Questo dovrebbe fare anche il lavoro, ma questo è su SQL e non specifico per Postgres.

select avg(cast(mynumber as numeric)) from my table