WebSphere Message Broker, Versão 8.0.0.5 Sistemas operacionais: AIX, HP-Itanium, Linux, Solaris, Windows, z/OS

Consulte as informações sobre a versão mais recente do produto em IBM Integration Bus, Versão 9.0

Instrução CALL

A instrução CALL chama (invoca) uma rotina.

Sintaxe

Ler diagrama de sintaxeManter visual do diagrama de sintaxe
>>-CALL--+---------------------+--RoutineName --(--ParameterList--)-->
         '-BrokerSchemaName--.-'                                      

>--+------------+--+--------------+----------------------------><
   '-Qualifiers-'  '-INTO--target-'   

BrokerSchemaName

   .-.--------------.   
   V                |   
|------Identifier---+-------------------------------------------|

ParameterList

   .-,--------------.   
   V                |   
|------Expression---+-------------------------------------------|

Qualificadores

|--+-IN--DatabaseSchemaReference----------+---------------------|
   '-EXTERNAL--SCHEMA--DatabaseSchemaName-'   

DatabaseSchemaReference

|--Database--+-------------------------+--.--SchemaClause-------|
             '-.--DatabaseSourceClause-'                    

DatabaseSourceClause

|--+-DatabaseSourceName-------+---------------------------------|
   '-{--DatabaseSourceExpr--}-'   

SchemaClause

|--+-SchemaName-------+-----------------------------------------|
   '-{--SchemaExpr--}-'   

Utilizando a Instrução CALL

A instrução CALL invoca uma rotina. Uma rotina é uma função ou um procedimento definido pelo usuário que foi definido por uma das seguintes:
  • Uma instrução CREATE FUNCTION
  • Uma instrução CREATE PROCEDURE
Assim como funções e procedimentos definidos pelo usuário padrão, você também pode utilizar CALL para invocar funções incorporadas (fornecidas pelo intermediário) e funções SQL definidas pelo usuário. Entretanto, a maneira comum de chamar esses tipos de função é simplesmente incluir seus nomes nas expressões.

A rotina chamada deve ser invocada de uma maneira que corresponda à sua definição. Por exemplo, se você tiver definido uma rotina com três parâmetros, os primeiros dois de tipo inteiro e o terceiro de tipo caractere, a instrução CALL deverá transmitir três variáveis para a rotina, cada uma de um tipo de dado que corresponda à definição. Esta técnica é chamada correspondência de assinatura exata, que significa que a assinatura fornecida pela instrução CALL deve corresponder à assinatura fornecida pela definição da rotina.

A correspondência de assinatura exata também se aplica ao valor retornado a uma rotina. Se a cláusula RETURNS for especificada na instrução CREATE FUNCTION, ou a rotina for uma função integrada, a cláusula INTO deverá ser especificada na instrução CALL. Um valor de retorno de uma rotina não pode ser ignorado. Por outro lado, se a cláusula RETURNS não for especificada na instrução CREATE FUNCTION, a cláusula INTO não deverá ser especificada, porque não haverá nenhum valor de retorno da rotina.

É possível usar a instrução CALL para invocar uma rotina que foi implementada de todas as maneiras a seguir:
  • ESQL.
  • Java™ .
  • Como um procedimento armazenado em um banco de dados.
  • Como uma função integrada (fornecida pelo broker) (embora, como indicado anteriormente, os nomes geralmente sejam incluídos nas expressões).

Essa variedade de implementação significa que algumas das cláusulas no diagrama de sintaxe CALL não são aplicáveis (ou permitidas) para todos os tipos de rotina. Também permite que a instrução CALL invoque qualquer tipo de rotina, independentemente de como a rotina foi definida.

Quando o parâmetro opcional BrokerSchemaName não é especificado, o analisador SQL do intermediário procura o procedimento nomeado utilizando o algoritmo descrito na instrução PATH (consulte a Cláusula PATH da instrução BROKER SCHEMA).

Quando o parâmetro BrokerSchemaName é especificado, o analisador SQL do intermediário chama o procedimento nomeado no esquema especificado sem procurar primeiro o caminho. Entretanto, se uma referência de procedimento for ambígua (ou seja, houver dois procedimentos com o mesmo nome em diferentes esquemas do broker) e a referência não for qualificada pelo BrokerSchemaName opcional, o conjunto de ferramentas Eclipse gerará um erro na visualização Problemas que você deve corrigir para implementar o código ambíguo.

As funções incorporadas fornecidas pelo intermediário são colocadas automaticamente em um esquema do intermediário predefinido chamado SQL. O esquema SQL é sempre procurado, por fim, por uma rotina que não tenha sido correspondida a uma rotina definida pelo usuário. Portanto, um módulo definido pelo usuário tem precedência sobre uma rotina interna com o mesmo nome.

Cada esquema do intermediário fornece um símbolo ou espaço de nomes exclusivo para uma rotina, portanto um nome de rotina é exclusivo quando qualificado pelo nome do esquema ao qual pertence.

A cláusula INTO é utilizada para armazenar o valor de retorno de uma rotina que foi definida com uma cláusula RETURNS ou de uma função integrada. O destino pode ser uma variável ESQL de um tipo de dados que corresponda ao tipo de dados na cláusula RETURNS ou uma referência de mensagem separada por pontos. Por exemplo, as duas instruções ESQL a seguir são válidas:
        CALL myProc1() INTO cursor;
        CALL myProc1() INTO OutputRoot.XMLNS.TestValue1; 

A instrução CALL transmite os parâmetros para o procedimento na ordem fornecida a ela. Os parâmetros que tiverem sido definidos como IN ou INOUT na definição da rotina são avaliados antes de ser feita uma CALL, mas os parâmetros definidos como OUT são sempre transmitidos como parâmetros NULL do tipo correto. Quando o procedimento é concluído, quaisquer parâmetros declarados como OUT ou INOUT são atualizados para refletir eventuais alterações feitas neles durante a execução do procedimento. Os parâmetros definidos como IN nunca são alterados durante a causa da execução de um procedimento.

A sobrecarga de rotina não é suportada, que significa que não é possível criar duas rotinas de mesmo nome no mesmo esquema do broker. Se o intermediário detectar que uma rotina foi sobrecarregada, ele emitirá uma exceção. De modo semelhante, não é possível invocar um procedimento armazenado do banco de dados que tenha sido sobrecarregado. Um procedimento armazenado do banco de dados será sobrecarregado se existir um outro procedimento com o mesmo no esquema do banco de dados. Entretanto, é possível chamar um método Java sobrecarregado, desde que você crie uma definição ESQL separada para cada método sobrecarregado a ser chamado, e fornecer um nome de rotina exclusivo a cada definição ESQL.

Avisos | Marcas Registradas | Downloads | Biblioteca | Suporte | Feedback

Copyright IBM Corporation 1999, 2014Copyright IBM Corporation 1999, 2014.

        
        Última atualização:
        
        Última atualização: 2015-02-28 18:29:52


Tópico de ReferênciaTópico de Referência | Versão 8.0.0.5 | ak04920_