Comment convertir une chaîne en entier et avoir 0 en cas d'erreur dans le cast avec PostgreSQL?

Dans PostgreSQL, j'ai une table avec une colonne varchar. Les données sont censées être des nombres entiers et j'en ai besoin en type entier dans une requête. Certaines valeurs sont des chaînes vides. Le suivant:

SELECT myfield::integer FROM mytable

rendements ERROR: invalid input syntax for integer: ""

Comment puis-je interroger un casting et avoir 0 en cas d'erreur lors du casting dans postgres?

J'étais moi-même aux prises avec un problème similaire, mais je ne voulais pas les frais généraux d'une fonction. J'ai proposé la requête suivante:

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

Postgres raccourcit ses conditions, donc vous ne devriez pas obtenir de non-entiers qui atteignent votre :: integer cast. Il gère également les valeurs NULL (elles ne correspondent pas à l'expression rationnelle).

Si vous voulez des zéros au lieu de ne pas sélectionner, une instruction CASE devrait fonctionner:

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

Vous pouvez également créer votre propre fonction de conversion, dans laquelle vous pouvez utiliser des blocs d'exception:

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;

Essai:

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

J'avais le même type de besoin et j'ai trouvé que cela fonctionnait bien pour moi (postgres 8.4):

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

Quelques cas de test pour démontrer:

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 vous devez gérer la possibilité que le champ contienne du texte non numérique (tel que "100bad"), vous pouvez utiliser regexp_replace pour supprimer les caractères non numériques avant le cast.

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

Ensuite, les valeurs text / varchar comme "b3ad5" donneront également des nombres

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

Pour répondre à la préoccupation de Chris Cogdon avec la solution ne donnant pas 0 pour tous les cas, y compris un cas tel que «mauvais» (aucun caractère numérique du tout), j'ai fait cette déclaration ajustée:

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

Cela fonctionne de la même manière que les solutions les plus simples, sauf qu'il donnera 0 lorsque la valeur à convertir est uniquement des caractères non numériques, tels que "mauvais":

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

C'est peut-être un peu un hack, mais cela a fait le travail dans notre cas:

(0 || myfield)::integer

Explication (testé sur Postgres 8.4):

L'expression mentionnée ci-dessus donne NULLdes valeurs NULL dans myfieldet 0pour des chaînes vides (ce comportement exact peut ou non correspondre à votre cas d'utilisation).

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

Données de 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 requête donnera le résultat suivant:

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

Alors que sélectionner uniquement values::integerentraînera un message d'erreur.

J'espère que cela t'aides.

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

Je n'ai jamais travaillé avec PostgreSQL mais j'ai vérifié dans le manuel la syntaxe correcte des instructions IF dans les requêtes SELECT.

La réponse de @ Matthew est bonne. Mais cela peut être plus simple et plus rapide. Et la question demande de convertir des chaînes vides ( '') en 0, mais pas une autre entrée «syntaxe d'entrée non valide» ou «hors plage»:

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;

Cela renvoie 0pour une chaîne vide et NULLpour toute autre entrée non valide.
Il peut facilement être adapté à toute conversion de type de données .

La saisie d'un bloc d'exception est nettement plus coûteuse. Si les chaînes vides sont courantes, il est judicieux de détecter ce cas avant de déclencher une exception.
Si les chaînes vides sont très rares, il vaut la peine de déplacer le test vers la clause d'exception.

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

Cette fonction retournera toujours 0s'il n'y a pas de chiffres dans la chaîne d'entrée.

SELECT parse_int('test12_3test');

reviendra 123

J'ai trouvé le code suivant facile et fonctionnel. La réponse originale est ici https://www.postgresql.org/message-id/[email protected]

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)

J'espère que ça aide

SUBSTRING peut aider dans certains cas, vous pouvez limiter la taille de l'int.

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

Si les données sont censées être des entiers et que vous n'avez besoin que de ces valeurs sous forme d'entiers, pourquoi ne pas parcourir tout le kilomètre et convertir la colonne en une colonne entière?

Ensuite, vous pouvez effectuer cette conversion de valeurs illégales en zéros une seule fois, au point du système où les données sont insérées dans la table.

Avec la conversion ci-dessus, vous obligez Postgres à convertir ces valeurs encore et encore pour chaque ligne de chaque requête pour cette table - cela peut sérieusement dégrader les performances si vous effectuez de nombreuses requêtes sur cette colonne de cette table.

La fonction suivante fait

• utilisez une valeur par défaut ( error_result) pour les résultats non castables, par exemple abcou999999999999999999999999999999999999999999
• garde nullcommenull
• supprime les espaces et autres espaces en entrée
• les valeurs exprimées comme valides bigintssont comparées lower_boundà, par exemple, appliquer uniquement des valeurs positives

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;

J'ai aussi le même besoin mais cela fonctionne avec JPA 2.0 et Hibernate 5.0.2:

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

Fonctionne à merveille. Je pense que ça marche aussi avec LIKE.

Cela devrait également faire le travail, mais cela concerne SQL et n'est pas spécifique à postgres.

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