A função específica a ser utilizada em uma chamada de função é determinada de acordo com os seguintes passos.
Resolução do tipo em função
Selecionar no catálogo do sistema pg_proc as funções a serem consideradas. Se for utilizado um nome de função não qualificado, as funções consideradas serão aquelas com nome e número de argumentos corretos, visíveis no caminho de procura corrente (consulte a Seção 5.8.3). Se for fornecido um nome de função qualificado, somente serão consideradas as funções no esquema especificado.
Se forem encontradas no caminho de procura várias funções com argumentos do mesmo tipo, somente será considerada àquela que aparece primeiro no caminho. Mas as funções com argumentos de tipos diferentes serão consideradas em pé de igualdade, não importando a posição no caminho de procura.
Verificar se alguma função aceita exatamente os mesmos tipos de dado dos argumentos de entrada. Caso exista (só pode haver uma correspondência exata no conjunto de funções consideradas), esta é usada. Os casos envolvendo o tipo unknown nunca encontram correspondência nesta etapa.
Se não for encontrada nenhuma correspondência exata, verificar se a chamada de função parece ser uma solicitação trivial de conversão de tipo. Isto acontece quando a chamada de função possui apenas um argumento, e o nome da função é o mesmo nome (interno) de algum tipo de dado. Além disso, o argumento da função deve ser um literal de tipo desconhecido, ou um tipo binariamente compatível com o tipo de dado do nome da função. Quando estas condições são satisfeitas, o argumento da função é convertido no tipo de dado do nome da função sem uma chamada real de função.
Procurar pela melhor correspondência.
Desprezar as funções candidatas para as quais os tipos da entrada não correspondem, e nem podem ser convertidos (utilizando uma conversão implícita) para corresponder. Para esta finalidade é assumido que os literais do tipo unknown podem ser convertidos em qualquer tipo. Se permanecer apenas uma função candidata, então esta é usada; senão continuar na próxima etapa.
Examinar todas as funções candidatas, e manter aquelas com mais correspondências exatas com os tipos da entrada (Para esta finalidade os domínios são considerados idênticos aos seus tipos base). Manter todas as funções candidatas se nenhuma possuir alguma correspondência exata. Se permanecer apenas uma função candidata, então esta é usada; senão continuar na próxima etapa.
Examinar todas as funções candidatas, e manter aquelas que aceitam os tipos preferidos (da categoria de tipo do tipo de dado de entrada) em mais posições onde a conversão de tipo será necessária. Manter todas as candidatas se nenhuma aceitar o tipo preferido. Se permanecer apenas uma função candidata, esta será usada; senão continuar na próxima etapa.
Se algum dos argumentos de entrada for do tipo "unknown", verificar as categorias de tipo aceitas nesta posição do argumento pelas funções candidatas remanescentes. Em cada posição, selecionar a categoria string se qualquer uma das candidatas aceitar esta categoria (este favorecimento em relação à cadeia de caracteres é apropriado, porque um literal de tipo desconhecido se parece com uma cadeia de caracteres). Senão, se todas as candidatas remanescentes aceitam a mesma categoria de tipo, selecionar esta categoria; senão falhar, porque a escolha correta não pode ser deduzida sem informações adicionais. Rejeitar agora as funções candidatas que não aceitam a categoria de tipo selecionada; além disso, se alguma função candidata aceitar o tipo preferido em uma dada posição do argumento, rejeitar as candidatas que aceitam tipos não preferidos para este argumento.
Se permanecer apenas uma função candidata, este será usada; Se não permanecer nenhuma função candidata, ou se permanecer mais de uma candidata, então falhar.
Deve ser observado que as regras da "melhor correspondência" são idênticas para a resolução do tipo em operador e função. Seguem alguns exemplos.
Exemplo 10-4. Resolução do tipo do argumento em função de arredondamento
Existe apenas uma função round com dois argumentos (O primeiro é numeric e o segundo é integer). Portanto, a consulta abaixo converte automaticamente o primeiro argumento do tipo integer para numeric:
=> SELECT round(4, 4); round -------- 4.0000 (1 linha)
Na verdade esta consulta é convertida pelo analisador em
=> SELECT round(CAST (4 AS numeric), 4);
Uma vez que inicialmente é atribuído o tipo numeric às constantes numéricas com ponto decimal, a consulta abaixo não necessita de conversão de tipo podendo, portanto, ser ligeiramente mais eficiente:
=> SELECT round(4.0, 4);
Exemplo 10-5. Resolução do tipo em função de subcadeia de caracteres
Existem diversas funções substr, uma das quais aceita os tipos text e integer. Se esta função for chamada com uma constante cadeia de caracteres de tipo não especificado, o sistema escolherá a função candidata que aceita o argumento da categoria preferida para string (que é o tipo text).
=> SELECT substr('1234', 3);
substr
--------
34
(1 linha)
Se a cadeia de caracteres for declarada como sendo do tipo varchar, o que pode ser o caso se vier de uma tabela, então o analisador tenta converter para torná-la do tipo text:
=> SELECT substr(varchar '1234', 3);
substr
--------
34
(1 linha)
Esta consulta é transformada pelo analisador para se tornar efetivamente:
=> SELECT substr(CAST (varchar '1234' AS text), 3);
Nota: O analisador descobre no catálogo pg_cast que os tipos text e varchar são binariamente compatíveis, significando que um pode ser passado para uma função que aceita o outro sem realizar qualquer conversão física. Portanto, neste caso, não é realmente inserida nenhuma chamada de conversão de tipo explícita.
E, se a função for chamada com um argumento do tipo integer, o analisador tentará convertê-lo em text:
=> SELECT substr(1234, 3);
substr
--------
34
(1 linha)
Na verdade é executado como:
=> SELECT substr(CAST (1234 AS text), 3);
Esta transformação automática pode ser feita, porque existe uma conversão implícita de integer para text que pode ser chamada.
