Trabalhar com objetos de dados estruturados

Trabalhar com objetos de dados estruturados

Objectives

After completing this lesson, you will be able to:
  • Trabalhar com objetos de dados estruturados.
  • Use objetos de dados estruturados no ABAP SQL.

Objetos de dados estruturados

Para acessar um componente de uma estrutura, você deve colocar um sinal negativo (-) entre o nome da estrutura e o nome do componente.

Nota

Não são permitidos espaços em branco antes ou depois do seletor de componentes.

Acessando um componente de estrutura dessa forma, você pode utilizá-lo em qualquer posição de operando na qual você pode utilizar uma variável do mesmo tipo. O componente airport_from_id da conexão de estrutura no exemplo acima é do tipo /DMO/AIRPORT_FROM_ID. Consequentemente, você pode utilizar este componente em qualquer posição de operando na qual você poderia utilizar uma variável simples do tipo /DMO/AIRPORT_FROM_ID; não só no lado esquerdo de uma avaliação como no exemplo, mas também no lado direito, na transferência de parâmetros de uma chamada de método, na cláusula INTO ou cláusula WHERE de uma instrução SELECT, etc.

Se o próprio componente de uma estrutura for uma estrutura, você acessa os subcomponentes utilizando o seletor de componentes novamente após o nome do componente principal. A primeira avaliação no exemplo acessa o componente MSGTY de MESSAGE, que por sua vez é um componente da estrutura embutida CONNECTION_NESTED.

Dica

Você pode utilizar a conclusão de código para implementar o acesso a componentes de estrutura. Posicione o cursor imediatamente após o seletor de componentes de estrutura e pressione CTRL + ESPAÇO para ver uma lista de todos os componentes de estrutura disponíveis.

A expressão VALUE #( ) é uma forma elegante de atribuir valores a um objeto de dados estruturado.

Se você quiser preencher uma estrutura inteira, pode abordar cada componente individualmente, como viu no exemplo anterior.

No entanto, você também pode utilizar uma expressão VALUE #( ) para preencher a estrutura. A expressão constrói uma estrutura, preenche-a com valores e atribui a estrutura preenchida a uma variável, neste caso connection. O sinal de libra (#) indica ao ambiente de tempo de execução ABAP para construir uma estrutura com o mesmo tipo que a variável de destino connection. Nos parênteses, você lista os componentes da estrutura que quer preencher (não precisa ser todos) e atribui um valor aos mesmos.

Quando você preenche uma estrutura desta forma, o sistema de tempo de execução elimina todos os valores existentes da estrutura antes de recarregar com os valores de sua expressão.

Nota

Uma atribuição no formulário connection = VALUE #( ). com apenas um espaço em branco entre parênteses, preenche todos os componentes da estrutura com o valor inicial específico de tipo. Isso tem o mesmo efeito que a instrução CLEAR connection.

No ABAP, você só pode copiar o conteúdo de uma estrutura diretamente para outra estrutura utilizando a notação <target structure> = <source structure> se os dois tipos de estrutura forem compatíveis. Normalmente, isso apenas acontece se ambas as estruturas forem do mesmo tipo. Se as estruturas tiverem tipos diferentes, duas coisas podem acontecer:

  • Se uma das estruturas tiver um componente não em forma de caractere em uma posição em que a outra estrutura tem um componente em forma de caractere, a atribuição direta leva a um erro de sintaxe.
  • Se as duas estruturas forem semelhantes a caracteres ou, por outras palavras, as duas estruturas forem somente compostas por componentes em forma de caractere, a atribuição direta é tecnicamente possível. Mas, geralmente, o resultado estará errado.

No exemplo, a estrutura de origem e a estrutura de destino são em forma de caractere. Por isso, a atribuição direta é tecnicamente possível. Mas como não são compatíveis, o resultado está incorreto: o conteúdo do componente carrier_name é copiado para o componente message na estrutura de destino.

Como não há erro de sintaxe, você deve ter cuidado extra ao trabalhar com estruturas em forma de caractere não compatíveis.

