Arquivo da categoria ‘Abap’

Quando você utiliza Netweaver Application Server ABAP Developer Edition com o banco de dados SAP MaxDB em um computador Desktop, você o instala e configura por conta própria, este trabalho no mundo real em um ambiente profissional é feito por um consultor especializado chamado BASIS. Este consultor é responsável por deixar os sistemas SAP em perfeita harmonia segundo as melhores praticas para cada tipo de instalação e configuração dos componente do sistema e seus ambientes.

O banco de dados SAP MaxDB precisa ser configurado corretamente para que seu log não ocupe todo o espaço definido por padrão e o sistema não consiga mais gravar novas entradas de logs, acusando assim que existe algum item que não esta em perfeita afinidade com o restante do sistema, neste caso o console de manutenção dos sistemas SAP mudará a cor do ícone que representa o servidor para amarelo avisando a inconformidade do sistema e lhe informando com a seguinte mensagem: Funcionando mas há uma paralisação na fila de diálogos (Running But Dialog Queue StandStill).

SAP - Running But Dialog Queue StandStill

SAP – Running But Dialog Queue StandStill

Para resolver a situação você pode executar um backup completo do banco de dados NSP ou definir o log como automático. Vamos fazer as duas coisas, o backup e a configuração automática do log, mas antes você precisa instalar o SAP MaxDB Database Manager, o instalador se encontra no diretório MaxDbTools da imagem do DVD de instalação que você baixou da SAP Store e procuramos o arquivo com o nome de DBM76.exe. Clique no instalador e siga os passos do assistente de instalação:

SAP - MaxDB - Database Manager

SAP – MaxDB – Database Manager

Configurando o SAP MaxDB

1 – Abra o Database Manager e com o botão direito no item Server escolha Sync Server e escolha NSP, quando interrogado pelo usuário e senha utilize: control e a senha master que você definiu no momento da instalação do NetWeaver. Você verá que o log está cheio 100% e o próprio gerenciador sugere que você faça o backup e defina o auto log para ON:

MaxDB - Log Full

MaxDB – Log Full

2 – Ao clicar no link sugerido o assistente de backup o ajudara a executar a tarefa, clique em next:

Backup - Wizard

Backup – Wizard

3 – Clique no botão Backup Medium e insira um nome para seu backup:

Backup Medium

Backup Medium

4 – Na tela de resumo clique em Start para iniciar o backup:

Start Backup

Start Backup

5 – Após o termino do backup (pode demorar), clique em Close:

Backup - Completo

Backup – Completo

6 – Vamos definir o log como automático, clique no banco NSP e com o botão direito escolha Set Auto Log On:

Log Automático

Log Automático

7 – Clique no botão do assistente para adicionar um nome para o backup automático de log e clique OK e depois em ON:

Nome do Backup de Log

Nome do Backup de Log

8 – Com o botão direito no banco de dados NSP clique em Refresh ou aguarde alguns segundos, e o novo status será mostrado:

MaxDB - Novo Status

MaxDB – Novo Status

10 – Pronto seu sistema SAP já esta funcionando perfeitamente e pronto para processar novas mensagens, você já pode logar novamente com sucesso.

SAP System - Console

SAP System – Console

Anúncios

O SAP .NET Connector 3.0 é a versão atual do ambiente de desenvolvimento da SAP para a comunicação entre os sistemas da plataforma SAP e Microsoft .NET. Este conector suporta RFCs e serviços Web. Ele permite que você escreva aplicações diferentes, na plataforma Web, Windows Form, ou aplicativos de console. Para baixa-lo você precisa ter um usuário na SAP MarketPlace com direitos de download, entretanto existe um projeto Open Source que estende o SAP Connector e disponibiliza a biblioteca do conector da SAP na versão para computadores x86 e x64 compilados para o Microsoft Framework 4.0.

SAP Oficial: SAP .NET Connector 3.0

SAP Connector Library: https://github.com/ion-sapoval/NSAPConnector/tree/master/Libraries

O que é Remote Function Call (RFC)?

Uma chamada de função remota (RFC) é a chamada ou a execução remota de um módulo de função remoto em um sistema externo. No sistema da SAP, estas funções são fornecidas pelo sistema de interface de RFC. O sistema de interface RFC permite chamadas de função entre dois sistemas SAP, ou entre um sistema SAP e um sistema externo. As transações de dados não se limitam a obtenção de dados a partir do servidor, mas também podem inserir dados em registros do servidor. O sistema SAP pode atuar como um cliente ou um servidor em uma chamada RFC.

SAP - .NET Connector - Exportando Dados

SAP – .NET Connector – Exportando Dados

 Usando o SAP .NET Connector 3.0 no Visual Studio

1 – Após baixar a biblioteca adequada para seu sistema operacional, crie um projeto C# Windows Forms e em suas propriedades mude o Target para que seja compilado na versão 4.0 do framework. Ressaltando que estamos utilizando a versão das dlls baixadas do projeto hospedado no Github no link acima. Adicione as três bibliotecas ao seu projeto e para referencia veja a figura abaixo:

Connector - Referencia - Bibliotecas

Referencia – bibliotecas

2 – No Netweaver abra transação SE16, e verifique o conteúdo da tabela de exemplo chamada SCARR no seu ambiente de desenvolvimento, caso não possua os dados do Netweaver em um ambiente de desenvolvimento, veja como configurar um ambiente DEV (200) e alimentar dados à tabela SCARR nos posts anteriores:

Scarr

Scarr

3 – No Visual Studio crie um design simples utilizando painéis, rótulos, caixas de textos e um botão:

Visual Studio - Design Time

Visual Studio – Design Time

Exemplo:

Neste exemplo utilizamos SAP Connector 3.0 e funções RFC do Netweaver para exportar dados contidos no sistema SAP através de chamadas remotas de uma aplicação escrita em C#.

C#

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using SAP.Middleware.Connector;  // SAP .NET Connector

namespace DASapNetConnector3
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            // Cria parametros de conexão
            RfcConfigParameters meusap = new RfcConfigParameters();

            // Alimenta parametros SAP Logon
            meusap.Add(RfcConfigParameters.Name, textBox1.Text);
            meusap.Add(RfcConfigParameters.AppServerHost, textBox2.Text);
            meusap.Add(RfcConfigParameters.SystemNumber, textBox3.Text);

            // Alimenta parametros SAP GUI
            meusap.Add(RfcConfigParameters.Client, textBox4.Text);
            meusap.Add(RfcConfigParameters.User, textBox5.Text);
            meusap.Add(RfcConfigParameters.Password, textBox6.Text);

            // Cria destino
            RfcDestination meurfc = RfcDestinationManager.GetDestination(meusap);

            try
            {
                if (meurfc != null)
                {
                    // Verifica conexão
                    meurfc.Ping();
                    label1.Text = "SAP - Conectado com sucesso.";

                    // Lê tabela
                    RfcRepository repo = meurfc.Repository;

                    // Define função de exportação de textos
                    IRfcFunction funcaoRT = repo.CreateFunction("RFC_READ_TABLE");

                    // Define parametros da função
                    funcaoRT.SetValue("query_table", "SCARR");
                    funcaoRT.SetValue("delimiter", "|");

                    // Chama função
                    funcaoRT.Invoke(meurfc);

                    // Recupera Dados cru, você precisa trata-los para
                    // que sejam humanamente legivel
                    IRfcTable tabela = funcaoRT.GetTable("DATA");

                    // Recupera texto
                    string dados = tabela.ToString();

                    // Workaround para limpar tabela
                    // Existem métodos mais eficientes
                    // Este é apenas um caminho rápido para exemplo
                    // Também há possibilidades em diferentes funções e BAPis
                    // Converter um set de dados da função em um set de dados .NET
                    dados = dados.Replace("TABLE  [STRUCTURE TAB512 { FIELD WA=","");
                    dados = dados.Replace("[STRUCTURE TAB512 { FIELD WA=", "");
                    dados = dados.Replace("}]", "\n");

                    // alimenta GUI
                    richTextBox1.AppendText(dados.TrimStart());

               }
            }
            catch (Exception ex)
            {
                // Erro ao conectar
                label1.Text = "SAP - Desconectado";
                MessageBox.Show(ex.ToString(), "Erro",
                                MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
    }
}

No ciência da computação, Data Access Object é um padrão para um objeto que fornece uma interface abstrata para algum tipo de banco de dados ou outro mecanismo de persistência e que permite separar regras de negócio das regras de acesso a banco de dados. A vantagem de usar objetos de acesso a dados é a separação simples e rigorosa entre duas partes importantes de uma aplicação que não devem e não podem conhecer quase que nada uma da outra, e que podem evoluir frequentemente e independentemente.

O DAO implementa o mecanismo de acesso necessário para trabalhar com a fonte de dados. A fonte de dados pode ser um armazenamento persistente como um RDBMS, um serviço externo, como uma troca de B2B, um repositório como um banco de dados LDAP, um serviço de negócios acessado via CORBA, Internet Inter-ORB Protocol (IIOP) ou soquetes de baixo nível. O componente de negócio que se baseia no DAO usa a interface mais simples exposta pelo DAO para seus clientes.

ABAP e DAO

O ABAP Objects possui conceitos comuns com o Java e utilizar o DAO Pattern que é um método padrão já consagrado para separar a camada de negocio da camada do banco de dados facilita muito a legibilidade e organização do código ABAP, visto que o SAP R/3 já comtempla uma arquitetura propicia em três camadas e um ambiente estabelecido onde podemos cortar certos caminhos, tornado simples, fácil e até mesmo divertido criar este tipo de programação, pois na pratica você tem uma classe para o objeto de negocio que contem as regras para cada método do objeto e uma classe para o objeto de dados que é responsável por manipular os dados no banco de dados e negocia-lo com o objeto de transferência que fica responsável pela comunicação com a interface de usuário.

O ABAP possui a vantagem de que não precisamos aplicar o Pattern Factory Method ao DAO, pois o Open SQL já nos possibilita uma função semelhante e podemos utiliza-lo em nosso objeto DAO, a vantagem é que outros desenvolvedores que utilizarão seu código já saberão onde está a regra e onde está a funcionalidade de acesso a dados e também possibilita uma sintaxe simples e homogênea na programação da GUI caso seu programa utilize alguma interface com o usuário

DAO - CRUD - ABAP

DAO – CRUD – ABAP

DAO Pattern

O DAO é um padrão flexível e não uma regra ele é utilizado em conjunto com Factory Pattern e Broker Pattern (veja Patterns relacionados no link abaixo) por isto é comum você encontrar algumas variações de sua implementação, o padrão possui quatro especificações para que possa ser utilizado corretamente elas são: DataAccessObject, DataSourceObject, BussinesObject e TransferObject.

  1. DataAccessObjecté o objeto principal desse padrão. O Data Access Object abstrai a implementação fundamental de acesso a dados para o Business Objects para permitir acesso transparente à fonte de dados.
  2. DataSourceObjectrepresenta uma implementação da fonte de dados. Uma fonte de dados pode ser uma base de dados tal como um RDBMS, repositório XML, e assim por diante.
  3. BussinesObject – o objeto de negócios representa o dados do cliente. É o objeto que requer acesso à fonte de dados para obter e armazenar dados.
  4. TransferObjectrepresenta um objeto de transferência usado como um suporte de dados. O Data Access Object pode usar um objeto de transferência para retornar dados para o cliente. O Data Access Object também pode receber os dados do cliente em um objeto de transferência para atualizar os dados na fonte de dados.

DAO Pattern: http://www.oracle.com/technetwork/java/dataaccessobject-138824.html

CRUD – DAO

CRUD acrónimo de Create, Read, Update e Delete, utiliza as quatro operações básicas  para criação, consulta, atualização e exclusão de dados.

Através do padrão DAO vamos utilizar as operações CRUD para manipular dados no banco de dados. O DAO é um Pattern J2EE, mas como ele separa as regras de negocio do acesso a dados também podemos utiliza-lo com qualquer tipo de interface, seja pela linha de comando, uma GUI desktop ou aplicações web.

Criando um programa ABAP

1 – Crie uma tabela transparente chamada ZFUNCIONARIOS utilizando os elementos de dados e as referencias necessárias aos campos CURR do dicionário de dados ABAP:

Tabela transparente - ZFUNCIONARIOS

Tabela transparente – ZFUNCIONARIOS

2 – Crie um menu e um titulo para o Status 100 com as funções necessárias para os eventos dos botões em seu programa e utilize a imagem abaixo para referencia:

Menu Painter

Menu Painter

3 – Crie uma tela de numero 100 no Screen Painter para seu programa com o seguinte layout:

Screen Painter

Screen Painter

 

Exemplo:

Neste exemplo usamos o Pattern DAO para criar operações CRUD utilizando uma interface gráfica. O DAO torna o código ABAP  mais legível pois separa as classes em objetos distintos e proporciona aos desenvolvedores a utilização de uma sintaxe mais homogênea em seus programas.

O exemplo separa o programa principal do objeto de negocio e do objeto de acesso a dados entretanto colocamos as duas classes DAO em um único include, você pode utiliza-las do modo que achar melhor, como por exemplo utilizando-as como classes globais.

