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

Dicas de Códigos ESQL

Você pode melhorar o desempenho do fluxo de mensagens com o ESQL utilizando algumas técnicas de otimização.

Antes de iniciar:

Ao gravar seu código ESQL, é possível usar várias técnicas para melhorar o desempenho de seus fluxos de mensagens. As seções a seguir contêm orientação sobre como melhorar o desempenho de seu código ESQL:

Matriz de Processamento ESQL

Subscritos de matriz [ ] são caros em termos de desempenho devido à maneira na qual subscript é avaliada dinamicamente no tempo de execução. Por para evitar o uso de subscripts de matriz sempre que possível, você pode melhorar o desempenho de seu código ESQL. Ao invés disso, você pode usar variáveis de referência, que mantêm um ponteiro para a matriz e que pode, então, ser reutilizada; por exemplo:

DECLARE myref REFERENCE TO InputRoot.XML.Invoice.Purchases.Item[1];
--  Continue processing for each item in the array
WHILE LASTMOVE(myref)=TRUE DO
   -- Add 1 to each item in the array
   SET myref = myref + 1;
   -- Do some processing
   -- Move the dynamic reference to the next item in the array
   MOVE myref NEXTSIBLING;
END WHILE;

Exemplo de processamento de matriz ESQL:

O exemplo a seguir mostra ESQL sendo utilizado para processar registros lidos a partir de um banco de dados. O uso repetido de subscripts de matriz, tais como Environment.Variables.DBData[A] aumenta o tempo de processamento significativamente:

SET Environment.Variables.DBDATA[] =
(
SELECT T.*
FROM Database.{'ABC'}.{'XYZ'} as T
);

DECLARE A INTEGER 1;
DECLARE B INTEGER CARDINALITY(Environment.Variables.*[]);
SET JPcntFODS = B;
WHILE A <= B DO
            CALL CopyMessageHeaders();
            CREATE FIELD OutputRoot.XML.FODS;
            DECLARE outRootRef REFERENCE TO OutputRoot.XML.Data;

            SET outRootRef.Field1 = Trim(Environment.Variables.DBDATA[A].Field1);
            SET outRootRef.Field2 = Trim(Environment.Variables.DBDATA[A].Field2);
            SET outRootRef.Field3 = Trim(Environment.Variables.DBDATA[A].Field3);
            SET outRootRef.Field4 = Trim(Environment.Variables.DBDATA[A].Field4);
            SET outRootRef.Field5 = Trim(Environment.Variables.DBDATA[A].Field5);
            . . .
            . . .
            SET outRootRef.Field37 = CAST(Environment.Variables.DBDATA[A].Field37)

            SET A = A + 1;
            PROPAGATE;
END WHILE;

Você pode reduzir o tempo de processamento significativamente utilizando variáveis de referência

Função CARDINALITY do ESQL