Quando você copia dados entre estruturas, normalmente você quer copiar informações de um campo para o campo correspondente da estrutura de destino - airport_from_id para airport_from_id, airport_to_id para airport_to_id, etc. Para conseguir isso no ABAP, utilize a expressão CORRESPONDING. Isso atribui valores de <source_structure> aos componentes correspondentes, ou seja, aos componentes de nome idêntico de <target_structure>. Você deve lembrar dos seguintes pontos:

  • Os campos devem ter nomes idênticos.
  • Os componentes não precisam estar na mesma posição ou sequência nas duas estruturas.
  • Se os campos tiverem tipos diferentes, o ABAP tenta uma conversão de tipo de acordo com o conjunto de regras predefinido.

A expressão CORRESPONDING no exemplo cria uma estrutura do tipo st_connection_nested. A esta estrutura são atribuídos os valores com o mesmo nome dos componentes da estrutura connection. Todos os outros componentes permanecem iniciais. A estrutura assim construída é então atribuída à estrutura connection_nested. Deste modo, os valores iniciais são atribuídos ao componente message.

Teste: acesso a objetos de dados estruturados

  1. Como no primeiro exercício deste curso, crie uma nova classe global que implemente a interface IF_OO_ADT_CLASSRUN.
  2. Copie o seguinte snippet de código para a parte de implementação do método if_oo_adt_classrun~main( ):
    Code Snippet
    12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576
    TYPES: BEGIN OF st_connection, airport_from_id TYPE /dmo/airport_from_id, airport_to_id TYPE /dmo/airport_to_id, carrier_name TYPE /dmo/carrier_name, END OF st_connection. TYPES: BEGIN OF st_connection_nested, airport_from_id TYPE /dmo/airport_from_id, airport_to_id TYPE /dmo/airport_to_id, message TYPE symsg, carrier_name TYPE /dmo/carrier_name, END OF st_connection_nested. DATA connection TYPE st_connection. DATA connection_nested TYPE st_Connection_nested. * Example 1: Access to structure components ********************************************************************** connection-airport_from_id = 'ABC'. connection-airport_to_id = 'XYZ'. connection-carrier_name = 'My Airline'. "Access to sub-components of nested structure connection_nested-message-msgty = 'E'. connection_nested-message-msgid = 'ABC'. connection_nested-message-msgno = '123'. * Example 2: Filling a structure with VALUE #( ). ********************************************************************** CLEAR connection. connection = VALUE #( airport_from_id = 'ABC' airport_to_id = 'XYZ' carrier_name = 'My Airline' ). " Nested VALUE to fill nested structure connection_nested = VALUE #( airport_from_id = 'ABC' airport_to_id = 'XYZ' message = VALUE #( msgty = 'E' msgid = 'ABC' msgno = '123' ) carrier_name = 'My Airline' ). * Example 3: Wrong result after direct assignment ********************************************************************** connection_nested = connection. out->write( `-------------------------------------------------------------` ). out->write( `Example 3: Wrong Result after direct assignment` ). out->write( data = connection name = `Source Structure:`). out->write( |Component connection_nested-message-msgid: { connection_nested-message-msgid }| ). out->write( |Component connection_nested-carrier_name : { connection_nested-carrier_name }| ). * Example 4: Assigning Structures using CORRESPONDING #( ) ********************************************************************** CLEAR connection_nested. connection_nested = CORRESPONDING #( connection ). " out->write( `-------------------------------------------------------------` ). out->write( `Example 4: Correct Result after assignment with CORRESPONDING` ). out->write( data = connection name = `Source Structure:`). out->write( |Component connection_nested-message-msgid: { connection_nested-message-msgid }| ). out->write( |Component connection_nested-carrier_name : { connection_nested-carrier_name }| ).
  3. Pressione CTRL + F3 para ativar a classe e F9 para executar o aplicativo de console.
  4. Analise a saída do console. Depurar o programa, brincar com o código-fonte para se familiarizar com os conceitos.

Objetos de dados estruturados no ABAP SQL

A cláusula INTO da instrução SELECT só funcionará corretamente se o número e os tipos dos componentes da estrutura corresponderem ao número e aos tipos de colunas especificados na cláusula FIELDS. No exemplo acima, a declaração só funcionará se a conexão da estrutura de destino tiver três componentes com o mesmo tipo e comprimento que as colunas DepartureAirport, DestinationAirport e \_Airline-Name listadas na cláusula FIELDS. Considere que, neste caso, os nomes não precisam ser idênticos - o sistema preenche a estrutura de destino da esquerda para a direita.

Se a lista de campos na cláusula FIELDS não corresponder à estrutura ou ao tipo de linha da tabela na cláusula INTO, ocorrerá um erro de tempo de execução.

