Supprimer les valeurs de tableau dans pgSQL

Est-il un moyen de supprimer une valeur d'un tableau dans pgSQL? Ou pour être plus précis, à la pop de la dernière valeur? À en juger par cette liste la réponse semble être non. Je peux obtenir le résultat que je veux avec un index supplémentaire pointeur, mais c'est un peu lourd.

InformationsquelleAutor oggy | 2010-01-15

arrays postgresql

10

Non, je ne pense pas que vous le pouvez. Au moins pas sans écrire quelque chose de laid comme:
```
SELECT ARRAY (
 SELECT UNNEST(yourarray) LIMIT (
  SELECT array_upper(yourarray, 1) - 1
 )
)
```
- À en juger par ce que Google me dit, il semble que je ne peux pas. Je vais marquer ce que l'on a accepté de répondre à moins que quelqu'un prouve que vous avez tort 🙂
InformationsquelleAutor Magnus Hagander
77

Dans la version 9.3 et ci-dessus, vous pouvez faire:
```
update users set flags = array_remove(flags, 'active')
```
- En 2015, c'est la réponse la plus appropriée-- en supposant que vous êtes en cours d'exécution au moins PostgreSQL 9.3.
- Pour ceux d'entre vous qui n'ont pas été en mesure de rouler jusqu'à la version 9.3+ encore, vous devriez être en mesure de faire écrire votre propre array_remove() comme indiqué: sqlfiddle.com/#!15/03d32/1/0
- C'est absolument pas "la réponse la plus appropriée," que la question demande explicitement si nous sommes capables de "pop de la dernière valeur." Même si vous avez été à la première requête de la valeur du dernier élément, si cette valeur a été répétée à tous les dans le tableau, tous les instances de il serait supprimé. Ce n'est évidemment pas la fonctionnalité désirée de quelque chose comme un array_pop() fonction, qui est ce que l'OP est de demander.
InformationsquelleAutor John Sheehan
19

La façon la plus simple de supprimer la dernière valeur:
```
array1 = array[1,2,3]
array1 = ( select array1[1:array_upper(array1, 1) - 1] )
```
- Ce doit être la accepté de répondre.
- Yep, c'est la réponse - fonctionne pour moi très bien avec certains des points-virgules.
InformationsquelleAutor luke
9

Je ne suis pas sûr au sujet de votre contexte, mais ce devrait vous donner quelque chose à travailler avec:
```
CREATE TABLE test (x INT[]);
INSERT INTO test VALUES ('{1,2,3,4,5}');

SELECT x AS array_pre_pop,
       x[array_lower(x,1) : array_upper(x,1)-1] AS array_post_pop, 
       x[array_upper(x,1)] AS popped_value 
FROM test;


 array_pre_pop | array_post_pop | popped_value 
---------------+----------------+--------------
 {1,2,3,4,5}   | {1,2,3,4}      |            5
```
- Merci, cela fonctionne mais je suppose que le découpage n'est pas exactement une solution efficace?
- Je pense que c'est votre meilleure méthode vu qu'il n'y est pas intégré dans la fonction pop(). Sans connaître les détails, je ne peux pas donner les meilleurs conseils. Si vous souhaitez faire une boucle à travers le contenu d'un enregistrement spécifique, puis unnest() serait probablement mieux comme ça serait de convertir en un ensemble d'enregistrements. Cependant, si vous souhaitez simplement mettre à jour une table de supprimer tous les "derniers éléments" de la matrice dans plusieurs dossiers, la matrice de découpage serait la voie à suivre.
InformationsquelleAutor Matthew Wood
9

Il y a un moyen SIMPLE de supprimer une valeur dans un tableau dans la PLAINE SQL:
```
SELECT unnest('{5,NULL,6}'::INT[]) EXCEPT SELECT NULL
```
il va supprimer toutes les valeurs NULLES de la matrice. Le résultat sera:
```
#| integer |
------------
1|    5    |
2|    6    |
```
- Les utilisateurs de la version 9.3+ devriez voir cette réponse. Les utilisateurs de la version 9.2 et ci-dessous peuvent envelopper le code ci-dessus pour les réutiliser comme ceci: sqlfiddle.com/#!15/03d32/1/0
InformationsquelleAutor user2210877