ABAP

GUI – ZDAAPP

*&//---------------------------------------------------------------------*
*&// Report  ZDAAPP
*&//
*&//---------------------------------------------------------------------*
*&// Desenvolvimento Aberto
*&// DAO - DAAPP
*&//---------------------------------------------------------------------*

REPORT  ZDAAPP.

*// Chama include
*// ZFUNCIONARIO é a classe de negocio
*//              você pode incluir qualquer regra
*//              para validação em seus métodos.
*//
*// ZFUNCIONARIODAO é a classe de acesso a dados
*//                 utiliza o OPEN SQL como o
*//                 Pattern Factory Method já
*//                 que ele faz um trabalho equivalente

INCLUDE ZFUNCIONARIO.

*// Define objetos e variáveis
DATA : funcionario     TYPE REF TO ZFUNCIONARIO,
       funcionarioDAO  TYPE REF TO ZFUNCIONARIODAO,
       resultado       TYPE ABAP_BOOL,
       TPESQUISAR      TYPE string,
       TID             TYPE string,
       tnome           TYPE string,
       tsobre          TYPE string,
       tcargo          TYPE string,
       tsalario        TYPE string,
       cid             TYPE i,
       csal            TYPE ZSAL.

START-OF-SELECTION.

*// Cria objetos
  CREATE OBJECT FUNCIONARIO.
  CREATE OBJECT FUNCIONARIODAO.

*// Define eventos clique para os botões
  DATA : OK_CODE    LIKE   SY-UCOMM,
         clique_ok  LIKE   sy-ucomm.

*// chama tela numero 100
  CALL SCREEN 100.

*// Modulo PBO
MODULE STATUS_0100 OUTPUT.

*// Define Menu e titulo do programa
  SET PF-STATUS '100'.
  SET TITLEBAR 'ZDAAPPT'.

*// Limpa evento de clique
 clique_ok = ok_code.
 CLEAR ok_code.

*// verifica ação dos botões
  CASE clique_ok.

    WHEN 'FPESQUISAR'.

      "// Trasferencia de objeto
      FUNCIONARIO = FUNCIONARIODAO->BUSCAFUNCIONARIO( TPESQUISAR ).

      "// Recupera valores e alimenta GUI
      tid = FUNCIONARIO->GETID( ).
      tnome = FUNCIONARIO->GETNOME( ).
      tsobre = FUNCIONARIO->GETSOBRENOME( ).
      tcargo = FUNCIONARIO->GETCARGO( ).
      tsalario = FUNCIONARIO->GETSALARIO( ).

    WHEN 'FNOVO'.

      " Limpa GUI
      clear:
      tid,
      tnome,
      tsobre,
      tcargo,
      tsalario.

    WHEN 'FINSERIR'.

      "// Converte valores para o objeto
      cid = tid.
      csal = tsalario.

      "// Adicona valores ao objeto
      FUNCIONARIO->SETID( cid  ).
      FUNCIONARIO->SETNOME( tnome ).
      FUNCIONARIO->SETSOBRENOME( tsobre ).
      FUNCIONARIO->SETCARGO( tcargo ).
      FUNCIONARIO->SETSALARIO( csal ).

      "// Insere dados no banco
      RESULTADO = FUNCIONARIODAO->INSERIRFUNCIONARIO( FUNCIONARIO ).

      "// Verifica resultados
      IF ( RESULTADO EQ ABAP_TRUE ).
        MESSAGE 'Dados inseridos com sucesso' TYPE 'S'.
      ELSE.
        MESSAGE 'Erro ao inserir dados' TYPE 'E'.
      ENDIF.

*// Os evento subsequentes utilizam a mesma sintaxe do evento acima
*// criando um metodo simples e facil para gravar dados
*// uma vez que você tenha qualquer objeto de negocio
*// e um objeto de acesso a dados.

      WHEN 'FALTERAR'.

      cid = tid.
      csal = tsalario.

      FUNCIONARIO->SETID( cid  ).
      FUNCIONARIO->SETNOME( tnome ).
      FUNCIONARIO->SETSOBRENOME( tsobre ).
      FUNCIONARIO->SETCARGO( tcargo ).
      FUNCIONARIO->SETSALARIO( csal ).

      RESULTADO = FUNCIONARIODAO->ALTERARFUNCIONARIO( FUNCIONARIO ).
      IF ( RESULTADO EQ ABAP_TRUE ).
        MESSAGE 'Dados alterados com sucesso' TYPE 'S'.
      ELSE.
        MESSAGE 'Erro ao inserir dados' TYPE 'E'.
      ENDIF.

      WHEN 'FAPAGAR'.

      cid = tid.
      csal = tsalario.

      FUNCIONARIO->SETID( cid  ).
      FUNCIONARIO->SETNOME( tnome ).
      FUNCIONARIO->SETSOBRENOME( tsobre ).
      FUNCIONARIO->SETCARGO( tcargo ).
      FUNCIONARIO->SETSALARIO( csal ).

      RESULTADO = FUNCIONARIODAO->APAGARFUNCIONARIO( FUNCIONARIO ).
      IF ( RESULTADO EQ ABAP_TRUE ).
        MESSAGE 'Dados apagados com sucesso' TYPE 'S'.
      ELSE.
        MESSAGE 'Erro ao inserir dados' TYPE 'E'.
      ENDIF.

    WHEN 'FSAIR'.
      LEAVE PROGRAM.

  ENDCASE.
ENDMODULE.

Include – Objeto negocio e Objeto dados

*&//---------------------------------------------------------------------*
*&// Desenvolvimento Aberto - DAO
*&// Objeto de Negocio
*&// Objeto de Dados
*&//
*&// Include           ZFUNCIONARIO
*&//---------------------------------------------------------------------*

*// Cria classe Funcionário
class ZFUNCIONARIO definition.

  public section.

*// Declara construtor com efeito Overload
    methods CONSTRUCTOR IMPORTING
               id        TYPE i      OPTIONAL
               nome      TYPE string OPTIONAL
               sobrenome TYPE string OPTIONAL
               cargo     TYPE string OPTIONAL
               salario   TYPE ZSAL    OPTIONAL.

*// Declara métodos Getter e Setter
*// Você pode incluir algumas validações
*// E criar eventos com um método de retorno para a GUI

    methods SETID importing  !ID type i .
    methods GETID returning value(RESULTADO) type i .

    methods SETNOME importing  !NOME type STRING .
    methods GETNOME returning value(RESULTADO) type STRING .

    methods SETSOBRENOME importing  !SOBRENOME type STRING .
    methods GETSOBRENOME returning value(RESULTADO) type STRING .

    methods SETCARGO importing  !CARGO type STRING .
    methods GETCARGO returning value(RESULTADO) type STRING .

    methods SETSALARIO importing  !SALARIO type ZSAL.
    methods GETSALARIO returning value(RESULTADO) TYPE ZSAL.

*// Declara atributos privados
  private section.

    data ID        type i.
    data NOME      type STRING .
    data SOBRENOME type STRING .
    data CARGO     type STRING.
    data SALARIO   type ZSAL .

ENDCLASS.

*// Implementação da classe
CLASS ZFUNCIONARIO IMPLEMENTATION.

*//  Construtor

  METHOD CONSTRUCTOR.
    me->ID = ID.
    me->NOME = NOME.
    me->SOBRENOME = SOBRENOME.
    me->CARGO = CARGO.
    me->SALARIO = SALARIO.
  ENDMETHOD.

*//  Metodos Getter e Setter

  METHOD GETID.
    RESULTADO = me->ID.
  ENDMETHOD.

  METHOD SETID.
    me->ID = ID.
  ENDMETHOD.

  METHOD GETNOME.
    RESULTADO = me->NOME.
  ENDMETHOD.

  METHOD SETNOME.
    me->NOME = NOME.
  ENDMETHOD.

  METHOD GETSOBRENOME.
    RESULTADO = me->SOBRENOME.
  ENDMETHOD.

  METHOD SETSOBRENOME.
    me->SOBRENOME = SOBRENOME.
  ENDMETHOD.

  METHOD GETCARGO.
    RESULTADO = me->CARGO.
  ENDMETHOD.

  METHOD SETCARGO.
    me->CARGO = CARGO.
  ENDMETHOD.

  METHOD GETSALARIO.
    RESULTADO = me->SALARIO.
  ENDMETHOD.

  METHOD SETSALARIO.
    me->SALARIO = SALARIO.
  ENDMETHOD.

ENDCLASS.

*&//---------------------------------------------------------------------*
*&// Desenvolvimento Aberto
*&// DAO - ZFUNCIONARIO DAO
*&//---------------------------------------------------------------------*

CLASS ZFUNCIONARIODAO DEFINITION.

*// Metodos DAO

  PUBLIC SECTION.

    METHODS BUSCAFUNCIONARIO IMPORTING ID TYPE STRING
                 RETURNING VALUE(FUNC) TYPE REF TO ZFUNCIONARIO.

    METHODS INSERIRFUNCIONARIO IMPORTING FUNCIONARIO TYPE REF TO ZFUNCIONARIO
                 RETURNING VALUE(RESULTADO) TYPE ABAP_BOOL.

    METHODS ALTERARFUNCIONARIO IMPORTING FUNCIONARIO TYPE REF TO ZFUNCIONARIO
                 RETURNING VALUE(RESULTADO) TYPE ABAP_BOOL.

    METHODS APAGARFUNCIONARIO IMPORTING FUNCIONARIO TYPE REF TO ZFUNCIONARIO
                 RETURNING VALUE(RESULTADO) TYPE ABAP_BOOL.

ENDCLASS.

CLASS ZFUNCIONARIODAO IMPLEMENTATION.

  METHOD BUSCAFUNCIONARIO.

    "// Cria tabela interna
    DATA tab TYPE ZFUNCIONARIOS.

    "// Cria objeto
    DATA FUNCIONARIO TYPE REF TO ZFUNCIONARIO.
    CREATE OBJECT FUNCIONARIO.

    "// Seleciona dados
    SELECT * INTO tab FROM ZFUNCIONARIOS WHERE ID = ID.
    ENDSELECT.

    "// Alimenta objeto
    FUNCIONARIO->SETID( tab-ID ).
    FUNCIONARIO->SETNOME( tab-NOME ).
    FUNCIONARIO->SETSOBRENOME( tab-SOBRENOME ).
    FUNCIONARIO->SETCARGO( tab-CARGO ).
    FUNCIONARIO->SETSALARIO( tab-SALARIO ).

    "// Transfere objeto
    FUNC = FUNCIONARIO.

  ENDMETHOD.

  METHOD INSERIRFUNCIONARIO.

    "// Cria tabela
    DATA tab TYPE ZFUNCIONARIOS.

    "// Recupe dados do objeto e insere na tabela
    tab-ID = FUNCIONARIO->GETID( ).
    tab-NOME = FUNCIONARIO->GETNOME( ).
    tab-SOBRENOME = FUNCIONARIO->GETSOBRENOME( ).
    tab-CARGO = FUNCIONARIO->GETCARGO( ).
    tab-SALARIO = FUNCIONARIO->GETSALARIO( ).

    "// Insere dados na tabela transparente
    INSERT INTO ZFUNCIONARIOS VALUES tab.
    IF SY-SUBRC = 0.
      RESULTADO = ABAP_TRUE.
    ELSE.
      RESULTADO = ABAP_FALSE.
    ENDIF.

  ENDMETHOD.

  METHOD ALTERARFUNCIONARIO.

    "// Cria tabela
    DATA tab TYPE ZFUNCIONARIOS.

    "// Recupe dados do objeto e insere na tabela
    tab-ID = FUNCIONARIO->GETID( ).
    tab-NOME = FUNCIONARIO->GETNOME( ).
    tab-SOBRENOME = FUNCIONARIO->GETSOBRENOME( ).
    tab-CARGO = FUNCIONARIO->GETCARGO( ).
    tab-SALARIO = FUNCIONARIO->GETSALARIO( ).

    "// Altera dados na tabela transparente
    UPDATE ZFUNCIONARIOS
       SET NOME = tab-NOME
           SOBRENOME = tab-SOBRENOME
           CARGO = tab-CARGO
           SALARIO = tab-SALARIO
           WHERE ID = tab-ID.
    IF SY-SUBRC = 0.
      RESULTADO = ABAP_TRUE.
    ELSE.
      RESULTADO = ABAP_FALSE.
    ENDIF.

  ENDMETHOD.

  METHOD APAGARFUNCIONARIO.

    "// Cria tabela
    DATA tab TYPE ZFUNCIONARIOS.

    "// Recupera ID do objeto
    tab-ID = FUNCIONARIO->GETID( ).

    "// Deleta dados da tabela transparente
    DELETE FROM ZFUNCIONARIOS
           WHERE ID = tab-ID.
    IF SY-SUBRC = 0.
      RESULTADO = ABAP_TRUE.
    ELSE.
      RESULTADO = ABAP_FALSE.
    ENDIF.

  ENDMETHOD.