O exemplo mostra uma técnica fácil para garantir que a estrutura de destino corresponda à seleção de campos:

  • A estrutura de destino é tipificada com a visão CDS /DMO/I_Connection, que é a fonte de dados na cláusula FROM.
  • O sinal de asterisco (*) após a palavra-chave FIELDS é uma notação breve para garantir que todos os campos da visão fazem parte da seleção de campos. As associações expostas são ignoradas.

Nota

Esta técnica também está disponível quando você lê diretamente de uma tabela de banco de dados. Assim como as definições de visão CDS, as definições de tabela de banco de dados também podem servir como tipos de estrutura global no ABAP.

A principal vantagem desta técnica é que a instrução SELECT permanece sintaticamente intacta, mesmo que você ou outra pessoa efetue modificações na visão CDS ou na tabela de banco de dados. A desvantagem mais importante é que você sempre lê todos os campos do banco de dados, independentemente de realmente precisar deles ou não.

Nota

Só utilize esta técnica para visões e tabelas com um pequeno número de campos e se você realmente precisar de todos os campos. A leitura desnecessária de dados do banco de dados é a principal causa de problemas de performance.

Outra forma de evitar erros de sintaxe é a variante INTO CORRESPONDING FIELDS. Esta variante tem o mesmo efeito que o operador CORRESPONDING #( ) que você aprendeu anteriormente. Ele garante que os dados sejam copiados entre componentes com nomes idênticos. Ao definir o tipo de estrutura de acordo com suas necessidades, você pode garantir que somente os dados necessários são lidos.

Mais uma vez, somente os nomes devem ser idênticos. No entanto, para evitar problemas, você deve se certificar de que os componentes com nomes idênticos têm tipos compatíveis. Caso contrário, o sistema tenta converter o conteúdo do campo de origem no tipo do campo de destino. Isso pode levar à perda de dados ou a erros em tempo de execução (catchable).

Se os nomes de campo na fonte de dados e os nomes de componente na estrutura de destino não coincidirem, a combinação de FIELDS * e INTO CORRESPONDING FIELDS OF não funciona.

Se você quiser manter a variante INTO CORRESPONDING FIELDS OF, pode definir nomes de alias para os campos selecionados na lista de campos. Para isso, adicione o suplemento AS após o nome do campo, seguido pelo nome do alias. No exemplo, o nome do alias para o campo de visualização DepartureAirport é airport_from_id e o nome do alias para a expressão do caminho \_Airline-Name é carrier_name. Com base nesses nomes de alias, INTO CORRESPONDING FIELDS OF identifica corretamente o componente de estrutura no qual os dados recuperados devem ser armazenados.

A técnica mais simples para evitar conflitos entre a seleção de campos e a estrutura de destino é uma declaração inline na cláusula INTO. A sequência, o tipo e o nome da estrutura declarada inline são derivados da cláusula FIELDS. Por isso, a estrutura de destino é sempre adequada à seleção de campos.

Nota

Declarações inline só são suportadas após INTO. Você não pode utilizar declarações inline após INTO CORRESPONDING FIELDS OF.

No exemplo, não existe alias para o campo DepartureAirport. O nome do campo é utilizado como nome do componente na estrutura connection_inline. O campo DestinationAirportbem como a expressão de caminho \_Airline-Name têm nomes de alias opcionais (ArrivalAirport e AirlineName). Aqui, os nomes de alias são utilizados como nomes de componente.

Ao trabalhar com um banco de dados relacional, muitas vezes você enfrenta o problema de ler dados relacionados de diferentes tabelas de banco de dados. Já aprendemos que as associações em visões CDS são uma maneira elegante de executar essa tarefa.

Se não existir uma visão CDS com associações adequadas, você pode implementar junções SQL. O exemplo acima ilustra o princípio das junções:

Estamos interessados em conexões de voo e nos aeroportos que eles se conectam. Encontramos os IDs de 3 letras dos aeroportos na tabela de banco de dados /DMO/CONNECTION. Os nomes completos dos aeroportos são armazenados na tabela de banco de dados /DMO/AIRPORT.

Para recuperar uma conexão com o nome do aeroporto de partida, em uma instrução SELECT, lemos os dados de conexão da tabela de banco de dados /DMO/CONNECTION e os juntamos à tabela de banco de dados /DMO/AIRPORT.