Voici une fonction que j'utilise pour integer[] tableaux

CREATE OR REPLACE FUNCTION array_remove_item (array_in INTEGER[], item INTEGER)
RETURNS INTEGER[]
LANGUAGE SQL
AS $$
SELECT ARRAY(
  SELECT DISTINCT $1[s.i] AS "foo"
    FROM GENERATE_SERIES(ARRAY_LOWER($1,1), ARRAY_UPPER($1,1)) AS s(i)
   WHERE $2 != $1[s.i]
   ORDER BY foo
);
$$;

C'est évidemment pour l'entier des tableaux mais peut être modifié pour ANYARRAY ANYELEMENT

=> select array_remove_item(array[1,2,3,4,5], 3);
-[ RECORD 1 ]-----+----------
array_remove_item | {1,2,4,5}

InformationsquelleAutor Dustin Butler

3

Je suis en cours d'exécution sur 9.2 et je suis en mesure d'exécuter ceci:
```
update tablename set arrcolumn=arrcolumn[1:array_length(arrcolumn)-1];
```
ou vous pouvez passer au large de la face de l'élément avec le même genre de chose:
```
update tablename set arrcolumn=arrcolumn[2:array_length(arrcolumn)];
```
Attention, les programmeurs -- pour une raison encore inconnue de la science, de la pgsql tableaux commençant à l'indice 1 au lieu de 0-indexé.

InformationsquelleAutor amwinter

J'ai créé un array_pop fonction de sorte que vous pouvez supprimer un élément avec la valeur connue à partir d'un tableau.

CREATE OR REPLACE FUNCTION array_pop(a anyarray, element character varying)
RETURNS anyarray
LANGUAGE plpgsql
AS $function$
DECLARE 
    result a%TYPE;
BEGIN
SELECT ARRAY(
    SELECT b.e FROM (SELECT unnest(a)) AS b(e) WHERE b.e <> element) INTO result;
RETURN result;
END;
$function$

il y a aussi un résumé de la version https://gist.github.com/1392734

InformationsquelleAutor number5

Essayez ceci:

update table_name set column_name=column_name[1:array_upper(column_name, 1)-1];

InformationsquelleAutor Karim Tabet

-1

Ma fonction pour tous les types de tableaux.

Fonction externe:

CREATE OR REPLACE FUNCTION "outer_array"(anyarray, anyarray) RETURNS anyarray AS $$
    SELECT
        "new"."item"
    FROM (
        SELECT
            ARRAY(
                SELECT
                    "arr"."value"
                FROM (
                    SELECT
                        generate_series(1, array_length($1, 1)) AS "i",
                        unnest($1)                              AS "value"
                ) "arr"
                WHERE
                    "arr"."value" <> ALL ($2)
                ORDER BY
                    "arr"."i"
            ) AS "item"
    ) "new"
    $$
LANGUAGE sql
IMMUTABLE
RETURNS NULL ON NULL INPUT
;

Fonction intérieure:

CREATE OR REPLACE FUNCTION "inner_array"(anyarray, anyarray) RETURNS anyarray AS $$
    SELECT
        "new"."item"
    FROM (
        SELECT
            ARRAY(
                SELECT
                    "arr"."value"
                FROM (
                    SELECT
                        generate_series(1, array_length($1, 1)) AS "i",
                        unnest($1)                              AS "value"
                ) "arr"
                WHERE
                    "arr"."value" = ANY ($2)
                ORDER BY
                    "arr"."i"
            ) AS "item"
    ) "new"
$$
LANGUAGE sql
IMMUTABLE
RETURNS NULL ON NULL INPUT
;

InformationsquelleAutor Roman V. NIkolaev

Vous devez vous connecter pour publier un commentaire.