ENDCLASS.

SAP – Classes – Objetos e Coleções – Abap

Publicado: 4 de dezembro de 2014 em Abap

Desde que o ABAP Objects foi lançado há vários anos atrás a polemica se instalou na comunidade de desenvolvedores ABAP quanto a utilização do novo paradigma de programação orientado a objeto junto com o antigo paradigma da programação procedural, possibilitando então escrever códigos de múltiplos paradigmas. Varias instruções do antigo paradigma foram marcadas como obsoleta pela SAP que ainda as mantem a nível de compatibilidade com programas mais antigos.

A vinda do novo paradigma causa até hoje enorme e incontáveis batalhas e discussões entre os novos e novos, os novos e velhos e os velhos e velhos desenvolvedores ABAP a fim de chegar a uma argumentação final sobre o assunto que parece não ter solução. Enquanto alguns puristas declaram firmemente que você não pode utilizar instruções do antigo paradigma com instruções orientadas objetos, outros mais liberais não veem nenhum problema nisto já que deste modo a programação se torna muito mais fácil e rápida e ainda contam com o respaldo dos exemplos oficiais disponibilizados pela SAP contidos no NetWeaver que educam os novos desenvolvedores a utilizar os dois paradigmas (transação ABAPDOCU).

Com toda está polemica, é claro que não queremos nos meter no meio deste assunto e nossa opinião não poderia ser mais obvia. Ficar em cima do muro! Pode parecer uma posição meio frouxa, mas garanto que este não é o caso. Se por um lado a programação orientada a objeto é considerada superior a programação procedural, então um código orientado a objeto bem escrito deveria ter uma melhor qualidade, e tem! Mas os exemplos e vários códigos fornecidos, escritos e assinados pela própria SAP misturam os paradigmas, então eu também posso fazer isto, também concordamos!

Já que concordamos com ambas as partes temos que achar o verdadeiro ocasionador de tal desavenças, isto não é tão difícil assim, uma simples busca na documentação oficial e logo encontramos uma da muitas explicações plausíveis para o acontecimento (existem vários pontos que divergem a programação procedural da orientada a objeto e um deles é o próprio Open SQL e os Data Objects, mas isto é assunto para outra ocasião).  Voltando para linha do raciocínio, acontece que a SAP não terminou de implementar o framework de coleções para a linguagem de programação ABAP Objects e indica nos exemplos oficiais um workaround para simular uma LISTA no conceito de programação orientada a objeto, veja no código a implementação do método:  “METHOD WRITE_LIST”.

Isto acontece exatamente no tópico de métodos que são um dos mais importantes elementos que compõem uma classe que obviamente resultará em um objeto. E mais! Também afirma que o exemplo contem instruções obsoletas e não garante a compatibilidade com futuras versões:

“The ABAP statements used for list processing are not yet fully available in ABAP Objects. However, to produce a simple test output, you can use the following statements: WRITE [AT] /<offset>(<length>) <f>
ULINE
SKIP
NEW-LINE

Note: The behavior of formatting and interactive list functions in their current state are not guaranteed. Incompatible changes could occur in a future release.”

Classes: Métodos ABAP

O que é uma lista em programação orientada a objetos?

Em programação orientada a objeto a classe de Lista faz parte do framework de coleções e é equivalente genérico da classe ArrayList . Implementa a interface genérica de listas usando uma matriz cujo tamanho é gerado dinamicamente conforme necessário. Em ABAP podemos dizer que uma lista é semelhante a uma tabela interna que pode conter varias colunas ou linhas, porem é um objeto que pode conter (Container) um objeto criado pelo desenvolvedor e ser manipulado através de outro objeto chamado de iterador.

O ABAP disponibiliza algumas classes para manipular objetos utilizando as coleções porem estas classes ainda não fazem parte de um framework de coleções consistentes como encontramos em outras linguagem com o próprio STL para C++ ou JCF para Java que são as linguagens de programação no qual o ABAP OO foi baseado.

Classes - Manipulando Objetos e Coleções

Classes – Manipulando Objetos e Coleções

Analisando a Classe do Objeto e Utilizando Coleções

Utilizamos um Pattern básico para o objeto criado na classe do código abaixo baseado no que seria comum em qualquer linguagem orientada a objeto como Java e C++.

  1. A classe utiliza encapsulamento privado para os atributos que são os campos primitivos ou não que armazenam valores para o objeto.
  2. Estes campos privados são acessados através dos tradicionais métodos Getter e Setter que são o método Get para ler um atributo do objeto e o método Set para alimentar um atributo do objeto.
  3. Utilizamos um construtor padrão e um construtor Overload para a classe, em ABAP não podemos sobrecarregar os construtores através de métodos e precisamos criar está funcionalidade pela instrução OPTIONAL declarada nos parâmetros das variáveis no escopo do método construtor.
  4. Utilizamos a classe de coleção CL_OBJECT_COLLECTION para criar uma lista para o objeto.
  5. Utilizamos a classe de coleção CL_OBJECT_COLLECTION_ITERATOR  para iterar o objeto de lista.
  6. Para continuar em cima do muro, utilizamos uma instrução FORM-PERFORM para adicionar os objetos na lista e explicamos o motivo nos comentários do código abaixo.

Você ainda pode manipular os objetos da lista, adicionado, removendo, alterando os dados para seu objeto. Mas reiteramos que as coleções ainda não estão totalmente implementadas em ABAP Objetcs o que pode tornar mais difícil este tipo de programação a não ser que você mesmo herde e estenda as classes e implemente seu próprio framework para as coleções.

Mais Questões

Seria o ABAP Objects uma linguagem incompleta? Já que as coleções são de grande importância e essenciais na orientação a objeto uma implementação incompleta justificaria o uso de instruções procedurais para a manipulação de objetos? O Open SQL deixaria o ABAP Objects com um pé no paradigma da programação declarativa já que é utilizado de forma muito similar ao SQL que é uma linguagem declarativa? Manipular dados nos objetos através do Open SQL e Data Objects (Em geral utilizam a instrução DATA) como vemos no exemplo disponibilizado pela SAP no link acima e não através de Patterns de objetos como o DAO (Data Access Objects) para Java entre outros também não quebraria o paradigma da orientação a objeto? Podemos então afirmar que ABAP é uma linguagem exclusivamente de múltiplos paradigmas? Deixaremos que vocês tirem suas próprias conclusões.

DAO Pattern: http://www.oracle.com/technetwork/java/dataaccessobject-138824.html

ABAP: Data Objects

Até o momento não há documentação oficial no site da SAP sobre as classes de coleções.

Object Handling: Manipulando Objetos

Exemplo:

Neste exemplo criamos uma classe que contem alguns recursos básicos da programação orientada a objeto como atributos privados, construtor Overload, métodos Getter e Setter e utilizamos um objeto de lista para armazenar e manipular nosso objeto.

Métodos: Overload

Coleções: Collections Iterator e Collection Map

ABAP

*&---------------------------------------------------------------------*
*& Report  ZABAPOBJETO
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Objetos Abap - Manipulando Objetos
*& Classe - Objeto - Lista - Iterador
*&---------------------------------------------------------------------*

REPORT  ZABAPOBJETO.

* Cria classe Participante
class ZPARTICIPANTE definition.

  public section.

* Declara construtor com efeito Overload
    methods CONSTRUCTOR IMPORTING
               pid    TYPE i      OPTIONAL
               pnome  TYPE string OPTIONAL
               pidade TYPE i      OPTIONAL.

* Declara métodos Getter e Setter

    methods SETID importing  !PID type i .
    methods GETID returning value(RESULTADO) type i .
    methods SETNOME importing  !PNOME type STRING .
    methods GETNOME returning value(RESULTADO) type STRING .
    methods SETIDADE importing !PIDADE type I .
    methods GETIDADE returning value(RESULTADO) type I .

* Declara atributos privados
  private section.

    data ID    type i.
    data NOME  type STRING .
    data IDADE type I .

ENDCLASS.

* Implementação da classe
CLASS ZPARTICIPANTE IMPLEMENTATION.

*  Construtor

  METHOD CONSTRUCTOR.
    me->ID = PID.
    me->NOME = PNOME.
    me->IDADE = PIDADE.
  ENDMETHOD.

*  Metodos Getter e Setter

  METHOD GETIDADE.
    RESULTADO = me->IDADE.
  ENDMETHOD.

  METHOD GETNOME.
    RESULTADO = me->NOME.
  ENDMETHOD.

  METHOD GETID.
    RESULTADO = me->ID.
  ENDMETHOD.

  METHOD SETIDADE.
    me->IDADE = PIDADE.
  ENDMETHOD.

  METHOD SETNOME.
    me->NOME = PNOME.
  ENDMETHOD.

  METHOD SETID.
    me->ID = PID.
  ENDMETHOD.

ENDCLASS.

* testa programa
START-OF-SELECTION.

* Testa Classe
  DATA: p1    TYPE REF TO ZPARTICIPANTE,
        p2    TYPE REF TO ZPARTICIPANTE,
        id    TYPE i,
        nome  TYPE String,
        idade TYPE i.

* Istancia Objeto usando Construtor Overload
  CREATE OBJECT P1
    EXPORTING
      PID    = 1
      PNOME  = 'José Pereira'
      PIDADE = 35.

* Métodos Getter
  id    = p1->GETID( ).
  nome  = P1->GETNOME( ).
  idade = P1->GETIDADE( ).

* Imprime valores P1
  WRITE: / 'Valor do Objeto P1: ', id, nome, idade.

*Instancia Objeto padrão

  CREATE OBJECT P2.
* Métodos Setter
  p2->SETID( 2 ).
  p2->SETNOME( 'Joao da Silva' ).
  p2->SETIDADE( 20 ).

* Métodos Getter
  id    = p2->GETID( ).
  nome  = P2->GETNOME( ).
  idade = P2->GETIDADE( ).

* Imprime valores P2
  WRITE: / 'Valor do Objeto P2: ', id, nome, idade.

SKIP 2.
WRITE : / 'Objetos da lista:'.
SKIP 1.

* ***********************************************
* ************* Manipulando Objetos *************
* ***********************************************
*
*
* Define Lista para iterar objetos
* Listas e iteradores fazem parte do framework de coleções
* São o meio padrão para manipular objetos
* No entanto em ABAP Objects as coleções não
* foram totalmente implementadas.

* Declara instancia da classe para a lista
  DATA ITEM TYPE REF TO ZPARTICIPANTE.

* Declara objeto de lista e iterador
  DATA LISTA TYPE REF TO CL_OBJECT_COLLECTION.
  DATA ITERADOR TYPE REF TO CL_OBJECT_COLLECTION_ITERATOR.

* Cria lista
  CREATE OBJECT LISTA.

* Adiciona Objeto a lista
  PERFORM ADD USING 3 'Mario Alvim' 27.
  PERFORM ADD USING 4 'Fernando Moraes' 45.
  PERFORM ADD USING 5 'Eduardo gonçalves' 38.

* Atribui objeto ao Iterador
  ITERADOR = LISTA->GET_ITERATOR( ).

* Usa iterator como um cursor de banco de dados
  WHILE ITERADOR->HAS_NEXT( ) IS NOT INITIAL.

    " Verifica objetos da lista
    ITEM ?= ITERADOR->GET_NEXT( ).

    " Alimenta objeto
    id = ITEM->GETID( ).
    nome = ITEM->GETNOME( ).
    idade = ITEM->GETIDADE( ).

    " Imprime dados do objeto
    WRITE : / id, nome, idade.

  ENDWHILE.

* Cria uma polemica instrução FORM-PERFORM
* Seria possivel criar uma classe com um método estatico
* para executar a mesma função desta sub-rotina
* mas encapsular os objetos criados daria muito mais trabalho
* do que mesclar Objetos e uma instrução procedural.
*
* Desde que as Coleções não estão totalmente implementadas em ABAP OO
* Exemplos utilizando o FORM-PERFORM para criar objetos
* são muito comuns mesmo nos exemplos disponibilizados pela SAP
* você pode conferir nos exemplos do NETWEAVER basta procurar na transação
* ABAPDOCU e vai encontrar varios exemplos utilizando objetos inicializados com FORM-PERFORM
* Este processo seria equivalente a uma VOID em C++ ou Def em Python ou Ruby que pode estar
* tanto dentro de uma classe como um método ou fora de uma classe como um procedimento.

FORM ADD USING VALUE(pid)  TYPE i
               VALUE(pnome) TYPE string
               VALUE(pidade) TYPE i.

* Cria objeto da classe como item
  CREATE OBJECT ITEM
    EXPORTING
      PID    = pid
      PNOME  = pnome
      PIDADE = pidade.

* Adiciona a lista
  LISTA->ADD( ITEM ).

ENDFORM.

SAP – ABAP Unit – Testes Unitários – Abap

Publicado: 30 de novembro de 2014 em Abap

A maioria das metodologias disponíveis para o desenvolvimento de software e gerenciamento de projetos incluem como pratica básica essencial o desenvolvimento e execução de testes unitários para que um projeto de desenvolvimento possa passar para próxima fase.