Um join é composto pelos seguintes módulos:

remotas
As tabelas e visões do banco de dados para se juntarem entre si. Uma única junção sempre combina uma fonte de dados à esquerda com uma fonte de dados à direita. No exemplo acima, a tabela /DMO/CONNECTION é a fonte de dados à esquerda e a tabela /DMO/AIRPORT é a fonte de dados à direita. O ABAP SQL também suporta junções de junções (junções aninhadas)
Condição join
A condição join indica que registros da fonte de dados direita pertencem a um registro da fonte de dados à esquerda. No exemplo acima, o aeroporto de partida relacionado é identificado pelo valor nas colunas CLIENT e AIRPORT_ID. A condição join é:
/DMO/CONNECTION~CLIENT = /DMO/AIRPORT~CLIENT
AND
/DMO/CONNECTION~AIRPORT_FROM_ID = /DMO/AIRPORT~AIRPORT_ID
Tipo de junção
O tipo de junção influencia o resultado se uma das fontes de dados não contiver registros correspondentes. O ABAP SQL suporta atualmente INNER JOIN, LEFT OUTER JOIN, RIGHT OUTER JOIN e CROSS JOIN. O tipo de junção mais comum é um LEFT OUTER JOIN.

A figura mostra a sintaxe do ABAP SQL para uma junção. Na cláusula FROM, o tipo de junção é especificado por palavras-chave LEFT OUTER JOIN entre a fonte de dados à esquerda /dmo/connection e a fonte de dados à direita /dmo/airport. A sintaxe introduz nomes de alias c e f para as fontes de dados. Os nomes de alias para fontes de dados são opcionais, a menos que uma fonte de dados apareça mais de uma vez na junção.

A condição join segue a palavra-chave ON. O separador entre a fonte de dados ou o respectivo alias e o campo é o sinal til (~).

Nota

No ABAP SQL, não é necessário mencionar os campos de cliente. Eles são adicionados à condição join pela interface do banco de dados antes de a instrução ser enviada para o banco de dados. Se a cláusula FROM definir uma junção, você poderá usar campos das duas fontes de dados nas cláusulas FIELDS e WHERE.

Neste exemplo, a instrução SELECT não só lê o nome do aeroporto de partida, mas também o nome do aeroporto de destino. Para isso, a cláusula FROM define uma junção aninhada:

A primeira junção é uma junção externa esquerda das tabelas /dmo/connection e /dmo/airport, introduzindo o alias "f" (como "from") para a fonte de dados à direita. Essa primeira junção é então utilizada como fonte de dados à esquerda para uma segunda junção externa esquerda que tem a tabela /dmo/airport como fonte de dados à direita. Observe que, neste caso, o alias "t" (para "para") é crucial para distinguir essa aparência da tabela /dmo/airport da anterior.

A cláusula FIELDS lista os nomes de aeroportos de ambas as fontes de dados, introduzindo aliases airport_from_name e airport_to_name para distingui-los uns dos outros.

Dica

Os parênteses ao redor da primeira junção são opcionais. Se elas forem omitidas, as junções na cláusula from serão avaliadas da esquerda para a direita.

