¿Cómo convierto una cadena a entero y tengo 0 en caso de error en la conversión con PostgreSQL?

En PostgreSQL tengo una tabla con una columna varchar. Se supone que los datos son enteros y los necesito en tipo entero en una consulta. Algunos valores son cadenas vacías. El seguimiento:

SELECT myfield::integer FROM mytable

rendimientos ERROR: invalid input syntax for integer: ""

¿Cómo puedo consultar un elenco y tener 0 en caso de error durante el elenco en postgres?

Estaba luchando con un problema similar, pero no quería la sobrecarga de una función. Se me ocurrió la siguiente consulta:

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

Postgres ataja sus condicionales, por lo que no deberías obtener ningún no entero que golpee tu :: número entero. También maneja valores NULL (no coincidirán con la expresión regular).

Si desea ceros en lugar de no seleccionar, entonces una declaración CASE debería funcionar:

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

También puede crear su propia función de conversión, dentro de la cual puede usar bloques de excepción:

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;

Pruebas:

=# 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)

Tenía el mismo tipo de necesidad y encontré que esto funcionaba bien para mí (postgres 8.4):

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

Algunos casos de prueba para demostrar:

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"

Si necesita manejar la posibilidad de que el campo tenga texto no numérico (como "100bad"), puede usar regexp_replace para quitar caracteres no numéricos antes de la conversión.

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

Luego, los valores de texto / varchar como "b3ad5" también darán números

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

Para abordar la preocupación de Chris Cogdon con la solución de no dar 0 para todos los casos, incluido un caso como "incorrecto" (sin caracteres de dígitos), hice esta declaración ajustada:

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

Funciona de manera similar a las soluciones más simples, excepto que dará 0 cuando el valor a convertir sea solo caracteres que no sean dígitos, como "incorrecto":

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

Esto podría ser algo así como un truco, pero hizo el trabajo en nuestro caso:

(0 || myfield)::integer

Explicación (Probado en Postgres 8.4):

La expresión mencionada anteriormente produce NULLvalores NULL en myfieldy 0para cadenas vacías (este comportamiento exacto puede o no ajustarse a su caso de uso).

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

Datos de prueba:

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 consulta arrojará el siguiente resultado:

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

Mientras que select solo values::integerdará como resultado un mensaje de error.

Espero que esto ayude.

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

Nunca he trabajado con PostgreSQL pero revisé el manual para ver la sintaxis correcta de las declaraciones IF en las consultas SELECT.

La respuesta de @ Matthew es buena. Pero puede ser más simple y más rápido. Y la pregunta pide convertir cadenas vacías ( '') a 0, pero no a otra "sintaxis de entrada no válida" o entrada "fuera de rango":

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;

Esto devuelve 0para una cadena vacía y NULLpara cualquier otra entrada no válida.
Se puede adaptar fácilmente para cualquier conversión de tipo de datos .

Entrar en un bloque de excepción es sustancialmente más costoso. Si las cadenas vacías son comunes , tiene sentido detectar ese caso antes de generar una excepción.
Si las cadenas vacías son muy raras, vale la pena mover la prueba a la cláusula de excepción.

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

Esta función siempre regresará 0si no hay dígitos en la cadena de entrada.

SELECT parse_int('test12_3test');

volverá 123

Encontré el siguiente código fácil y funcional. La respuesta original está aquí 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)

Espero eso ayude

SUBSTRING puede ayudar en algunos casos, puede limitar el tamaño de la int.

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

Si se supone que los datos son enteros, y solo necesita esos valores como enteros, ¿por qué no hace todo lo posible y convierte la columna en una columna entera?

Entonces podría hacer esta conversión de valores ilegales a ceros solo una vez, en el punto del sistema donde los datos se insertan en la tabla.

Con la conversión anterior, está obligando a Postgres a convertir esos valores una y otra vez para cada fila individual en cada consulta para esa tabla; esto puede degradar seriamente el rendimiento si realiza muchas consultas en esta columna de esta tabla.

La siguiente función hace

• use un valor predeterminado ( error_result) para resultados no convertibles, p. ej.abc o999999999999999999999999999999999999999999
• mantiene null comonull
• recorta espacios y otros espacios en blanco en la entrada
• los valores emitidos como válidos bigintsse comparan lower_boundpara, por ejemplo, imponer valores positivos únicamente

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;

También tengo la misma necesidad, pero eso funciona con JPA 2.0 e Hibernate 5.0.2:

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

Funciona de maravillas. Creo que también funciona con LIKE.

Esto también debería hacer el trabajo, pero esto es a través de SQL y no específico de postgres.

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