Evite a utilização de CARDINALITY em um loop; por exemplo:
WHILE ( I < CARDINALITY (InputRoot.MRM.A.B.C[]
A função CARDINALITY precisa ser avaliada toda vez que o loop é atravessado, o que é caro em termos de desempenho. Isso é particularmente verdade com grandes matrizes porque o loop é repetido mais frequentemente. É mais eficiente para determinar o tamanho da matriz antes de o loop WHILE (a menos que seja alterado no loop) para que ela seja avaliada apenas uma vez; por exemplo:
SET ARRAY_SIZE = CARDINALITY (InputRoot.MRM.A.B.C[]
WHILE ( I < ARRAY_SIZE )

Instruções DECLARE e EVAL do ESQL

Reduz o número de instruções DECLARE (e, portanto, o custo de desempenho), declarando uma variável e configurando seu valor inicial em uma instrução única. Como alternativa, você pode declarar várias variáveis do mesmo tipo de dados em uma única instrução ESQL em vez de em várias instruções. Esta técnica também ajuda a reduzir o uso de memória.

A instrução do EVAL é, às vezes, usada quando há um requisito para determinar dinamicamente nomes de correlação. No entanto, é cara em termos de utilização de CPU, porque ele envolve a instrução que está sendo executada duas vezes. Na primeira vez que é executada, as partes do componente são determinadas a fim de construir a instrução que será executada, então, a instrução que foi construída é executada.

Instrução PASSTHRU do ESQL

As técnicas a seguir podem aprimorar significativamente o desempenho quando você está utilizando as instruções PASSTHRU:

  • Evite o uso da instrução PASSTHRU com uma instrução CALL para chamar um procedimento armazenado. Como alternativa, você pode usar os comandos CREATE PROCEDURE ... EXTERNAL ... e CALL ....
  • Quando você estiver trabalhando com instruções SQL que requerem valores literais ou de dados, utilize as variáveis do host, que mapeiam um valor de coluna para uma variável. Isso permite que instruções SQL dinâmicas sejam reutilizadas dentro do banco de dados. Um PREPARAR do SQL em uma instrução dinâmica é uma operação dispendiosa em termos de desempenho, portanto, é mais eficiente executá-la apenas uma vez e, em seguida, EXECUTAR a instrução repetidamente, em vez de PREPARAR e EXECUTAR toda vez.

Por exemplo, a seguinte instrução possui dois valores de dados e literal: 100 e IBM:

PASSTHRU(’UPDATE SHAREPRICES AS SP SET Price = 100 WHERE SP.COMPANY = ‘IBM’’);

Esta instrução é efetiva quando o preço é 100 e a empresa é IBM. Quando o Price ou Company é alterado, outra instrução é necessária, com outra instrução PREPARAR do SQL, que impacta o desempenho.

No entanto, utilizando a instrução a seguir, Price e Company podem alterar sem exigir outra instrução ou outro PREPARAR:
PASSTHRU(’UPDATE SHAREPRICES AS SP SET Price = ? WHERE SP.COMPANY = ?’,
InputRoot.XML.Message.Price,InputRoot.XML.Message.Company);
É possível verificar se o SQL dinâmico está alcançando reutilização de instrução máxima, usando os comandos a seguir para exibir o conteúdo do cache de instruções SQL no DB2:
db2 connect to <database name>
db2 get snapshot for database on <database name>
Use os seguintes comandos para ver o conteúdo do cache de instrução dinâmica:
db2 connect to <database name>
db2 get snapshot for dynamic SQL on <database name>

Variáveis de Referência do ESQL

É possível usar variáveis de referência para fazer referência a nomes de correlação longos, tais como InputRoot.XMLNSC.A.B.C.D.E. Declare um ponteiro de referência conforme mostrado no exemplo a seguir:
DECLARE refPtr REFERENCE to InputRoot.XMLNSC.A.B.C.D;

Para acessar o elemento E da árvore de mensagens, utilize o nome de correlação refPtr.E.

Você pode utilizar instruções REFERENCE e MOVE para ajudar a reduzir a quantidade de navegação dentro da árvore de mensagens, o que melhora o desempenho. Essa técnica pode ser útil quando você está construindo um grande número de instruções SET ou CREATE; em vez de navegar para a mesma ramificação na árvore, é possível usar uma variável REFERENCE para estabelecer um ponteiro para a filial e, em seguida, utilize a instrução MOVE para processar um campo de cada vez.

Funções de Cadeia do ESQL

As funções de manipulação de cadeia usadas no ESQL podem ser intensivas do CPU; funções como LENGTH, SUBSTRING, e RTRIM devem acessar bytes individuais na árvore de mensagens. Estas funções são caras em termos de desempenho, então minimizar a sua utilização pode ajudar a melhorar o desempenho. Quandopossível, evite também executar as mesmas concatenações repetidamente por armazenar resultados intermediários em variáveis.

Árvores de Mensagens com Registros de Repetição

O desempenho pode ser reduzido sob as seguintes condições:

  • Você está utilizando o processamento ESQL para manipular uma árvore de mensagens grande
  • A árvore de mensagens consiste em registros de repetição ou vários campos
  • Você utilizou instruções SET explícitas com caminhos de referência de campo para acessar ou criar os campos
  • Você observou uma lentidão gradual do processamento de fluxo de mensagens enquanto o ESQL processava campos ou repetições adicionais

Este problema ocorre quando você utiliza referências de campos, em vez de variáveis de referências, para acessar ou criar campos ou registros consecutivos.

O exemplo a seguir mostra instruções SET independentes utilizando caminhos de referência de campo para manipular a árvore de mensagens. A instrução SET utiliza um parâmetro de origem e um parâmetro de destino, em que um ou ambos os parâmetros são referências de campo:

SET OutputRoot.XMLNS.TestCase.StructureA.ParentA.field = '1';

O desempenho é afetado pela instrução SET que é usada para criar vários campos adicionais, como mostrado no exemplo a seguir:

SET OutputRoot.XMLNS.TestCase.StructureA.ParentA.field1 = '1';
SET OutputRoot.XMLNS.TestCase.StructureA.ParentA.field2 = '2';
SET OutputRoot.XMLNS.TestCase.StructureA.ParentA.field3 = '3';
SET OutputRoot.XMLNS.TestCase.StructureA.ParentA.field4 = '4';
SET OutputRoot.XMLNS.TestCase.StructureA.ParentA.field5 = '5';

Nesse exemplo, os cinco campos criados são todos filhos de ParentA. Antes da criação ou modificação do campo especificado, o broker deve navegar na árvore de mensagens nomeada para localizar o ponto na árvore de mensagens que deve ser alterado. Por exemplo:

  • Para acessar o campo 1, a instrução SET navega para ParentA, em seguida, para o primeiro campo, envolvendo duas navegações.
  • Para acessar o campo 5, a instrução SET navega para ParentA, em seguida, atravessa cada um dos campos anteriores até que atinja o campo 5, envolvendo seis navegações.

Navegar por todos os campos que precedem o campo especificado causa perda no desempenho.

O exemplo a seguir mostra campos de repetição que estão sendo acessados em uma árvore de mensagens de entrada:
DECLARE myChar CHAR;
DECLARE thisRecord INT 0;
WHILE thisRecord < 10000 DO
	SET thisRecord = thisRecord + 1;
	SET myChar = InputRoot.MRM.myParent.myRepeatingRecord[thisRecord];
END WHILE;  
Quando a notação de índice é utilizada, à medida que a contagem aumenta, o processamento precisa navegar por todos os campos precedentes para obter o campo necessário; ele deve contar nos registros anteriores para chegar ao que é representado pela referência indexada atual.
  • Ao acessar InputRoot.MRM.myParent.myRepeatingRecord[1], ocorre uma navegação para chegar ao primeiro registro
  • Ao acessar InputRoot.MRM.myParent.myRepeatingRecord[2], ocorrem duas navegações para chegar ao segundo registro
  • Ao acessar o InputRoot.MRM.myParent.myRepeatingRecord[N], navegações N ocorrem para chegar ao registro N(enésimo

Portanto, o número total de navegações para esse loop WHILE é: 1 + 2 + 3 + .... + N, que não é linear.

Se você estiver acessando ou criando campos ou registros consecutivos, você pode resolver esse problema utilizando variáveis de referência.

Quando você utiliza variáveis de referência, a instrução navega até o pai principal, que mantém um ponteiro para o campo na árvore de mensagens. O seguinte exemplo mostra o ESQL que pode ser utilizado para reduzir o número de navegações ao criar novos campos da árvore de mensagens de saída:

SET OutputRoot.XMLNS.TestCase.StructureA.ParentA.field1 = '1';
DECLARE outRef REFERENCE TO OutputRoot.XMLNS.TestCase.StructureA.ParentA;
SET outRef.field2 = '2';
SET outRef.field3 = '3';
SET outRef.field4 = '4';
SET outRef.field5 = '5';

Ao referenciar campos da árvore de mensagens de entrada de repetição, você pode utilizar o seguinte ESQL:

DECLARE myChar CHAR;
DECLARE inputRef REFERENCE TO InputRoot.MRM.myParent.myRepeatingRecord[1];
WHILE LASTMOVE(inputRef) DO
	SET myChar = inputRef;
	MOVE inputRef NEXTSIBLING NAME 'myRepeatingRecord';
END WHILE;

Veja informações adicionais na publicação Criando Referências de Campos Dinâmicos.

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:31:29


Tópico de TarefaTópico de Tarefa | Versão 8.0.0.5 | bj28653_