Testar: objetos de dados estruturados no ABAP SQL

  1. Como no primeiro exercício deste curso, crie uma nova classe global que implemente a interface IF_OO_ADT_CLASSRUN.
  2. Copie o seguinte snippet de código para a parte de implementação do método if_oo_adt_classrun~main( ):
    Code Snippet
    123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113
    TYPES: BEGIN OF st_connection, airport_from_id TYPE /dmo/airport_from_id, airport_to_id TYPE /dmo/airport_to_id, carrier_name TYPE /dmo/carrier_name, END OF st_connection. TYPES: BEGIN OF st_connection_short, DepartureAirport TYPE /dmo/airport_from_id, DestinationAirport TYPE /dmo/airport_to_id, END OF st_connection_short. DATA connection TYPE st_connection. DATA connection_short TYPE st_connection_short. DATA connection_full TYPE /DMO/I_Connection. * Example 1: Correspondence between FIELDS and INTO ********************************************************************** SELECT SINGLE FROM /DMO/I_Connection FIELDS DepartureAirport, DestinationAirport, \_Airline-Name WHERE AirlineID = 'LH' AND ConnectionID = '0400' INTO @connection. out->write( `------------------------------` ). out->write( `Example 1: Field List and INTO` ). out->write( connection ). * Example 2: FIELDS * ********************************************************************** SELECT SINGLE FROM /DMO/I_Connection FIELDS * WHERE AirlineID = 'LH' AND ConnectionID = '0400' INTO @connection_full. out->write( `----------------------------` ). out->write( `Example 2: FIELDS * and INTO` ). out->write( connection_full ). * Example 3: INTO CORRESPONDING FIELDS ********************************************************************** SELECT SINGLE FROM /DMO/I_Connection FIELDS * WHERE AirlineID = 'LH' AND ConnectionID = '0400' INTO CORRESPONDING FIELDS OF @connection_short. out->write( `----------------------------------------------------` ). out->write( `Example 3: FIELDS * and INTO CORRESPONDING FIELDS OF` ). out->write( connection_short ). * Example 4: Alias Names for Fields ********************************************************************** CLEAR connection. SELECT SINGLE FROM /DMO/I_Connection FIELDS DepartureAirport AS airport_from_id, \_Airline-Name AS carrier_name WHERE AirlineID = 'LH' AND ConnectionID = '0400' INTO CORRESPONDING FIELDS OF @connection. out->write( `---------------------------------------------------` ). out->write( `Example 4: Aliases and INTO CORRESPONDING FIELDS OF` ). out->write( connection ). * Example 5: Inline Declaration ********************************************************************** SELECT SINGLE FROM /DMO/I_Connection FIELDS DepartureAirport, DestinationAirport AS ArrivalAirport, \_Airline-Name AS carrier_name WHERE AirlineID = 'LH' AND ConnectionID = '0400' INTO @DATA(connection_inline). out->write( `-----------------------------------------` ). out->write( `Example 5: Aliases and Inline Declaration` ). out->write( connection_inline ). * Example 6: Joins ********************************************************************** SELECT SINGLE FROM ( /dmo/connection AS c LEFT OUTER JOIN /dmo/airport AS f ON c~airport_from_id = f~airport_id ) LEFT OUTER JOIN /dmo/airport AS t ON c~airport_to_id = t~airport_id FIELDS c~airport_from_id, c~airport_to_id, f~name AS airport_from_name, t~name AS airport_to_name WHERE c~carrier_id = 'LH' AND c~connection_id = '0400' INTO @DATA(connection_join). out->write( `------------------------------------------` ). out->write( `Example 6: Join of Connection and Airports` ). out->write( connection_join ).
  3. Pressione CTRL + F3 para ativar a classe e F9 para executar o aplicativo de console.
  4. Analise a saída do console. Depurar o programa, brincar com o código-fonte para se familiarizar com os conceitos.

Utilizar um objeto de dados estruturado

Neste exercício, você declara um atributo estruturado, o preenche usando uma instrução SELECT e acessa os componentes de estrutura.

Modelo:

  • /LRN/CL_S4D400_DBS_CDS (classe global)

Solução:

  • /LRN/CL_S4D400_STS_STRUCTURE (classe global)

Tarefa 1: Copiar modelo

Copie a classe modelo. Como alternativa, copie sua solução do exercício anterior.