Uma boa execução de um projeto bem elaborado em diversas metodologias utilizam ambientes e exigem que os testes unitários sejam executados no ambiente de desenvolvimento (DEV) utilizando uma ferramenta para este proposito e reexecutados por consultores  funcionais/testadores, na fase de testes unitários no ambiente real de qualidade (QAS) para que só então possam executar a fase de testes integrados antes de aprovarem e homologarem o software para utilização em um ambiente produtivo (PRD).

O teste unitário executado do ponto de vista do setor de qualidade (QAS) é feito validando todas as partes dos software, incluindo, design intuitivo, usabilidade, teclas de atalho, layouts, grafia, links e etc. É claro que existem algumas diferenças sutis entre metodologias, como um ou outro procedimento ou diferentes nomenclaturas mas no final todas possuem o mesmo proposito, um software de qualidade, livre de erros e dentro do orçamento inicial do projeto. Bem! No mundo real, não importa qual a metodologia escolhida, isto nem sempre é possível.

Contudo a SAP possui sua própria metodologia desenvolvida ao longo de 40 anos de experiência no mercado para software corporativo, e muitos destes anos como líder mundial em software empresarial, podemos afirmar que sua metodologia é comprovadamente eficiente e durante a evolução de seu desenvolvimento influenciou muitas outras metodologias de software existentes e vice versa, a nova versão da metodologia SAP também incorporou o DNA dos polêmicos métodos de desenvolvimento ágil e assim o ASAP 8 conta com duas aproximações da metodologia, o  Standard ASAP e Agile ASAP.

ASAP: http://scn.sap.com/community/asap-methodology

ABAP Unit

ABAP Unit é parte do ambiente de teste para programas ABAP. Unidade ABAP permite a implementação de testes de unidade e  execução manual e automática. Testes de unidade ABAP são métodos de classes ABAP especialmente designados. Os métodos de ensaio funcionam como scripts, com o qual o código a ser testado pode ser executado, e com a qual o resultado como em um ensaio pode ser avaliado. ABAP OO é conceitualmente parecido com Java e C++, deste modo os teste unitários ABAP são similares ao JUnit do Java. O ABAP Unit é adequado para desenvolvimento orientado a testes (TDD).

ABAP Unit: Abap Unit Overview

Executando Testes Unitários com  ABAP Unit

Os testes unitários ABAP podem ser escritos para classes ou para funções. Existe dois principais métodos de criar um teste unitário, eles são Global ou Local.

Global :

1 – Abra o Class Builder e crie uma classe chamada ZParticipante, com os seguintes atributos (você pode utilizar o código abaixo para se basear na criação da classe):

Classe - Atributos

Classe – Atributos

2 – Crie os seguintes métodos para a classe:

Classe - Métodos

Classe – Métodos

3 – Na barra de ferramentas clique em Source-Code Based e preencha os métodos para a classe ZParticipante de acordo com  a classe do código abaixo:

Classe - Implementação

Classe – Implementação

4 – Para criar uma classe de testes clique no menu Utilities->Test Class Generation e você será guiado pelo Wizard sobre como criar a classe de teste (Utilize a classe de teste encontrada abaixo para preencher o Wizard e implementar os métodos gerados).

  • Para acessar a classe de testes, no menu GO TO->Local Definitions/Implementation-> Local Test Classes.
  • Para testar os métodos clique no menu Class Source->Unit Test
Classe Teste - Wizard

Classe Teste – Wizard

Teste Unitário – ABAP Unit – Métodos

Um modo de testar um objeto é testando seus métodos Setters e retornando os métodos Getters como comparação, evitando assim erros de logica no objeto, além destes métodos você pode testar outros métodos do objeto como achar melhor:

1 – Caso não queira utilizar o método Global você pode testar classes locais diretamente de um programa ABAP, entre na transação SE38 e crie um programa chamado ZDAUNITESTE e utilize o código abaixo, compile e teste.

  • Para executar o teste unitário na classe, o procedimento é o mesmo do procedimento global, no menu Program->Test->Unit Test.
  • Para obter um erro no método substitua o valor de comparação no método ASSERT por um valor diferente do código abaixo:
Teste Unitário - Erros

Teste Unitário – Erros

2 – Corrija o código da classe de teste de acordo com o código abaixo e rode o teste novamente:

Teste Unitário - OK

Teste Unitário – OK

Exemplo:

Neste exemplo criamos uma simples classe com métodos Getter e Setter e uma classe de caso de teste para efetuar um teste unitário nos métodos criados.

Obs: O método utilizado para o testar o código abaixo é executado em um programa local, de modo local, caso queira testar classes globais com a classe de teste atrelada a classe testada, utilize os trechos das classes abaixo para criar as classes pelos Wizards do Class Builder como mostra as figuras acima.

ABAP

Classe – Participante

*&---------------------------------------------------------------------*
*& Report  ZDAUNITESTE
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Testes unitários - ABAP
*&---------------------------------------------------------------------*

REPORT  ZDAUNITESTE.

* Cria classe Participante
class ZPARTICIPANTE definition.

  public section.

* Declara métodos Getter e Setter

    methods SETNOME importing  !PNOME type STRING .
    methods GETNOME returning value(RESULTADO) type STRING .
    methods SETIDADE importing !PIDADE type I .
    methods GETIDADE returning value(RESULTADO) type I .

  protected section.

* Declara atributos privados
  private section.

    data NOME type STRING .
    data IDADE type I .

ENDCLASS.

* Implementação da classe
CLASS ZPARTICIPANTE IMPLEMENTATION.

*  Metodos Getter e Setter

  METHOD GETIDADE.
    RESULTADO = me->IDADE.
    "Inverta o código acima: me->IDADE = RESULTADO
    "Você vai obter um erro de lógica
    "Passara pelo compilador ABAP
    "Mas não passara pelo teste Unitário
    "Deste modo você previne erros escritos
    "por desatenção ou desenvolvimento emergências
    "como nos Sprints em algumas metodologias

  ENDMETHOD.

  METHOD GETNOME.
    RESULTADO = me->NOME.
  ENDMETHOD.

  METHOD SETIDADE.
    me->IDADE = PIDADE.
  ENDMETHOD.

  METHOD SETNOME.
    me->NOME = PNOME.
  ENDMETHOD.
ENDCLASS.

* testa programa
START-OF-SELECTION.

* Testa Classe
  DATA: p1    TYPE REF TO ZPARTICIPANTE,
        nome  TYPE String,
        idade TYPE i.

* Istancia Objeto
  CREATE OBJECT P1.

* Métodos Setter
  p1->SETNOME( 'Joao da Silva' ).
  p1->SETIDADE( 20 ).

* Métodos Getter
  nome =  P1->GETNOME( ).
  idade = P1->GETIDADE( ).

* Imprime valores
  WRITE: / nome, idade.

* Classe de Teste Unitário.
* Na definição da classe de teste abaixo:
* "#AU Risk_Level Harmless não é um comentário
* e sim um decorador indicando o nível risco do teste
* sem este decorador a classe não testará os métodos.

CLASS ZPARTICIPANTE_TEST DEFINITION FOR TESTING."#AU Risk_Level Harmless

  PUBLIC SECTION.

    METHODS:
      SETNOME FOR TESTING,
      SETIDADE FOR TESTING.

ENDCLASS.

CLASS ZPARTICIPANTE_TEST IMPLEMENTATION.

* Teste unitario para metodos Getter e Setter
  METHOD SETNOME.

    DATA p1 TYPE REF TO ZPARTICIPANTE.
    CREATE OBJECT p1.

    p1->SETNOME('Nome').
    cl_aunit_assert=>ASSERT_EQUALS(
      exporting
        EXP                  =     'Nome'          " Data Object with Expected Type
        ACT                  =     p1->GETNOME( )  " Data Object with Current Value

    ).
  ENDMETHOD.

  METHOD SETIDADE.
    DATA p2 TYPE REF TO ZPARTICIPANTE.
    CREATE OBJECT p2.

    p2->SETIDADE( 20 ).
    cl_aunit_assert=>ASSERT_EQUALS(
      exporting
        EXP                  =     20          " Data Object with Expected Type
        ACT                  =     p2->GETIDADE( )  " Data Object with Current Value

    ).
  ENDMETHOD.

ENDCLASS.

SAP MaxDB é um banco de dados estratégico criado para rodar em todas as soluções SAP e substituir os bancos de dados Oracle, IBM DB2 e MSSQL Server  tornando as soluções SAP mais acessíveis em termos de custo para clientes de grande e médio porte. O SAP MaxDB foi construído como uma solução open source baseado em MySQL sob a licença GNU GPL, as versão anteriores do MaxDB ainda são mantidas pela comunidade open source mas a SAP não contribui mais com estas versões.

Ao longo dos últimos anos, a tecnologia SAP MaxDB continuou a evoluir com investimentos muito significativos em inovações e essas inovações não são em código aberto. Assim o mais recente produto SAP MaxDB não é open source, entretanto ele é gratuito em sua versão comunitária para uso com aplicações não SAP e possui licença comercial para uso com aplicações SAP.

Com 40 anos de inovação atuando em mais de 130 países e com mais de 100 mil clientes que utilizam soluções SAP, o SAP MaxDB ainda é um banco de dados jovem mas conta com mais de 6.500 clientes em 15.000 instalações mais soluções que utilizam liveCache e Content Server.

SAP MaxDB: http://maxdb.sap.com/

SAP MaxDB e C++ MFC

O C++ MFC utiliza as classes de fundação Microsoft e é a linguagem padrão para se desenvolver aplicativos Desktop C++ para Windows, você precisa no mínimo de uma versão profissional do Visual Studio para utilizar este framework.

A SAP disponibiliza uma API para utilizar o MaxDB com a linguagem de programação C++ utilizando os sistemas operacionais Unix, Linux e Windows, possibilitando integrar soluções Enterprise SAP que utilizam o banco de dados MaxDB com aplicações escritas em C++ ou permite que aplicações C++ utilizem o SAP MaxDB gratuitamente também em soluções que não possuem o intuito de integrar dados com os sistemas SAP.

Softwares Requeridos

Para utilizar este walkthrough completo integrando uma solução C++ com a linguagem de programação ABAP, você precisa instalar vários software entres eles o NetWeaver Application Server ABAP no qual já possui uma instalação completa do ambiente de desenvolvimento SAP com uma instancia do banco de dados MaxDB, caso queira utilizar somente o lado C++ você pode baixar o SAP MaxDB diretamente da SAP Store:

NetWeaver Application Server ABAP: Mini SAP

Download SAP MaxDB sistemas não SAP: SAP Store

SAP MaxDB SQL Studio: Desenvolvimento Aberto walkthrough

API C++ e  Drivers ODBC

Microsoft Fundation Classes permite utilizar suas classes para conectar ao MaxDB de um modo simples através do protocolo padrão ODBC, no entanto os drivers ODBC disponibilizados pela SAP não possuem a mesma arquitetura para aplicativos win32 (código nativo)  x64, então precisamos utilizar o driver 32bit disponibilizado pelo SAP MaxDB SQL Studio.

Caso não queira utilizar as classes MFC, a instalação do SAP MaxDB incluída nos produtos SAP como o núcleo de desenvolvimento do sistema SAP R/3 chamado de NetWeaver Application Sever ABAP já comtempla uma API C++ para que você possa acessar o banco de dados MaxDB e se encontra no seguinte local:

C:\sapdb\clients\NSP\sdk\sqldbc\incl
C:\sapdb\NSP\db\doc\FirstSteps\SQLDBC

Conectando ao MaxDB NSP com C++

1 – Caso utilize este tutorial com o NetWeaver primeiro tenha certeza que servidor de aplicação e a instancia SAP do banco de dados está rodando, caso utilize apenas o MaxDb e C++ ignore este passo:

SAP - Servidor de Aplicação - e Banco de dados - NetWeaver/MaxDB

SAP – Servidor de Aplicação – e Banco de dados – NetWeaver/MaxDB

2 – Abra o SQL Studio utilizando o servidor MaxDB e o banco de dados NSP ou seu próprio banco de dados caso não utilize o sistema SAP:

NSP - NetWeaver Database

NSP – NetWeaver Database

3 – Crie uma tabela Z que significa uma tabela não SAP Standard que não será transparente no conceito do dicionário de dados do sistemas SAP para isto utilize o script logo abaixo, não se assuste para desenvolvedores não SAP isto é apenas uma tabela comum do banco de dados:

Tabela Não Transparente

Tabela Z Não Transparente

4 – Utilizaremos os drivers ODBC do SAP MaxDB SQL Studio. No painel de controle escolha ferramentas administrativas e fonte de dados ODBC de 32bit, em drivers verifique seu driver NSP:

ODBC 32bit

ODBC 32bit

5 – Crie uma nova fonte de dados do usuário escolha o driver NSP ou o driver apropriado e clique em concluir:

ODBC SQLSTUDIO

ODBC SQLSTUDIO

6 – Preencha os dados de conexão com o servidor e o banco de dados e finalize:

Dados Servidor

