anyarray @> anyarray → boolean

A primeira matriz contém a segunda matriz, ou seja, cada elemento que aparece na segunda matriz é igual a algum elemento da primeira matriz? (Duplicados não são tratados de forma especial, portanto ARRAY[1] e ARRAY[1,1] são considerados contendo um ao outro.)

ARRAY[1,4,3] @> ARRAY[3,1,3] → t

anyarray <@ anyarray → boolean

A primeira matriz está contida na segunda matriz?

ARRAY[2,2,7] <@ ARRAY[1,7,4,2,6] → t

anyarray && anyarray → boolean

As matrizes se sobrepõem, ou seja, têm algum elemento em comum?

ARRAY[1,4,3] && ARRAY[2,1] → t

anycompatiblearray || anycompatiblearray → anycompatiblearray

Concatena as duas matrizes. Concatenar uma matriz nula ou uma matriz vazia é uma operação vazia (no-op); caso contrário, as matrizes devem ter o mesmo número de dimensões (como mostrado no primeiro exemplo), ou diferirem em número de dimensões por um (como mostrado no segundo exemplo). Se as matrizes não tiverem elementos de tipos de dados idênticos, os tipos de dados serão forçados a ter um tipo de dados comum (veja a Seção 10.5).

ARRAY[1,2,3] || ARRAY[4,5,6,7] → {1,2,3,4,5,6,7}

ARRAY[1,2,3] || ARRAY[[4,5,6],[7,8,9.9]] → {{1,2,3},{4,5,6},{7,8,9.9}}

anycompatible || anycompatiblearray → anycompatiblearray

Concatena um elemento no início da matriz (que deve ser vazia ou unidimensional).

3 || ARRAY[4,5,6] → {3,4,5,6}

anycompatiblearray || anycompatible → anycompatiblearray

Concatena um elemento no fim da matriz (que deve ser vazia ou unidimensional).

ARRAY[4,5,6] || 7 → {4,5,6,7}

array_append ( anycompatiblearray, anycompatible ) → anycompatiblearray

Acrescenta um elemento ao final de uma matriz (idêntico ao que o operador anycompatiblearray || anycompatible faz).

array_append(ARRAY[1,2], 3) → {1,2,3}

array_cat ( anycompatiblearray, anycompatiblearray ) → anycompatiblearray

Concatena duas matrizes (idêntico ao que o operador anycompatiblearray || anycompatiblearray faz).

array_cat(ARRAY[1,2,3], ARRAY[4,5]) → {1,2,3,4,5}

array_dims ( anyarray ) → text

Retorna a representação em forma de texto das dimensões da matriz.

array_dims(ARRAY[[1,2,3], [4,5,6]]) → [1:2][1:3]

array_fill ( anyelement, integer[] [, integer[] ] ) → anyarray

Retorna uma matriz preenchida com cópias do valor fornecido, com as dimensões dos comprimentos especificados pelo segundo argumento. O terceiro argumento, opcional, fornece valores de limite inferior para cada dimensão (cujo padrão é 1).

array_fill(11, ARRAY[2,3]) → {{11,11,11},{11,11,11}}

array_fill(7, ARRAY[3], ARRAY[2]) → [2:4]={7,7,7}

array_length ( anyarray, integer ) → integer

Retorna o comprimento da dimensão solicitada da matriz. (Retorna NULL, em vez de 0, para dimensões de matriz vazias ou ausentes.)

array_length(array[1,2,3], 1) → 3

array_length(array[]::int[], 1) → NULL

array_length(array['text'], 2) → NULL

array_lower ( anyarray, integer ) → integer

Retorna o limite inferior da dimensão solicitada da matriz.

array_lower('[0:2]={1,2,3}'::integer[], 1) → 0

array_ndims ( anyarray ) → integer

Retorna o número de dimensões da matriz.

array_ndims(ARRAY[[1,2,3], [4,5,6]]) → 2

array_position ( anycompatiblearray, anycompatible [, integer ] ) → integer

Retorna o índice da primeira ocorrência do segundo argumento na matriz, ou NULL se não estiver presente. Se o terceiro argumento for fornecido, a procura começará nesse índice. A matriz deve ser unidimensional. As comparações são feitas usando a semântica IS NOT DISTINCT FROM, então é possível procurar por NULL.

array_position(ARRAY['dom', 'seg', 'ter', 'qua', 'qui', 'sex', 'sab'], 'seg') → 2

array_positions ( anycompatiblearray, anycompatible ) → integer[]

Retorna uma matriz contendo os índices de todas as ocorrências do segundo argumento na matriz fornecida como primeiro argumento. A matriz deve ser unidimensional. As comparações são feitas usando a semântica IS NOT DISTINCT FROM, então é possível procurar por NULL. Só é retornado NULL se a matriz for NULL; se o valor não for encontrado na matriz, será retornada uma matriz vazia.

array_positions(ARRAY['A','A','B','A'], 'A') → {1,2,4}

array_prepend ( anycompatible, anycompatiblearray ) → anycompatiblearray