Etapas

  1. Copie a classe /LRN/CL_S4D400_DBS_CDS para uma classe em seu próprio pacote (nome sugerido: ZCL_##_STRUCTURE, onde ## representa seu número de grupo).

    1. Abra o texto fonte da classe global /LRN/CL_S4D400_DBS_CDS.

    2. Vincule a visão Explorador de projetos ao editor.

    3. Na visão Explorador de projetos, clique com o botão direito do mouse na classe /LRN/CL_S4D400_DBS_CDS para abrir o menu de contexto.

    4. No menu de contexto, selecione Duplicar ....

    5. Insira o nome do seu pacote no campo Pacote. No campo Nome, insira o nome ZCL_##_STRUCTURE, onde ## representa seu número de grupo.

    6. Ajuste a descrição e selecione Seguinte.

    7. Confirme a ordem de transporte e selecione Concluir.

Tarefa 2: Declarar um objeto de dados estruturado

Na classe local, declare os detalhes de um atributo estruturado para substituir os atributos escalares airport_from_id, airport_to_id e carrier_name. Comece definindo um tipo de estrutura privada st_details dentro da classe local.

Etapas

  1. Mude para a classe local lcl_connection.

    1. Na classe global, selecione Tipos locais.

  2. Defina um tipo de estrutura privadast_details com os seguintes componentes:

    Componentes do tipo de estrutura st_details:

    Nome do componenteTipo de dados
    Aeroporto de Partida/dmo/airport_from_id
    Aeroporto de destino/dmo/airport_to_id
    Nome da companhia aérea/dmo/carrier_name
    1. Após a linha PRIVATE SECTION., adicione o seguinte código:

      Code Snippet
      12345678
      TYPES: BEGIN OF st_details, DepartureAirport TYPE /dmo/airport_from_id, DestinationAirport TYPE /dmo/airport_to_id, AirlineName TYPE /dmo/carrier_name, END OF st_details.
  3. Comente ou remova a declaração dos atributos airport_from_id, airport_to_id e carrier_name.

    1. Selecione as linhas com as três instruções DATA.

    2. Pressione Ctrl + < para adicionar um sinal de estrela (*) na frente de cada linha selecionada.

  4. Declare os detalhes de um novo atributo de instância privado e digite-o com o tipo de estrutura st_details.

    1. Ajuste o código da seguinte forma:

      Code Snippet
      123456789
      * DATA airport_from_id TYPE /dmo/airport_from_id. * DATA airport_to_id TYPE /dmo/airport_to_id. * * DATA carrier_name TYPE /dmo/carrier_name. DATA details TYPE st_details.

Tarefa 3: Acessar componentes da estrutura

Utilize os componentes dos detalhes do atributo estruturado no método get_output.

Etapas

  1. Ajuste a implementação do método get_output. Substitua qualquer acesso aos atributos airport_from_id, airport_to_id e carrier_name pelo componente correspondente dos detalhes do atributo.

    Dica

    Não digite os nomes dos componentes manualmente! Depois de digitar o seletor de componente de estrutura (-), pressione Ctrl + espaço para obter uma lista de todos os componentes.
    1. Navegue para a implementação do método get_output.

    2. Ajuste as instruções APPEND da seguinte forma:

      Code Snippet
      12345678910111213
      * APPEND |--------------------------------| TO r_output. * APPEND |Carrier: { carrier_id } { carrier_name }| TO r_output. * APPEND |Connection: { connection_id }| TO r_output. * APPEND |Departure: { airport_from_id }| TO r_output. * APPEND |Destination: { airport_to_id }| TO r_output. APPEND |--------------------------------| TO r_output. APPEND |Carrier: { carrier_id } { details-airlinename }| TO r_output. APPEND |Connection: { connection_id }| TO r_output. APPEND |Departure: { details-departureairport }| TO r_output. APPEND |Destination: { details-destinationairport }| TO r_output.

Tarefa 4: Preencher o atributo estruturado na instrução SELECT

Use o atributo estruturado como destino da instrução SELECT no método construtor.

Etapas

  1. Ajuste a instrução SELECT na implementação do método construtor. Substitua a lista de objetos de dados na cláusula INTO pelos detalhes do atributo estruturado.

    1. Navegue para a implementação do construtor de métodos.

    2. Ajuste a instrução SELECT da seguinte forma:

      Code Snippet
      123456789
      SELECT SINGLE FROM /DMO/I_Connection FIELDS DepartureAirport, DestinationAirport, \_Airline-Name WHERE AirlineID = @i_carrier_id AND ConnectionID = @i_connection_id * INTO ( @airport_from_id, @airport_to_id, @carrier_name ). INTO @details.
  2. Opcional: use a variante de sintaxe INTO CORRESPONDING FIELDS OF @details..

    1. Na instrução SELECT, substitua INTO @details.pelo seguinte código:

      Code Snippet
      123
        INTO CORRESPONDING FIELDS OF @details.
    2. Adicione o nome do alias AirlineName à expressão de caminho.

    3. A instrução SELECT deve ter o seguinte aspecto:

      Code Snippet
      12345678
      SELECT SINGLE FROM /DMO/I_Connection FIELDS DepartureAirport, DestinationAirport, \_Airline-Name as AirlineName WHERE AirlineID = @i_carrier_id AND ConnectionID = @i_connection_id INTO CORRESPONDING FIELDS OF @details.
  3. Ative a classe. Execute-o e analise a saída do console. Verifique se a saída exibe dados para todos os atributos.

    1. Pressione Ctrl + F3 para ativar a classe.

    2. Pressione F9 para executar a classe.