Dados Servidor

7 – No Visual Studio crie uma solução MFC Dialog Based e disponha na tela um Static Text, um List Control e um Button, utilize a figura abaixo para o design:

Design Time

Design Time

8 – Utilize o código abaixo para manipular dados utilizando o SAP MaxDB:

C++ - Programa

C++ – Programa

9 – Para utilizar o ABAP para ler ou gravar dados nesta mesma tabela não transparente utilizando uma Stored Procedure no MaxDB através de códigos Native SQL, utilize o link abaixo:

Stored Procedure - Abap

Stored Procedure – Abap

Programa SAP – ABAP Native SQL: MaxDB Stored Procedure parâmetros IN e OUT

 Caso conecte em um banco de dados MaxDB utilizando soluções SAP tenha em mente que você deve respeitar o conceito de dados dos sistemas SAP e verificar os termos de garantia de cada produto SAP, visto que este método ao contrario do RFC  ignora a camada de banco de dados SAP e o dicionário de dados ABAP.

Como você pode verificar na imagem acima no ambiente ABAP o valor flutuante não vem formatado por padrão como estão acostumados os desenvolvedores SAP que utilizam instruções Open SQL e o dicionário ABAP no entanto você pode utilizar campos criados no dicionário apenas para a manipulação do valor de saída da Stored Procedure neste caso você deve alinhar os tipos de dados entre as aplicações C++ e aplicações ABAP.

Exemplo:

Neste exemplo utilizamos a linguagem de programação C++ para conectar ao banco de dados SAP MaxDB em uma instancia do banco de dados do NetWeaver e integrar uma tabela não transparente que pode ser manipulada tanto do lado C++ como dentro do sistema SAP utilizando Native SQL.

SQL – SAP MaxDB

-- Cria tabela no schema SAPNSP
CREATE TABLE SAPNSP.ZFUNCIONARIO
(
            ID_FUNCIONARIO INT,
            NOME VARCHAR (30),
            SOBRENOME VARCHAR(70),
            CARGO VARCHAR(30),
            SALARIO DECIMAL(9,2)
)

-- Insere dados na tabela
Insert into SAPNSP.ZFUNCIONARIO values (1,'Steve','Gates','Programador',2550.56)
Insert into SAPNSP.ZFUNCIONARIO values (2,'Bill','Jobs','Diretor',5143.71)

CPP – arquivo h


// ConexaoSapMaxDBcppDlg.h : header file
//

#pragma once

// Inclui classe de banco de dados MFC
#include "afxdb.h"
#include "afxcmn.h"

// CConexaoSapMaxDBcppDlg dialog
class CConexaoSapMaxDBcppDlg : public CDialogEx
{

public:
	CConexaoSapMaxDBcppDlg(CWnd* pParent = NULL);	// standard constructor
	enum { IDD = IDD_CONEXAOSAPMAXDBCPP_DIALOG };

	protected:
	virtual void DoDataExchange(CDataExchange* pDX);	// DDX/DDV support


protected:
	HICON m_hIcon;

	virtual BOOL OnInitDialog();
	afx_msg void OnPaint();
	afx_msg HCURSOR OnQueryDragIcon();
	DECLARE_MESSAGE_MAP()
public:
	
	// Cria métodos e objetos da classe
	CDatabase db;
	void conectarDB(CString dns, CString usuario, CString senha);
	afx_msg void OnBnClickedButton1();
	CListCtrl m_tabela;
};

CPP – arquivo cpp


// ConexaoSapMaxDBcppDlg.cpp : implementation file
//

#include "stdafx.h"
#include "ConexaoSapMaxDBcpp.h"
#include "ConexaoSapMaxDBcppDlg.h"
#include "afxdialogex.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// CConexaoSapMaxDBcppDlg dialog


CConexaoSapMaxDBcppDlg::CConexaoSapMaxDBcppDlg(CWnd* pParent /*=NULL*/)
	: CDialogEx(CConexaoSapMaxDBcppDlg::IDD, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CConexaoSapMaxDBcppDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_LIST1, m_tabela);
}

BEGIN_MESSAGE_MAP(CConexaoSapMaxDBcppDlg, CDialogEx)
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_BN_CLICKED(IDC_BUTTON1, &CConexaoSapMaxDBcppDlg::OnBnClickedButton1)
END_MESSAGE_MAP()


// CConexaoSapMaxDBcppDlg message handlers

BOOL CConexaoSapMaxDBcppDlg::OnInitDialog()
{
	CDialogEx::OnInitDialog();

	SetIcon(m_hIcon, TRUE);			// Set big icon
	SetIcon(m_hIcon, FALSE);		// Set small icon

	// Inicializa dialogo
	// Cria o modelo de exibição de dados
	m_tabela.SetView(LV_VIEW_DETAILS);
	m_tabela.SendMessage(LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_GRIDLINES);


	return TRUE;  // return TRUE  unless you set the focus to a control
}

void CConexaoSapMaxDBcppDlg::OnPaint()
{
	if (IsIconic())
	{
		CPaintDC dc(this); // device context for painting

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// Draw the icon
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialogEx::OnPaint();
	}
}

HCURSOR CConexaoSapMaxDBcppDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}

void CConexaoSapMaxDBcppDlg::OnBnClickedButton1()
{
	// campo de dado da tabela
	CString m_campo;

	// Abre conexão
         // O SAP MAXDB requer usuário e senha em caracteres UPPERCASE
       	conectarDB(L"SAPMAXDB32", L"SAPNSP", L"PASSWORD");	

	// Cria um set de dados
	CRecordset  dados(&db);

	// Executa instrução SQL
	dados.Open(CRecordset::forwardOnly, L"Select * From SAPNSP.ZFUNCIONARIO Order by 1 DESC");
	

	// Cria item
	LVITEM lvItem;

	// cria estrutura para inserir o item
	typedef struct _LVITEM
	{
		UINT mask;
		int iItem;
		int iSubItem;
		UINT state;
		UINT stateMask;
		LPTSTR pszText;
		int cchTextMax;
		int iImage;
		LPARAM lParam;
#if (_WIN32_IE >= 0x0300)
		int iIndent;
#endif
	} LVITEM, FAR *LPLVITEM;

	// Define variaveis de itens
	int InsertItem(const LVITEM* pItem);
	int nItem;

	// Converte CString para LPTSTR atraves de um TCHAR
	TCHAR sz[1024];

	// Verifica colunas
	short nFields = dados.GetODBCFieldCount();
	int colunas = m_tabela.GetHeaderCtrl()->GetItemCount();

	// Verifica colunas
	if (colunas == 0)
	{
		// Lê metadata da tabela
		CODBCFieldInfo field;
		for (UINT i = 0; i < nFields; i++)
		{
			dados.GetODBCFieldInfo(i, field);
			m_tabela.InsertColumn(i, field.m_strName, LVCFMT_LEFT, 100);
		}

	}

	// Deleta itens do controle de lista
	m_tabela.DeleteAllItems();

	// Recupera dados da tabela
	while (!dados.IsEOF())
	{
		for (short index = 0; index < nFields; index++)
		{
			dados.GetFieldValue(index, m_campo);

			// Retorna linha do banco de dados
			if (index == 0)
			{
				// Insere linha
				lvItem.mask = LVIF_TEXT;
				lvItem.iItem = 0;
				lvItem.iSubItem = 0;
				lvItem.pszText = lstrcpy(sz, m_campo);
				nItem = m_tabela.InsertItem(&lvItem);
			}

			// Retorna colunas da linha
			m_tabela.SetItemText(nItem, index, lstrcpy(sz, m_campo));

		}
		// Move o cursor para a proxima linha
		dados.MoveNext();
	}

	// Fecha o set de dados e a conexão
	dados.Close();
	db.Close();

	
}

void CConexaoSapMaxDBcppDlg::conectarDB(CString dns, CString usuario, CString senha)
{
	// Cria string de conexão ODBC
	CString conexao;

	// Cria string de conexão
	conexao = L"DSN=" + dns + L";UID=" + usuario + L";PWD=" + senha;

	// Abre conexão
	db.OpenEx(conexao, 0);
}

SAP MaxDB é um banco de dados estratégico criado para rodar em todas as soluções SAP e substituir os bancos de dados Oracle, IBM DB2 e MSSQL Server  tornando as soluções SAP mais acessíveis em termos de custo para clientes de grande e médio porte. O SAP MaxDB foi construído como uma solução open source baseado em MySQL sob a licença GNU GPL, as versão anteriores do MaxDB ainda são mantidas pela comunidade open source mas a SAP não contribui mais com estas versões.

Ao longo dos últimos anos, a tecnologia SAP MaxDB continuou a evoluir com investimentos muito significativos em inovações e essas inovações não são em código aberto. Assim o mais recente produto SAP MaxDB não é open source, entretanto ele é gratuito em sua versão comunitária para uso com aplicações não SAP e possui licença comercial para uso com aplicações SAP.

Com 40 anos de inovação atuando em mais de 130 países e com mais de 100 mil clientes que utilizam soluções SAP, o SAP MaxDB ainda é um banco de dados jovem mas conta com mais de 6.500 clientes em 15.000 instalações mais soluções que utilizam liveCache e Content Server.

SAP MaxDB: http://maxdb.sap.com/

SAP MaxDB e C#

A SAP disponibiliza provedores para utilizar o MaxDB com as linguagens de programação .NET utilizando os sistemas operacionais Unix, Linux e Windows, possibilitando integrar soluções Enterprise SAP que utilizam o banco de dados MaxDB com aplicações escritas em C# ou permite que aplicações C# utilizem o SAP MaxDB gratuitamente também em soluções que não possuem o intuito de integrar dados com os sistemas SAP.

SAP ADO.NETInterface ADO.NET

Para utilizar este walkthrough completo integrando uma solução C# com a linguagem de programação ABAP, você precisa instalar vários software entres eles o NetWeaver Application Server ABAP no qual já possui uma instalação completa do ambiente de desenvolvimento SAP com uma instancia do banco de dados MaxDB, caso queira utilizar somente o lado C# você pode baixar o SAP MaxDB diretamente da SAP Store:

NetWeaver Application Server ABAP: Mini SAP

Download SAP MaxDB sistemas não SAP: SAP Store

SAP MaxDB SQL Studio: Desenvolvimento Aberto walkthrough

MaxDB Data Provider ADO.NET e MONO

O provedor ADO.NET for MaxDB RDBMS foi desenvolvido pelo projeto MONO sob a licença GNU para as versões open Source do SAP MaxDB, caso queira utilizar provedores das versões disponibilizadas pela SAP, estas já acompanham a instalação do MaxDB.

Download: http://sourceforge.net/projects/maxdbprovider/

Projeto MaxDB Mono: http://www.mono-project.com/archived/maxdb/

Conectando ao MaxDB em instancia SAP com C#

1 – Caso utilize este tutorial com o NetWeaver primeiro tenha certeza que servidor de aplicação e a instancia SAP do banco de dados está rodando, caso utilize apenas o MaxDb e C# ignore este passo:

SAP - Servidor de Aplicação - e Banco de dados - NetWeaver/MaxDB

SAP – Servidor de Aplicação – e Banco de dados – NetWeaver/MaxDB

2 – Abra o SQL Studio utilizando o servidor MaxDB e o banco de dados NSP ou seu próprio banco de dados caso não utilize o sistema SAP:

NSP - NetWeaver Database

NSP – NetWeaver Database

3 – Crie uma tabela Z que significa uma tabela não SAP Standard que não será transparente no conceito do dicionário de dados do sistemas SAP para isto utilize o script logo abaixo, não se assuste para desenvolvedores não SAP isto é apenas uma tabela comum do banco de dados:

Tabela Não Transparente

Tabela Z Não Transparente

4 – Após efetuar o download do provedor ADO.NET para MaxDB clique com o botão direito do mouse, desbloqueie o arquivo baixado, pois o arquivo foi compilado no Linux, caso contrario o Windows Smart Screen tentara bloquear o arquivo. Clique em instalar:

SAP MaxDb Provider for .NET

SAP MaxDb Provider for .NET

5 – Crie um projeto Windows Forms e disponha na tela um Label, um DataGridView e um Button e alinhe os componentes como na figura abaixo:

Design Time

Design Time

6 – Compile o programa e clique em conectar para se conectar a instancia SAP NSP:

Programa C#

Programa C#

7 – Para utilizar o ABAP para ler ou gravar dados nesta mesma tabela não transparente utilizando uma Stored Procedure no MaxDB através de códigos Native SQL, utilize o link abaixo:

Stored Procedure - Abap

Stored Procedure – Abap

Programa SAP – ABAP Native SQL: MaxDB Stored Procedure parâmetros IN e OUT

 Caso conecte em um banco de dados MaxDB utilizando soluções SAP tenha em mente que você deve respeitar o conceito de dados dos sistemas SAP e verificar os termos de garantia de cada produto SAP, visto que este método ao contrario do RFC  ignora a camada de banco de dados SAP e o dicionário de dados ABAP.

