É possível usar referências de campo ESQL para formar caminhos para elementos de corpo da mensagem.
>>-CorrelationName--+---------------------+-------------------->< | .-.---------------. | | V | | '---| PathElement |-+-' PathElement |--+------------+-----------------------------------------------> '-(--Type--)-' >-- ---+----------------------------------+--+-Nome-----------------+--> '-+---------------------------+--:-' +-{--NameExpression--}-+ +-Namespace-----------------+ '-*--------------------' +-{--NamespaceExpression--}-+ '---*-----------------------' >--+-------------------------+----------------------------------| '-[--+---------------+--]-' +-Índice--------+ +-<--+--------+-+ | '-Índice-' | +->--+--------+-+ | '-Índice-' | '-<-------------'
Uma referência de campo consiste em um nome de correlação, seguido de zero ou mais Elementos de Caminho, separados por pontos (.). O nome de correlação identifica um ponto de início bem conhecido e deve ser o nome de uma constante, uma variável declarada (escalar, linha ou referência) ou um dos pontos de início predefinidos; por exemplo, InputRoot. Os Campos de caminho definem um caminho do ponto de início para o campo desejado.
InputRoot.XMLNS.Data.Invoice
inicia o broker no local InputRoot (isto é, a raiz da
mensagem de entrada de um nó Compute) e, em seguida, realiza uma
seqüência de navegações.
Inicialmente, ele navega da raiz ao primeiro
campo filho denominado XMLNS, em seguida, ao primeiro campo filho do
campo XMLNS denominado Data. Finalmente, o broker navega até o
primeiro campo filho do campo Data, denominado Invoice. Toda vez que essa referência
de campo ocorre em um programa ESQL, o campo Invoice é acessado.InputRoot.XMLNS."Customer
Data".Invoice
Se precisar fazer referência a campos que
contêm aspas, utilize dois pares de aspas em torno da referência. Por exemplo: Body.Message."""hello"""
Alguns identificadores são reservados apenas como palavras-chave, mas, com exceção dos nomes de correlação, é possível utilizá-los nas referências de campo, sem a utilização de aspas duplas
InputRoot.XMLNS."Customer Data".{'Customer-'
||
CurrentCustomer}.Invoice
no qual as faturas estão
contidas em uma pasta com um nome formado pela concatenação do
literal de caractere Customer- com o valor em CurrentCustomer (que,
neste exemplo, deve ser uma variável declarada de caractere de tipo). InputRoot.XMLNS.*.Invoice.Value
corresponde a qualquer elemento do caminho no qual as faturas estão contidas.Observe que encerrar qualquer coisa em aspas duplas no ESQL torna-o um identificador; encerrar qualquer coisa em aspas simples torna-o um literal de caractere. Você deve incluir todas as cadeias de caracteres entre aspas simples.
DECLARE sp1 NAMESPACE 'http://www.ibm.com/space1';
/* Namespace declaration to associate prefix 'space1' with the namespace */
SET OutputRoot.XMLNS.TestCase.(XML.NamespaceDecl)xmlns:space1 = 'http://www.ibm.com/space1';
SET OutputRoot.XMLNS.TestCase.sp1:data1 = 'Hello!';
gera:<TestCase xmlns:space1="http://www.ibm.com/space1">
<space1:data1>Hello!</space1:data1>
</TestCase>
InputRoot.XMLNS.Data[1].Invoice
InputRoot.XMLNS.Data.Invoice[1]
Esta construção é a mais utilizada com uma
variável de índice, portanto, se um loop percorre todos estes campos em
sequência. Por exemplo: WHILE count < 32 DO
SET TOTAL = TOTAL + InputRoot.XMLNS.Data.Invoice[count].Amount;
SET COUNT = COUNT + 1
END WHILE;
Utilize este tipo de construção com cuidado, pois ele implica
em que o intermediário deve contar os campos desde o começo
cada vez ao longo do loop. Se a contagem repetida for grande, o
desempenho será fraco. Nesses
casos, uma alternativa melhor é utilizar uma variável de referência de campo.InputRoot.XMLNS.Data.Invoice -- Seleciona o primeiro
InputRoot.XMLNS.Data.Invoice[1] -- Seleciona o primeiro
InputRoot.XMLNS.Data.Invoice[>] -- Seleciona o primeiro
InputRoot.XMLNS.Data.Invoice[>1] -- Seleciona o primeiro
InputRoot.XMLNS.Data.Invoice[>2] -- Seleciona o segundo
InputRoot.XMLNS.Data.Invoice[<] -- Seleciona o quarto
InputRoot.XMLNS.Data.Invoice[<1] -- Seleciona o quarto
InputRoot.XMLNS.Data.Invoice[<2] -- Seleciona o terceiro
InputRoot.XMLNS.Data.Invoice[<3] -- Seleciona o segundo
Uma cláusula de índice também pode consistir em um par de colchetes
vazio ( [] ).
Isso seleciona todos os campos com nomes
correspondentes. Utilize essa construção com funções e instruções
que esperam listas (por exemplo, as funções SELECT, CARDINALITY,
SINGULAR e EXISTS ou a instrução SET).Cada campo de uma referência de campo pode conter uma cláusula type. Elas são denotadas por parênteses ( ( ) ) e aceitam qualquer expressão que retorna um valor não nulo de tipo inteiro. A presença de uma expressão de tipo restringe os campos que são selecionados aos do tipo correspondente. Essa construção é utilizada mais frequentemente com o XML genérico, em que há muitos tipos de campos e é possível que um campo XML contenha ambos os atributos e outros Campos XML com o mesmo nome.
<Item Value = '1234' >
<Value>5678</Value>
</Item>
Aqui, o campo XML Item possui dois Campos filhos, ambos denominados "Value". Os Campos filhos podem ser distintos utilizando-se as cláusulas do tipo: Item.(<Domínio>.Attribute)Value para selecionar o atributo e Item.(XML.Element)Value para selecionar o campo, em que <Domínio> é um de XML, XMLNS ou XMLNSC, como determinado pelo domínio de mensagens da origem.
(1) >>-(--FieldReference--)--ScalarDataTypeName--------------------><
Normalmente, uma restrição de tipo faz com que o valor escalar da referência seja extraído (de um modo semelhante à função FIELDVALUE) e uma exceção seja emitida se a referência não for do tipo correto. Por definição, uma exceção será emitida para todos os campos não existentes, porque eles são avaliados como NULL. Isso fornece uma maneira conveniente e rápida de causar exceções se campos essenciais estiverem ausentes nas mensagens.
Entretanto, quando restrições de tipos ocorrem em expressões que são candidatas para serem transmitidas a um banco de dados (por exemplo, elas estão em uma cláusula WHERE), as informações são utilizadas para determinar se a expressão pode ser especificada no banco de dados. Isso pode ser importante se uma cláusula WHERE contiver uma operação CAST em uma coluna de tabela de banco de dados. Na falta de uma restrição de tipo, como por exemplo, as expressões não podem ser especificadas no banco de dados porque o intermediário não pode informar se o banco de dados é capaz de desempenhar a conversão requerida. Entretanto, observe que você deve sempre tomar cuidado ao utilizar coerções que operam em valores de colunas, porque alguns bancos de dados possuem recursos de conversão de dados excessivamente limitados.
O namespace é tomado para ser o único namespace no caminho do namespace que contém esse nome. O único namespace que pode estar no caminho é o namespace notarget.
Essas formas existiam antes da introdução dos namespaces. Embora o seu comportamento tenha alterado o sentido de que agora elas comparam tanto o nome como o namespace, as transformações existentes não devem perceber nenhuma alteração no seu comportamento, pois todas as transformações existentes criam os seus Campos no namespace notarget.
Em todos os casos anteriores, um nome, ou namespace, fornecido por uma expressão contida entre chaves ({}) é equivalente a um nome fornecido como um identificador.
Por definição, o nome do namespace notarget é a cadeia vazia. A cadeia vazia pode ser selecionada por expressões que se resolvem como a cadeia vazia, o identificador vazio "" ou por referência a uma constante de namespace definida como a cadeia vazia.
A utilização de referências de campo geralmente implica na procura por um campo existente. No entanto, se o campo requerido não existir, como é geralmente o caso para referências de campo que são os destinos das instruções SET e aqueles na cláusula AS das funções SELECT, ele é criado.
Na ausência de especificação de um tipo, o tipo de campo não é Name nem NameValue, o que indica efetivamente que o novo campo não tem nome
.Estes padrões podem ser derivados de nomes de campos, nomes de colunas ou podem ser simplesmente nomes de sequência fabricados. Se o nome for o nome de um campo, trata-se efetivamente de uma cópia de árvore e o nome do namespace será copiado como acima.
Se não, o namespace do campo recém-criado será derivado da procura do caminho, isto é, o nome será tratado como a sintaxe NameId de uma referência de campo.
SET OutputRoot.XMLNS.Msg.Data.Name = NULL; -- isto exclui o campo
SET OutputRoot.XMLNS.Msg.Data.Name VALUE = NULL;
-- designa um valor NULL a um campo sem excluí-lo
Para compatibilidade com versões anteriores, a palavra-chave LAST ainda é suportada, mas sua utilização é obsoleta. LAST não pode ser utilizada como parte de uma expressão de índice: [LAST] é válido e é equivalente a [<], mas [LAST3] não é válido.
Field [ > ] -- O primero campo, equivalente a [ 1 ]
Field [ > (a + b) * 2 ]
Field [ < ] -- O último campo, equivalente a [ LAST ]
Field [ < 1 ] -- O último campo, equivalente a [ LAST ]
Field [ < 2 ] -- O último, mas único campo
Field [ < (a + b) / 3 ]