Quando uma função PL/Python é chamada, seus argumentos são convertidos de seu tipo de dados no PostgreSQL para o tipo de dados no Python correspondente:

Quando uma função escrita em PL/Python retorna, seu valor retornado é convertido para o tipo de dados de retorno do PostgreSQL declarado na função, da seguinte forma:

Note que as incompatibilidades lógicas entre o tipo de dados retornado declarado do PostgreSQL, e o tipo de dados retornado pelo Python, não são sinalizadas; o valor será convertido em todos os casos.

Se o valor nulo do SQL for passado para uma função, o valor do argumento aparecerá como None no Python. Por exemplo, a definição da função pymax mostrada em Funções em PL/Python retornará a resposta errada para entradas nulas. Poderia ser adicionado STRICT à definição da função para fazer com que o PostgreSQL faça algo mais razoável: se for passado um valor nulo, a função não será chamada, apenas retornando um resultado nulo automaticamente. Como alternativa, pode-se verificar se existem entradas nulas no corpo da função:

CREATE FUNCTION pymax (a integer, b integer)
  RETURNS integer
AS $$
  if (a is None) or (b is None):
    return None
  if a > b:
    return a
  return b
$$ LANGUAGE plpython3u;

Como mostrado acima, para retornar o valor nulo do SQL por uma função escrita em PL/Python, deve ser retornado o valor None. Isto pode ser feito independentemente da função ser estrita ou não.

Os valores do tipo de dados matriz do SQL são passados ​​para o PL/Python como uma lista do Python. Para retornar um valor do tipo de dados matriz do SQL por uma função escrita em PL/Python, deve ser retornada uma lista do Python:

CREATE FUNCTION retorna_matriz()
  RETURNS int[]
AS $$
return [1, 2, 3, 4, 5]
$$ LANGUAGE plpython3u;

SELECT retorna_matriz();

 retorna_matriz
----------------
 {1,2,3,4,5}
(1 linha)

As matrizes multidimensionais são passadas ​​para o PL/Python como listas Python aninhadas. Uma matriz bidimensional é uma lista de listas, por exemplo. Ao retornar uma matriz SQL multidimensional de uma função escrita em PL/Python, as listas internas em cada nível devem ser todas do mesmo tamanho. Por exemplo:

CREATE FUNCTION testa_conversao_tipo_matriz_int4(x int4[])
  RETURNS int4[]
AS $$
plpy.info(x, type(x))
return x
$$ LANGUAGE plpython3u;

SELECT * FROM testa_conversao_tipo_matriz_int4(ARRAY[[1,2,3],[4,5,6]]);

INFO:  ([[1, 2, 3], [4, 5, 6]], <class 'list'>)
 testa_conversao_tipo_matriz_int4
----------------------------------
 {{1,2,3},{4,5,6}}
(1 linha)

Outras sequências do Python, como as tuplas, também são aceitas para manter a compatibilidade com as versões do PostgreSQL 9.6 e anteriores, quando as matrizes multidimensionais não tinham suporte. Entretanto, são sempre tratadas como matrizes unidimensionais, porque são ambíguas com os tipos de dados compostos. Pela mesma razão, quando um tipo de dados composto é usado em uma matriz multidimensional, ele deve ser representado por uma tupla, em vez de uma lista.

Note que, no Python, as cadeias de caracteres são sequências, podendo ter efeitos indesejáveis ​​que podem ser familiares aos programadores Python:

CREATE FUNCTION retorna_cadeia_caracteres_matriz()
  RETURNS varchar[]
AS $$
return "hello"
$$ LANGUAGE plpython3u;
SELECT retorna_cadeia_caracteres_matriz();

 retorna_cadeia_caracteres_matriz
----------------------------------
 {h,e,l,l,o}
(1 linha

Os argumentos do tipo de dados composto são passados ​​para a função como mapeamentos do Python. Os nomes dos elementos do mapeamento são os nomes dos atributos do tipo composto. Se um atributo na linha passada tiver o valor nulo, ele terá o valor None no mapeamento. A seguir está um exemplo:

CREATE TABLE empregado (
  nome text,
  salario integer,
  idade integer
);

CREATE FUNCTION sobressalario (e empregado)
  RETURNS boolean
AS $$
  if e["salario"] > 20000:
    return True
  if (e["idade"] < 30) and (e["salario"] > 10000):
    return True
  return False
$$ LANGUAGE plpython3u;

Existem várias maneiras de retornar tipos de dados linha ou composto de uma função Python. Os exemplos a seguir assumem que existe:

CREATE TYPE nome_valor AS (
  nome   text,
  valor  integer
);

Um resultado composto pode ser retornado como:

Funções com parâmetros OUT também têm suporte. Por exemplo:

CREATE FUNCTION multiout_simple(OUT i integer, OUT j integer)
AS $$
return (1, 2)
$$ LANGUAGE plpython3u;

SELECT * FROM multiout_simple();

Os parâmetros de saída dos procedimentos são passados ​​de volta da mesma maneira. Por exemplo:

CREATE PROCEDURE python_triplica(INOUT a integer, INOUT b integer) AS $$
return (a * 3, b * 3)
$$ LANGUAGE plpython3u;

CALL python_triplica(5, 10);

As funções escritas em PL/Python também podem retornar conjunto, de tipo de dados escalar ou composto. Existem várias maneiras de se obter isto, porque o objeto retornado é internamente transformado em um iterador. Os exemplos a seguir assumem que existe o tipo de dados composto:

CREATE TYPE cumprimento AS (
  como text,
  quem text
);

Um conjunto de resultados pode ser retornado de:

Funções que retornam conjunto com parâmetros OUT (usando RETURNS SETOF record) também têm suporte. Por exemplo:

CREATE FUNCTION multiout_simple_setof(n integer, OUT integer, OUT integer)
    RETURNS SETOF record
AS $$
return [(1, 2)] * n
$$ LANGUAGE plpython3u;

SELECT * FROM multiout_simple_setof(3);