Como você pode verificar na imagem acima no ambiente ABAP o valor flutuante não vem formatado por padrão como estão acostumados os desenvolvedores SAP que utilizam instruções Open SQL e o dicionário ABAP no entanto você pode utilizar campos criados no dicionário apenas para a manipulação do valor de saída da Stored Procedure neste caso você deve alinhar os tipos de dados entre as aplicações C# e aplicações ABAP.

Exemplo:

Neste exemplo utilizamos a linguagem de programação C# para se conectar ao banco de dados SAP MaxDB em uma instancia do banco de dados do NetWeaver e integrar uma tabela não transparente que pode ser manipulada tanto do lado C# como dentro do sistema SAP utilizando Native SQL.

SQL – SAP MaxDB

-- Cria tabela no schema SAPNSP
CREATE TABLE SAPNSP.ZFUNCIONARIO
(
            ID_FUNCIONARIO INT,
            NOME VARCHAR (30),
            SOBRENOME VARCHAR(70),
            CARGO VARCHAR(30),
            SALARIO DECIMAL(9,2)
)

-- Insere dados na tabela
Insert into SAPNSP.ZFUNCIONARIO values (1,'Steve','Gates','Programador',2550.56)
Insert into SAPNSP.ZFUNCIONARIO values (2,'Bill','Jobs','Diretor',5143.71)

C#

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using MaxDB.Data; // SAP MaxDB Data Provider for MONO 

namespace WindowsFormsApplication1
{
    public partial class FormMaxDB : Form
    {
        
        // Declara objetos
        private static MaxDBConnection connMaxDB;   // MaxDB Data Server Provider for MONO        
        private DataTable dataTable;
        string sql;
        
        // Conexão MaxDB
        void conexaoMaxDB(string Server, string Database,
                                    string Username, string Password)
        {
            try
            {
                // String de Conexao
                string connectionString =

                    // Servidor
                    "Server=" + Server +

                    // Banco de dados
                    ";Database=" + Database +

                    // Usuario
                    ";User ID=" + Username +

                    // Senha
                    ";Password=" + Password;

                //Conecta ao datasource usando a conexão SAP MaxDB
                connMaxDB = new MaxDBConnection(connectionString);

                //Abre a conexão com o banco de dados
                connMaxDB.Open();

            }
            // Retorna erro
            catch (Exception ex)
            {
                // Mostra menssagem de erro
                MessageBox.Show(ex.ToString());
            }
        }

        // Retorna um set de dados
        public DataTable retornaTabela(string sql)
        {
            FormMaxDB acesso = new FormMaxDB();

            // SAP MaxDB requer usuario e senha em caracteres UPPERCASE
            acesso.conexaoMaxDB("localhost", "NSP", "SAPNSP", "PASSWORD");

            // Cria comando SQL
            MaxDBCommand maxCmd = new MaxDBCommand(sql);
            maxCmd.Connection = connMaxDB;
            
            // Cria DataReader
            MaxDBDataReader maxDBreader = maxCmd.ExecuteReader();
            dataTable = new DataTable();
            dataTable.Load(maxDBreader);
            
            return dataTable;
        }

        public FormMaxDB()
        {
            InitializeComponent();
        }
        
        private void button1_Click(object sender, EventArgs e)
        {
            // Alimenta grade de dados
            FormMaxDB dados = new FormMaxDB();            
            dataGridView1.DataSource = dados.retornaTabela("Select * from SAPNSP.ZFUNCIONARIO");
        }
    }
}

SAP MaxDB – Soluções Enterprise com Java

Publicado: 13 de novembro de 2014 em Abap, Java

SAP MaxDB é um banco de dados estratégico criado para rodar em todas as soluções SAP e substituir os bancos de dados Oracle, IBM DB2 e MSSQL Server  tornando as soluções SAP mais acessíveis em termos de custo para clientes de grande e médio porte. O SAP MaxDB foi construído como uma solução open source baseado em MySQL sob a licença GNU GPL, as versão anteriores do MaxDB ainda são mantidas pela comunidade open source mas a SAP não contribui mais com estas versões.

Ao longo dos últimos anos, a tecnologia SAP MaxDB continuou a evoluir com investimentos muito significativos em inovações e essas inovações não são em código aberto. Assim o mais recente produto SAP MaxDB não é open source, entretanto ele é gratuito em sua versão comunitária para uso com aplicações não SAP e possui licença comercial para uso com aplicações SAP.

Com 40 anos de inovação atuando em mais de 130 países e com mais de 100 mil clientes que utilizam soluções SAP, o SAP MaxDB ainda é um banco de dados jovem mas conta com mais de 6.500 clientes em 15.000 instalações mais soluções que utilizam liveCache e Content Server.

SAP MaxDB: http://maxdb.sap.com/

Softwares Requeridos

Para utilizar este walkthrough completo integrando uma solução Java com a linguagem de programação ABAP, você precisa instalar vários software entres eles o NetWeaver Application Server ABAP no qual já possui uma instalação completa do ambiente de desenvolvimento SAP com uma instancia do banco de dados MaxDB, caso queira utilizar somente o lado Java você pode baixar o SAP MaxDB diretamente da SAP Store:

NetWeaver Application Server ABAP: Mini SAP

Download SAP MaxDB sistemas não SAP: SAP Store

SAP MaxDB SQL Studio: Desenvolvimento Aberto walkthrough

 SAP MaxDB JDBC Drivers

A instalação do SAP MaxDB incluída nos produtos SAP como o núcleo de desenvolvimento do sistema SAP R/3 chamado de NetWeaver Application Sever ABAP já comtempla os Drivers Java para que você possa acessar o banco de dados MaxDB.

C:\sapdb\NSP\db\runtime\jar
C:\sapdb\NSP\db\doc\FirstSteps\Java

SAP MaxDB JDBC Drivers: Documentação.

Conectando ao MaxDB em instancia SAP com Java

1 – Caso utilize este tutorial com o NetWeaver primeiro tenha certeza que servidor de aplicação e a instancia SAP do banco de dados está rodando, caso utilize apenas o MaxDb e Java ignore este passo:

SAP - Servidor de Aplicação - e Banco de dados - NetWeaver/MaxDB

SAP – Servidor de Aplicação – e Banco de dados – NetWeaver/MaxDB

2 – Abra o SQL Studio utilizando o servidor MaxDB e o banco de dados NSP ou seu próprio banco de dados caso não utilize o sistema SAP:

NSP - NetWeaver Database

NSP – NetWeaver Database

3 – Crie uma tabela Z que significa uma tabela não SAP Standard que não será transparente no conceito do dicionário de dados do sistemas SAP para isto utilize o script logo abaixo, não se assuste para desenvolvedores não SAP isto é apenas uma tabela comum do banco de dados:

Tabela Não Transparente

Tabela Z Não Transparente

4 – Utilize o Driver descrito acima, através da opção propriedades do seu projeto Java e adicione o arquivo sapdbc.jar nas bibliotecas externas do seu projeto:

Bibliotecas Externas

Bibliotecas Externas

5 – Utilize o código abaixo na IDE Eclipse:

Eclipse - SAPDBC

Eclipse – SAPDBC

 

6 – Compile o programa para manipular dados utilizando o SAP MaxDB:

MaxDB - Java - Programa

MaxDB – Java – Programa

7 – Para utilizar o ABAP para ler ou gravar dados nesta mesma tabela não transparente utilizando uma Stored Procedure no MaxDB através de códigos Native SQL, utilize o link abaixo para o procedimento ABAP:

Stored Procedure - Abap

Stored Procedure – Abap

Programa SAP – ABAP Native SQL: MaxDB Stored Procedure parâmetros IN e OUT

 Caso conecte em um banco de dados MaxDB utilizando soluções SAP tenha em mente que você deve respeitar o conceito de dados dos sistemas SAP e verificar os termos de garantia de cada produto SAP, visto que este método ao contrario do RFC  ignora a camada de banco de dados SAP e o dicionário de dados ABAP.

Como você pode verificar na imagem acima no ambiente ABAP o valor flutuante não vem formatado por padrão como estão acostumados os desenvolvedores SAP que utilizam instruções Open SQL e o dicionário ABAP no entanto você pode utilizar campos criados no dicionário apenas para a manipulação do valor de saída da Stored Procedure neste caso você deve alinhar os tipos de dados entre as aplicações Java e aplicações ABAP.

Exemplo:

Neste exemplo utilizamos a linguagem de programação Java para se conectar ao banco de dados SAP MaxDB em uma instancia do banco de dados do NetWeaver e integrar uma tabela não transparente que pode ser manipulada tanto do lado Java como dentro do sistema SAP utilizando Native SQL.

SQL – SAP MaxDB

-- Cria tabela no schema SAPNSP
CREATE TABLE SAPNSP.ZFUNCIONARIO
(
            ID_FUNCIONARIO INT,
            NOME VARCHAR (30),
            SOBRENOME VARCHAR(70),
            CARGO VARCHAR(30),
            SALARIO DECIMAL(9,2)
)
 
-- Insere dados na tabela
Insert into SAPNSP.ZFUNCIONARIO values (1,'Steve','Gates','Programador',2550.56)
Insert into SAPNSP.ZFUNCIONARIO values (2,'Bill','Jobs','Diretor',5143.71)

Java

import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Vector;

import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.DefaultTableModel;

public class ConectarMaxDB implements ActionListener, ItemListener {
	// Cria componentes
	private JTable tabela;
	private JRadioButton banco1;
	private JButton botao;

	// Declara objetos de conexão
	private static Connection conn;
	private static Statement query;
	private static String bancodedados;

	public void conectar(String login, String senha) {

		// Verifica strings de conexão
		// SAP MaxDB
		// Utilize senhas com caracteres UPPERCASE
		if (bancodedados == "maxdb") {
			try {
				// Define Driver de conexão JDBC SAP MaxDB
				Class.forName("com.sap.dbtech.jdbc.DriverSapDB");

				// Servidor / Banco de Dados
				conn = DriverManager.getConnection(
						"jdbc:sapdb://localhost/NSP", login, senha);

				// Executa pedido SQL
				query = conn.createStatement();

			}

			catch (ClassNotFoundException ex) {
				ex.printStackTrace();
			}

			catch (SQLException ex) {
				ex.printStackTrace();
			}
		}
	}

	public ResultSet retornaTabela() throws SQLException {
		// Cria uma nova conexão
		Statement query;
		query = conn.createStatement();
		String sql;

		sql = "Select * from SAPNSP.ZFUNCIONARIO";

		// Executa Script
		ResultSet dados = query.executeQuery(sql);

		// Retorna set de dados
		return dados;
	}

	// Modelo
	public static DefaultTableModel criaTableModel(ResultSet rs)
			throws SQLException {

		// Cria um modelo de tabela
		ResultSetMetaData metaData = rs.getMetaData();

		// Retorna as colunas
		Vector<String> colunas = new Vector<String>();

		int columnCount = metaData.getColumnCount();

		for (int column = 1; column <= columnCount; column++) {
			colunas.add(metaData.getColumnName(column));
		}

		// Retorna dados
		Vector<Vector<Object>> dados = new Vector<Vector<Object>>();

		while (rs.next()) {
			Vector<Object> vector = new Vector<Object>();

			for (int columnIndex = 1; columnIndex <= columnCount; columnIndex++) {
				vector.add(rs.getObject(columnIndex));
			}
			dados.add(vector);
		}

		return new DefaultTableModel(dados, colunas);

	}

	public void itemStateChanged(ItemEvent arg0) {

		// Verifica item banco de dados selecionado
		Object fonte = arg0.getItemSelectable();
		int estado = arg0.getStateChange();

		if (estado == arg0.SELECTED) {

			if (fonte == banco1) {
				bancodedados = "maxdb";
			}

		}

	}

	public void actionPerformed(ActionEvent arg0) {
		// Efetua login no banco de dados
		ConectarMaxDB acesso = new ConectarMaxDB();

		// SAP MaxDB utiliza senhas com caracteres maiusculos (UPPERCASE)
		if (bancodedados == "maxdb") {
			acesso.conectar("SAPNSP", "PASSWORD");
		}

		try {
			tabela.setModel(criaTableModel(acesso.retornaTabela()));
		} catch (SQLException e) {
			e.printStackTrace();
		}

	}