Anexa um elemento ao início de uma matriz (idêntico ao que o operador anycompatible || anycompatiblearray faz).

array_prepend(1, ARRAY[2,3]) → {1,2,3}

array_remove ( anycompatiblearray, anycompatible ) → anycompatiblearray

Remove da matriz todos os elementos iguais ao valor fornecido. A matriz deve ser unidimensional. As comparações são feitas usando a semântica IS NOT DISTINCT FROM, então é possível remover NULL.

array_remove(ARRAY[1,2,3,2], 2) → {1,3}

array_replace ( anycompatiblearray, anycompatible, anycompatible ) → anycompatiblearray

Substitui cada elemento da matriz igual ao segundo argumento pelo terceiro argumento.

array_replace(ARRAY[1,2,5,4], 5, 3) → {1,2,3,4}

array_reverse ( anyarray ) → anyarray

Inverte a primeira dimensão da matriz.

array_reverse(ARRAY[[1,2],[3,4],[5,6]]) → {{5,6},{3,4},{1,2}}

array_sample ( array anyarray, n integer ) → anyarray

Retorna uma matriz de n itens selecionados aleatoriamente da matriz array. n não pode exceder o valor da primeira dimensão da matriz array. Se a matriz array for multidimensional, um “item” será uma fatia possuindo como primeira dimensão o valor fornecido.

array_sample(ARRAY[1,2,3,4,5,6], 3) → {2,6,1}

array_sample(ARRAY[[1,2],[3,4],[5,6]], 2) → {{5,6},{1,2}}

array_sample(ARRAY[[1,2,3],[3,4,5],[5,6,7]], 2) → {{5,6,7},{1,2,3}}

array_shuffle ( anyarray ) → anyarray

Mistura aleatoriamente a primeira dimensão da matriz.

array_shuffle(ARRAY[[1,2],[3,4],[5,6]]) → {{5,6},{1,2},{3,4}}

array_shuffle(ARRAY[[1,2,3],[3,4,5],[5,6,7]]) → {{1,2,3},{5,6,7},{3,4,5}}

array_sort ( array anyarray [, descending boolean [, nulls_first boolean ]] ) → anyarray

Ordena a primeira dimensão da matriz. A ordem de classificação é determinada pela ordem de classificação padrão do tipo de dados do elemento da matriz; entretanto, se o tipo de dados do elemento for ordenável, a ordenação a ser usada pode ser especificada adicionando uma cláusula COLLATE ao argumento matriz array.

Se descending for verdade, então a ordenação será feita em ordem decrescente; caso contrário, será na ordem crescente. Se for omitido, o padrão é a ordem crescente. Se nulls_first for verdade, os valores nulos aparecem antes dos valores não nulos; caso contrário, os valores nulos aparecem depois dos valores não nulos. Se for omitido, nulls_first é considerado como tendo o mesmo valor que descending.

array_sort(ARRAY[[2,4],[2,1],[6,5]]) → {{2,1},{2,4},{6,5}}

array_sort(ARRAY[[3,4,5],[5,6,7],[1,2,3]]) → {{1,2,3},{3,4,5},{5,6,7}}

array_to_string ( array anyarray, delimiter text [, null_string text ] ) → text

Converte cada elemento da matriz em sua representação de texto, e concatena aqueles separados pela cadeia de caracteres presente em delimiter. Se for especificada a cadeia de caracteres null_string, e não for NULL, então os valores NULL da matriz serão representados por esta cadeia de caracteres; caso contrário, os valores NULL serão omitidos. Veja também a função string_to_array.

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

array_upper ( anyarray, integer ) → integer

Retorna o limite superior da dimensão solicitada da matriz.

array_upper(ARRAY[1,8,3,7], 1) → 4

cardinality ( anyarray ) → integer

Retorna o número total de elementos na matriz, ou 0 se a matriz estiver vazia.

cardinality(ARRAY[[1,2],[3,4]]) → 4

trim_array ( array anyarray, n integer ) → anyarray

Corta uma matriz removendo os últimos n elementos. Se a matriz for multidimensional, apenas a primeira dimensão será cortada.

trim_array(ARRAY[1,2,3,4,5,6], 2) → {1,2,3,4}

unnest ( anyarray ) → setof anyelement

Expande uma matriz em um conjunto de linhas. Os elementos da matriz são lidos na ordem de armazenamento.

unnest(ARRAY[1,2]) →

 1
 2

unnest(ARRAY[['foo','bar'],['baz','quux']]) →

 foo
 bar
 baz
 quux

unnest ( anyarray, anyarray [, ... ] ) → setof anyelement, anyelement [, ... ]

Expande várias matrizes (possivelmente de tipos de dados diferentes) em um conjunto de linhas. Se nem todas as matrizes tiverem o mesmo comprimento, as mais curtas serão preenchidas com o valor NULL. Esta forma só é permitida na cláusula FROM da consulta; veja a Seção 7.2.1.4.

select * from unnest(ARRAY[1,2], ARRAY['foo','bar','baz']) as x(a,b) →

 a |  b
---+-----
 1 | foo
 2 | bar
   | baz