	public Container criaPainel() throws SQLException {
		// Cria painel principal
		JPanel painel = new JPanel();

		// Seleciona layout
		painel.setLayout(new BoxLayout(painel, BoxLayout.PAGE_AXIS));
		painel.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));

		// Cria painel de escolha de conexão
		JPanel pescolha = new JPanel();

		pescolha.setLayout(new BoxLayout(pescolha, BoxLayout.LINE_AXIS));
		pescolha.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));

		ButtonGroup grupo = new ButtonGroup();

		// Cria componentes de radio
		banco1 = new JRadioButton("SAP MaxDB");

		// Agrupa botões de radio
		grupo.add(banco1);

		// Cria ouvinte dos botões
		banco1.addItemListener(this);

		// Seleciona primeira conexão
		banco1.setSelected(true);

		// Adiciona botões ao painel
		pescolha.add(banco1);

		// Efetua primeira conexão ao banco (SAP MAXDB)
		// SAP MaxDB utiliza senhas com caracteres maiusculos (UPPERCASE)
		ConectarMaxDB acesso = new ConectarMaxDB();
		acesso.conectar("SAPNSP", "PASSWORD");

		// Cria modelo de tabela
		tabela = new JTable(criaTableModel(acesso.retornaTabela()));

		// Adiciona um painel de rolagem
		JScrollPane rolar = new JScrollPane(tabela);

		// Cria painel do botão
		JPanel pbotao = new JPanel();

		// Seleciona layout
		pbotao.setLayout(new BoxLayout(pbotao, BoxLayout.PAGE_AXIS));

		// cria botão
		botao = new JButton("Ler dados");
		botao.addActionListener(this);

		// Adiciona botão ao painel
		pbotao.add(botao);

		// componentes ao painel principal
		painel.add(pescolha);
		painel.add(rolar);
		painel.add(Box.createVerticalStrut(10));
		painel.add(pbotao);

		return painel;
	}

	public static void criaGUI() {
		// Cria formulario
		JFrame formulario = new JFrame("SAP MaxDB - Acessando Dados");
		formulario.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

		// cria painel de conteudo
		ConectarMaxDB acesso = new ConectarMaxDB();

		try {
			formulario.setContentPane(acesso.criaPainel());
		}

		catch (SQLException e) {
			e.printStackTrace();
		}

		// Exibe o formulario
		formulario.pack();
		formulario.setVisible(true);
	}

	public static void main(String[] args) {
		javax.swing.SwingUtilities.invokeLater(new Runnable() {

			@Override
			public void run() {

				// Cria e mostra a GUI
				criaGUI();

			}
		});
	}
}

SAP MaxDB é um banco de dados estratégico criado para rodar em todas as soluções SAP e substituir os bancos de dados Oracle, IBM DB2 e MSSQL Server  tornando as soluções SAP mais acessíveis em termos de custo para clientes de grande e médio porte. O SAP MaxDB foi construído como uma solução open source baseado em MySQL sob a licença GNU GPL, as versão anteriores do MaxDB ainda são mantidas pela comunidade open source mas a SAP não contribui mais com estas versões.

Ao longo dos últimos anos, a tecnologia SAP MaxDB continuou a evoluir com investimentos muito significativos em inovações e essas inovações não são em código aberto. Assim o mais recente produto SAP MaxDB não é open source, entretanto ele é gratuito em sua versão comunitária para uso com aplicações não SAP e possui licença comercial para uso com aplicações SAP.

Com 40 anos de inovação atuando em mais de 130 países e com mais de 100 mil clientes que utilizam soluções SAP, o SAP MaxDB ainda é um banco de dados jovem mas conta com mais de 6.500 clientes em 15.000 instalações mais soluções que utilizam liveCache e Content Server.

SAP MaxDB: http://maxdb.sap.com/

SAP MaxDB e Python

O Python é uma poderosa linguagem de scripts que já vem se destacando a algum tempo em aplicações para web e ambiente corporativos, a maior empresa de soluções corporativas não poderia deixar de integrar sua aplicações e utilizar os vários benéficos da linguagem de programação Python e da sua crescente comunidade de desenvolvedores.

A SAP disponibiliza módulos para utilizar o MaxDB com a linguagem de programação Python utilizando os sistemas operacionais Unix, Linux e Windows, possibilitando integrar soluções Enterprise SAP que utilizam o banco de dados MaxDB com aplicações escritas em Python ou permite que aplicações Python utilizem o SAP MaxDB gratuitamente também em soluções que não possuem o intuito de integrar dados com os sistemas SAP.

Wiki Python: Sap MaxDB

IMPORTANTE:  Para utilizar este walkthrough completo integrando uma solução Python com a linguagem de programação ABAP, você precisa instalar vários software entres eles o NetWeaver Application Server ABAP no qual já possui uma instalação completa do ambiente de desenvolvimento SAP com uma instancia do banco de dados MaxDB, caso queira utilizar somente o lado Python você pode baixar o SAP MaxDB diretamente da SAP Store:

NetWeaver Application Server ABAP: Mini SAP

Download SAP MaxDB sistemas não SAP: SAP Store

SAP MaxDB SQL Studio: Desenvolvimento Aberto walkthrough

Módulos Python e Drivers ODBC

A instalação do SAP MaxDB incluída nos produtos SAP como o núcleo de desenvolvimento do sistema SAP R/3 chamado de NetWeaver Application Sever ABAP já comtempla módulos Python para que você possa acessar o banco de dados MaxDB porem a instalação suporta apenas a versão Python 2.3 e se encontra no seguinte local:

C:\sapdb\clients\NSP\lib\python2.3
C:\sapdb\NSP\db\doc\FirstSteps\Python

No entanto o banco de dados possui drivers ODBC para que você se conecte com qualquer versão do Python, você encontra detalhes sobre os módulos Python mais recentes e vários exemplos neste link:

MaxDB Python Modules: SAP Manual Python

Conectando ao MaxDB em instancia SAP com Python

1 – Caso utilize este tutorial com o NetWeaver primeiro tenha certeza que servidor de aplicação e a instancia SAP do banco de dados está rodando, caso utilize apenas o MaxDb e Python ignore este passo:

SAP - Servidor de Aplicação - e Banco de dados - NetWeaver/MaxDB

SAP – Servidor de Aplicação – e Banco de dados – NetWeaver/MaxDB

2 – Abra o SQL Studio utilizando o servidor MaxDB e o banco de dados NSP ou seu próprio banco de dados caso não utilize o sistema SAP:

NSP - NetWeaver Database

NSP – NetWeaver Database

3 – Crie uma tabela Z que significa uma tabela não SAP Standard que não será transparente no conceito do dicionário de dados do sistemas SAP para isto utilize o script logo abaixo, não se assuste para desenvolvedores não SAP isto é apenas uma tabela comum do banco de dados:

Tabela Não Transparente

Tabela Z Não Transparente

4 – Como estamos utilizando uma versão mais recente do Python utilizaremos os drivers ODBC do MaxDB. No painel de controle escolha ferramentas administrativas e fonte de dados ODBC de 64bit, em drivers verifique seu driver NSP:

Driver SAP MaxDB ODBC 64bit

Driver SAP MaxDB ODBC 64bit

5 – Crie uma nova fonte de dados do usuário escolha o driver NSP ou o driver apropriado e clique em concluir:

Fonte de Dados do Usuário

Fonte de Dados do Usuário

6 – Preencha os dados de conexão com o servidor e o banco de dados:

Dados do DNS da conexão

Dados do DNS da conexão

7 – Clique em testar a conexão e alimente o usuário e senha para o banco de dados:

Testar Conexão - Usuário e Senha

Testar Conexão – Usuário e Senha

8 – Com tudo funcionando conclua a conexão:

Conexão OK

Conexão OK

9 – Utilize o código abaixo para manipular dados utilizando o SAP MaxDB:

MaxDB - Programa Python

MaxDB – Programa Python

10 – Para utilizar o ABAP para ler ou gravar dados nesta mesma tabela não transparente utilizando uma Stored Procedure no MaxDB através de códigos Native SQL, utilize o link abaixo para o procedimento ABAP:

Stored Procedure - Abap

Stored Procedure – Abap

Programa SAP – ABAP Native SQL: MaxDB Stored Procedure parâmetros IN e OUT

 Caso conecte em um banco de dados MaxDB utilizando soluções SAP tenha em mente que você deve respeitar o conceito de dados dos sistemas SAP e verificar os termos de garantia de cada produto SAP, visto que este método ao contrario do RFC  ignora a camada de banco de dados SAP e o dicionário de dados ABAP.

Como você pode verificar na imagem acima no ambiente ABAP o valor flutuante não vem formatado por padrão como estão acostumados os desenvolvedores SAP que utilizam instruções Open SQL e o dicionário ABAP no entanto você pode utilizar campos criados no dicionário apenas para a manipulação do valor de saída da Stored Procedure neste caso você deve alinhar os tipos de dados entre as aplicações Python e aplicações ABAP.

Exemplo:

Neste exemplo utilizamos a linguagem de programação Python para se conectar ao banco de dados SAP MaxDB em uma instancia do banco de dados do NetWeaver e integrar uma tabela não transparente que pode ser manipulada tanto do lado Python como dentro do sistema SAP utilizando Native SQL.

SQL – SAP MaxDB

-- Cria tabela no schema SAPNSP
CREATE TABLE SAPNSP.ZFUNCIONARIO
(
            ID_FUNCIONARIO INT,
            NOME VARCHAR (30),
            SOBRENOME VARCHAR(70),
            CARGO VARCHAR(30),
            SALARIO DECIMAL(9,2)
)

-- Insere dados na tabela
Insert into SAPNSP.ZFUNCIONARIO values (1,'Steve','Gates','Programador',2550.56)
Insert into SAPNSP.ZFUNCIONARIO values (2,'Bill','Jobs','Diretor',5143.71)

Python

#!/usr/bin/env python
# -*- coding: cp1252 -*-
# Desenvolvimento Aberto
# MeuSAPMaxDB.py

# importa modulos
from Tkinter import *
import tkMessageBox
import odbc

# Cria formulario
formulario = Tk(className='.::SAP MaxDB - Desenvolvimento Aberto')
formulario.geometry("550x300+300+300")

# Cria janela para menssagem
janela = Tk()
janela.wm_withdraw()

# Cria conexão com o banco de dados
def conectar():
    # Conexão SAPMaxDB
    # SAP MaxDb Drivers necessita que o password seja
    # convertido para letras maisculas (UPPERCASE)
    # Coloque somente caracteres maiusculos no exemplo
    # trate este requerimento no seu codigo fonte
    sconexao =  "SapMaxDB/SAPNSP/password"
    try:
        con = odbc.odbc(sconexao)
    except ValueError:
        tkMessageBox.showinfo(title="Menssagem", message="Erro de Conexão", parent=janela)
    return con

# Executa e retorna cursor
def retornaFuncionarioID(sql, con):
    cursor = con.cursor()
    cursor.execute(sql)
    return cursor

# Evento do botão
def on_Pesquisar():
    # Exibe banco de dados
    titulo['text'] = "Database: SAP MaxDB"

    # Cria conexão
    con = conectar()

    # Define e executa SQL
    sql = "Select * From SAPNSP.ZFUNCIONARIO Where  ID_FUNCIONARIO = " + tpesquisa.get()
    tabela = retornaFuncionarioID(sql, con)

    # Retorna dados
    dados = tabela.fetchone()

    # Exibe dados
    tcodigo.insert(0, str(dados[0]))
    tpnome.insert(0, dados[1])
    tsnome.insert(0, dados[2])
    tcargo.insert(0, dados[3])
    tsalario.insert(0, str(dados[4]))

# Cria componentes widgets
titulo = Label(formulario, text="Database: Nenhum")
separador1 = Frame(height=2, bd=1, relief=SUNKEN)
separador2 = Frame(height=2, bd=1, relief=SUNKEN)

# labels
lcodigo = Label(formulario, text="Codigo:")
lpnome = Label(formulario, text="Nome:")
lsnome = Label(formulario, text="Sobrenome:")
lcargo = Label(formulario, text="Cargo:")
lsalario = Label(formulario, text="Salario:")
# Entry
tcodigo = Entry(formulario)
tpnome = Entry(formulario, width=50)
tsnome = Entry(formulario, width=40)
tcargo = Entry(formulario, width=30)
tsalario = Entry(formulario)
# Pesquisa
lpesquisa = Label(formulario, text="Pesquisa:")
tpesquisa = Entry(formulario)
botao = Button(formulario, text = "Pesquisar", command=on_Pesquisar)

# Define Layout
titulo.grid(row=0, sticky=W+E+N+S, pady=20)
separador1.grid(row=1, sticky=W+E+N+S, pady=5, columnspan=4)
lcodigo.grid(row=2, sticky=W, padx=20)
tcodigo.grid(row=2, column=1, sticky=W, pady=5)
lpnome.grid(row=3, sticky=W, padx=20)
tpnome.grid(row=3, column=1, sticky=W, pady=5)
lsnome.grid(row=4, sticky=W, padx=20)
tsnome.grid(row=4, column=1, sticky=W, pady=5)
lcargo.grid(row=5, sticky=W, padx=20)
tcargo.grid(row=5, column=1, sticky=W, pady=5)
lsalario.grid(row=6, sticky=W, padx=20)
tsalario.grid(row=6, column=1, sticky=W, pady=5)
separador2.grid(row=7,sticky=W+E+N+S, pady=5, columnspan=4)
# Layout pesquisa
lpesquisa.grid(row=8, column=0, pady=20)
tpesquisa.grid(row=8, column=1, pady=20)
botao.grid(row=8, column=2,pady=20)

# loop do tcl
mainloop()

O termo Enterprise se refere a organização empresarial corporativa. Na indústria de computadores, o termo é frequentemente usado para descrever qualquer grande organização que utiliza computadores, sistemas operacionais, softwares ou ferramentas de desenvolvimento para o mundo dos negócios. E ao analisarmos o DNA das soluções Enterprise que encontramos nos dias de hoje, sem duvida encontraremos a herança de uma empresa que foi amplamente responsável por tudo que conhecemos, a IBM, empresa pioneira no desenvolvimento de hardware e softwares corporativos.

O principal software corporativo é chamado de Enterprise Resource Planning (ERP) e grande parte de toda infraestrutura e metodologias existentes no universo corporativo prezam garantir que este software funcione perfeitamente desde o inicio da era da computação empresarial. O ERP nasceu de seu antecessor, Manufacturing Resource Planning (MRP) e evoluiram desde os primórdios dos pacote de gerenciamento de banco de dados comercial desenvolvido por Gene Thomas na IBM na década de 1960. Logo os primeiros sistemas ERP foram concebidos como uma ferramenta organizacional e de programação para as empresas industriais. A função da próxima geração de sistemas de software ERP foram estendidos além dos limites do que poderia ser feito para uso interno de uma empresa de fabricação individual e começou a incluir clientes e fornecedores. Não demorou muito para que outras indústrias reconhecessem os benefícios dos sistemas ERP, então as agências governamentais e organizações do setor de serviços também começaram a tirar proveito desta tecnologia.

A evolução se deu dos processos executados em grandes mainframes, como IBM/360 para os processos atuais que gerenciam enormes quantidades de dados em tempo real e são executados em diferentes plataformas transpondo os limites físicos das empresas, permitindo que o processo de trabalho continue sem fronteiras e a qualquer hora, em qualquer lugar.

De onde vem os softwares Enterprise?

Um rápido passeio pela historia das três maiores soluções Enterprise encontradas no mercado de software da atualidade, nos mostram o como foi o inicio dos sistemas corporativos:

A SAP AG criada em 1972 por cinco consultores da IBM que perceberam a possibilidade de criar um pacote de software padrão a ser executado em um mainframe IBM. Em dezoito meses foi criado o sistema R que foi renomeado para R/1, sendo seguido pelo sistema R/2 de duas camadas e logo depois o R/3 apareceu inicialmente no final dos anos 80 quando a IBM lançou sua arquitetura SNA, mas foi decidido trabalhar com Unix no lugar do mainframe IBM e após cinco anos de desenvolvimento, em 1992 o sistema R/3 finalmente foi lançado.

A JD Edwards World Solution Company, foi fundada em março 1977 e era uma empresa de software empresarial, o foco inicial da empresa foi o desenvolvimento de um programa de contabilidade necessário para seus clientes. Seu produto mais popular chamado World era centralizado em servidores, bem como multiusuário; os usuários poderiam acessar o sistema usando um dos vários terminais de computador da IBM ou “telas verdes”. Como um sistema ERP, o JD Edwards World incluía as três áreas básicas de atuação: analista funcional/negócios, desenvolvedor/programador e  administração do sistema.

O Microsoft Dynamics AX foi originalmente desenvolvido como uma colaboração entre a IBM e a dinamarquesa Damgaard Data que resultou no IBM Axapta. O Axapta foi inicialmente lançado em março de 1998, nos mercados dinamarqueses  e norte-americanos. A IBM devolveu todos os direitos sobre o produto para a Damgaard Data logo após o lançamento da versão 1.5 antes da Damgaard Data ser fundida com Navision Software A/S em 2000, a empresa combinada, inicialmente Navision Damgaard, depois Navision A/S, foi adquirida pela Microsoft em julho de 2002 e em setembro de 2011, a Microsoft anunciou o lançamento da versão nova AX 2012.

Hoje a IBM não possui uma solução de ERP mas ela endossa através de suas alianças poderosas soluções em conjunto com a SAP e Oracle:

IBM ERP Alliance: http://www.ibm.com/solutions/alliance/us/en/index/erp.html

????????????????????????????????????????
O que os Softwares Corporativos Podem Fazer?

Unificar os dados como um todo, integrando os sistemas de gestão empresarial, permitindo a centralização de todo o negócio em uma única fonte, pois são desenvolvidos para atender às necessidades das diferentes áreas de uma empresa.

As varias ferramentas oferecem aos seus gestores um maior controle sobre suas operações e planejamentos, interligando todos os departamentos e se tornando um importante apoio às decisões estratégicas da diretoria, indicando os mercados mais lucrativos no qual pode-se investir.

Como beneficio a empresa passa a obter maior agilidade aos processos e uma maximização de resultados a longo prazo, com a padronização das informações internas consegue-se uma ampla visibilidade dos procedimentos empresariais e uma automação das dinâmicas de apoio. A obtenção de dados em tempo real, possibilita a eliminação das falhas de comunicação entre os setores e um melhor gerenciamento de qualidade de seus produtos ou serviços e também um melhor relacionamento com os seus clientes.

Como é a arquitetura de um software Enterprise?

Os softwares Enterprise geralmente utilizam o topo da tecnologia disponível em termos de hardware. Novos hardwares são construídos para atender as novas exigências que as empresas demandam com o crescimento baseado no beneficio da tecnologia que elas adquirem, sendo assim novos hardwares necessitam de novas versões de softwares e sistemas operacionais para que possam ser controlados, gerando um ciclo de desenvolvimento de tecnologia de ponta.

Os programas Enterprise atuais utilizam uma arquitetura de três camadas, cada camada é auto contida o suficiente de forma que a aplicação pode ser dividida em vários computadores em uma rede distribuída. As camadas são compostas da interface do usuário (Camada de Apresentação ou Servidor de Apresentação); da lógica do negócio (Camada de Negócio ou Servidor de Aplicação) e da camada de banco de dados (Camada de Dados ou Servidor de Dados). Cada camada desta arquitetura é normalmente mantida em um ou mais servidores para tornar-se mais escalonável e independente das demais. Com o mesmo objetivo são utilizadas tecnologias de middleware como, por exemplo, COM, CORBA, Web Services ou RMI. Esta arquitetura tem como características baixos custos de disponibilização, de mudança da base de dados, de mudança na lógica de negócios, eficiente armazenamento e reutilização de recursos.

Três camadas SAP:

R/3 - Três camadas

R/3 – SAP – Três camadas

Três camadas Oracle:

JD Edwards - três camadas

JD Edwards – Oracle – Três camadas

Três camadas Microsoft:

Dynamics - Microsoft - Três camadas

Dynamics – Microsoft – Três camadas

Como funcionam na pratica para desenvolvedores e consultores?

Os softwares corporativos que integram a linha empresarial como já vimos ditam não só a tecnologia de hardware e software mas também o funcionamento de empresas de tecnologia, de desenvolvimento ou consultorias que trabalham com este tipo de solução.

No mercado de softwares corporativos um desenvolvedor em alguns casos também é um tipo de consultor ou especialista, outras profissões que conhecemos no mercado da tecnologia também se enquadram no time de consultores tendo sua própria nomenclatura, os códigos fontes são abertos e podem ser herdados e modificados, porem geralmente tudo que é desenvolvido dentro de um software corporativo pela licença sob o qual ele é gerido é de propriedade da empresa fabricante do software, entretanto é permitindo que consultorias desenvolvam e comercializem módulos adicionais para seus produtos seguindo as melhores praticas de desenvolvimento, implantação e manutenção da empresa detentora da solução.

Os sistemas ERP podem se conectar com qualquer banco de dados topo de linha do mercado e tem como parceiros as empresas fabricantes de cada banco, quando também não é proprietária de uma solução de banco de dados, em ambos os casos os bancos de dados possuem Features exclusivas desenvolvidas para uso com cada um destes sistemas. Os sistemas ERP contam com um dicionário de dados que controla o banco de dados em uso, permitindo que o sistema e os desenvolvedores utilizem uma linguagem única para acesso a dados. Possuem também seu próprio compilador e sua própria linguagem de programação na qual as consultorias podem desenvolver novos módulos ou modificar módulos existentes.

A SAP possui a linguagem Abap, a Oracle utiliza entre outros métodos a linguagem C e a Microsoft a linguagem X++. As empresas terceirizadas também podem desenvolver outros softwares corporativos que se comunicam com o ERP através de um protocolo de comunicação especifico, geralmente utilizando as tecnologias DCOM ou Corba e são nada mais que interfaces para a comunicação entre um sistema proprietário e outro compatível de terceiros através de conexões TCP/IP e podem chamar funções remotas do ERP que são criadas para inserir ou exportar dados garantindo a consistência de dados utilizando a própria regra de negocio do ERP e fornecendo uma maneira para que um programa externo escrito em linguagens como  Java, C, C ++C# ou outras línguas possam também atuar como o cliente ou servidor em uma chamada.

SAP – Abap: Linguagem de programação.

Oracle – JDE: Development Tools.

Microsoft – MorphX: IDE e linguagem X++.

Solutions_key
Como é a Metodologia dos Softwares Enterprise?

Com décadas de experiência no mercado corporativo os softwares empresariais desenvolveram algumas metodologias ao longo dos anos que possibilitam que as empresas utilizem de forma adequada suas soluções, abrangendo todas as fases de um projeto desde a engenharia de software, a definição de escopo, passando pela especificação funcional, design, construção, testes, até chegar à validação, implantação e uso produtivo da solução.

ASAP Methodology: Metodologia ASAP

Oracle Unified Method: Metodologia OUM

Microsoft Dynamics Sure Step methodology: Metodologia MS Sure Step

Falando de modo genérico já que estamos nos referindo a três ótimos softwares empresariais da atualidade, podemos perceber que os três possuem uma arquitetura semelhante que proporciona uma metodologia muito similar para execução de seus projetos, deste modo, segue uma visão geral de um projeto corporativo.

A fase de preparação geralmente é executada por um gerente de projetos e engloba o escopo, estimativas, planejamento inicial do projeto, cronograma, aspectos técnicos, definição de equipe, identificação de riscos e estratégias, planejamento de controle de qualidade e o inicio do projeto.

A fase inicial, já com os recursos definidos em ação, o gerente de projeto e os analistas funcionais devem tratar do levantamento dos processos de negócio, gestão do projeto, mudanças organizacionais, definição dos novos processos de negócio, necessidades e mudanças organizacionais.

Com toda a definição realizada, já na fase de customização e desenvolvimento, entra em cena os consultores especialistas que iniciam a configuração, implementação e o desenvolvimento das definições funcionais que entre elas estão a configuração base, a configuração final, desenvolvimento de programas, implementação de interfaces, testes unitários, testes integrados, documentação de cenários e processos, execução dos treinamentos aos key users e usuários, controle de qualidade e a correção de possíveis erros.

Na fase de pré-produção toda atenção se volta aos detalhes finais como, testes de volume, testes de stress, planejamento da implantação, estratégia de implantação, treinamentos finais e o controle de qualidade.

Com tudo pronto o projeto é finalmente implantado e o sistema é colocado em produção e os retoques finais são a transferência de pré-produção, ajuste da configuração de hardware, ajustes na configuração de software, base de dados, sistema operacional e outros. Só então se inicia os treinamentos finais, suporte aos key-users e usuários e encerramento do projeto.

Ambientes Corporativos

Integrando a metodologia de gestão de projeto os softwares corporativos e suas demais ferramentas são desenvolvidas para utilizar ambientes específicos nos quais tem o intuito de maximizar a eficiência dos métodos de implantação, desenvolvimento, testes, qualidade, treinamento, utilização e gerenciamento dos produtos adquiridos. Cada ambiente possui suas especificações de uso e são utilizados para uma finalidade especifica e devido a eficiência deste modelo outras metodologias também utilizam alguns destes cenários.

Ambientes do SAP:

Alguns dos ambientes SAP

Alguns dos ambientes SAP

Ambientes da Oracle:

Alguns dos ambientes Oracle

Alguns dos ambientes Oracle

Ambientes da Microsoft:

Alguns dos ambientes Microsoft

Alguns dos ambientes Microsoft

Como Desenvolver Suas Próprias Aplicações Enterprise?

As grandes empresas de tecnologia que desenvolvem o hardwaresoftware para o mercado corporativo em sua maioria também desenvolvem ferramentas para desenvolvimento de softwares para empresas terceirizadas, para que estas possam desenvolver seus próprios softwares empresariais ou soluções que complementas as soluções já existentes, entre elas a Oracle, a IBM, a Microsoft e com exceção da SAP que também utilizam em certos casos o Java da Oracle e ferramentas da IBM como a IDE Eclipse. Todas disponibilizam um vasto matérial sobre como desenvolver seus próprios projetos Enterprise, veja os seguintes links:

Microsoft: http://msdn.microsoft.com/en-us/library/ff648951.aspx

Oracle: http://www.oracle.com/technetwork/java/javaee/overview/index.html

IBM: http://www.ibm.com/developerworks/

SAP: Enterprise Learning

O primeiro passo é ter em mente que um software enterprise bem sucedido necessita de hardware adequado, arquitetura e programação adequada, metodologia adequada, consultoria adequada e o mais importante de tudo um grande know-how das regras de negocio das áreas incluídas no escopo de sua solução.