Conceitos de Business Function e cache no JDE – Parte 1

Usar o cache, ou caching, é um dos conceitos fundamentais das aplicações web, ou, digamos, de qualquer aplicação, seja na camada de banco de dados, na camada de aplicação ou na camada web. No JD Edwards, o caching é feito na camada de aplicação, por meio de código, e na camada web, por meio do Server Manager (HTML Server).

Podemos examinar o caching baseado em código, que normalmente é feito por meio de Business Function (BSFN).

Sempre usamos ou vemos alguns parâmetros de business function que o JDE usa para comunicar ou passar informações

LPBHVRCOM

• Ponteiro para uma estrutura de dados usada na comunicação com as business functions
• Tem a capacidade de identificar a versão atual do software
• Identifica o privilégio de acesso do usuário atual
• Tem parâmetros que tratam a janela atual e os controles da janela
• Pode identificar o controle atual que está com o foco
• Identifica o momento atual do evento que está sendo processado
• Tem o componente de ID para o identificador global de tempo de execução do job executado a partir do menu driver
• Tem informações sobre as preferências do sistema
• Tem informações sobre as preferências do usuário
• Pode exibir o ID da mensagem de erro ou 0L
• Define o flag como TRUE ao alterar o comportamento do banco de dados
• Contém a chave de evento da mensagem de erro para as event rules
• Tem informações sobre o handle de ambiente para ODBC
• Contém ponteiros para a seção de RDA
• Tem a lista encadeada de erros para programas batch
• Armazena as informações de tempo de execução do formulário para FDA
• Tem um flag que indica chamada de runtime ou chamada de business function
• Armazena um flag que indica chamada remota ou objeto de chamada de terceiros
• Tem as informações de endereço de subscription/publish da aplicação
• Guarda o ID de processo lógico de quem chamou a API jdeLaunchUBEEx
• Contém também uma área de uso futuro para novos itens

LPVOID

• Ponteiro para uma estrutura de dados void, usada atualmente no processamento de erros
• Será usado para segurança no futuro.

Temos uma Master Business Function para a maioria dos processos que inserem dados em tabelas de transação. Cada master business function usa Begin Doc, Edit Line, Edit Doc e End Doc para inserir os registros nas tabelas.

Em termos simples, de leigo, abaixo está o uso de cada função, que é chamada em sequência para criar os registros.

O que é cache:

Cache é uma memória que contém informações usadas recentemente e pode ser acessada de forma extremamente rápida para manipular dados ao criar ou atualizar uma transação em uma aplicação.

Prós de usar cache:

• O cache melhora o desempenho da aplicação em que é usado.
• O cache reduz a carga nos servidores.
• Com o cache, podemos armazenar dados de várias tabelas e acessá-los quando necessário.
• O cache é útil no lugar de tabelas temporárias, reduzindo a carga nos servidores.

Contras de usar cache:

• O cache tem limitação de capacidade de armazenamento.
• Implementar cache exige conhecimento das APIs JDECACHE.
• Solucionar problemas da memória cache é difícil.

Algumas APIs de cache que usamos com frequência para criar o cache e usá-lo para armazenar e atualizar registros:

Conceitos de Business Function e cache no JDE – Parte 2

No nosso último artigo (parte 1), demos uma visão geral dos parâmetros padrão de uma Business Function e do uso das master business functions; também falamos sobre as APIs de cache e o seu uso.

Neste artigo, vamos demonstrar o processo de criação de um cache usando as APIs de cache e, no próximo artigo, veremos como usar esta BSFN para inserir/atualizar/buscar os dados no/do cache.

Passos para criar um cache

1. Criação da estrutura de dados

Crie uma estrutura de dados (data structure) para a Business Function.

Alguns parâmetros são obrigatórios na estrutura de dados para construir um cache, e os demais dependem do requisito.

• Cachename – Obrigatório
• ActionCode – Obrigatório
• Cursor – Obrigatório

2. Associar a estrutura de dados à BSFN em C

3. Gerar o esqueleto da Business Function

4. Criar a definição da estrutura de dados no arquivo .h

5. Definir a estrutura do cache no .h

6. Definir a estrutura da chave do cache no arquivo .h

7. Criar as instâncias do cache e da chave do cache no arquivo .c

8. Declarar ponteiros e variáveis no arquivo .c

9. Inicializar o usuário

10. Inicializar o cache

O cache é inicializado com a API ‘jdeCacheInit’. Este é o passo mais importante para criar um cache.

‘jdeCacheInit’ inicializa um cache nomeado, associa o cache inicializado a um usuário e retorna um handle para o cache inicializado. Esta API contém quatro coisas:

1. Cria um cache na memória.
2. Cria um índice que será usado para acessar os registros no cache.
3. Dá ao cache o nome passado nesta API.
4. Associa o cache a um handle de cache (HCACHE), que o usuário usará para referenciar o cache nas chamadas às APIs do JDE Cache.

11. Processamento do cache

Na maior parte das vezes, o processamento do cache consiste em adicionar, atualizar, buscar e apagar no cache.

Alguns deles estão listados abaixo:

Adicionar/atualizar no cache

‘jdeCacheAdd’ adiciona um registro ao cache identificado pelo handle de cache hCache, obtido na chamada a ‘jdeCacheInit’.

‘jdeCacheUpdate’ atualiza, com os dados passados, o registro para o qual o HJDECURSOR passado aponta no momento.

Busca única no cache

‘jdeCacheFetchPosition’ recupera o registro que corresponde à chave informada. Esta API pode ser usada para posicionar o HJDECURSOR em um local específico dentro do conjunto de dados. Quando for feita uma chamada a jdeCacheFetch, ela começará a buscar a partir da próxima posição. Isso é útil para fazer buscas sequenciais a partir de um local específico do cache.

Busca múltipla no cache

A busca múltipla é possível por meio da API ‘JdeCacheFetch’. ‘JdeCacheFetch’ avança o cursor para o próximo registro do conjunto de dados, em relação à posição atual do cursor, e recupera o registro. Esta passa a ser a nova posição associada ao HJDECURSOR. Esta API não procura um registro no cache, mas busca qualquer registro que esteja depois do registro para o qual o HJDECURSOR passado aponta no momento. A API é ideal para fazer buscas sequenciais

Apagar do cache

‘jdeCacheDelete’ é a API que apaga o registro apontado pelo cursor. Só é possível apagar um registro por vez.

Encerrar o cache

Quando todo o processamento termina, a memória alocada para o cache deve ser destruída. ‘jdeCacheTerminateAll’ destrói todos os caches com o mesmo nome daquele com o hCache informado. Os caches são removidos fisicamente da memória.

O código de exemplo (abaixo) para criar o cache é dado como referência.

Conceitos de Business Function e cache no JDE – Parte 3

No nosso último artigo (parte 2), demonstramos passo a passo o processo de criação da business function de cache usando as APIs de cache e explicamos o propósito das APIs de cache.

Neste artigo, veremos como usar a business function de cache em um objeto do JDE, como os valores serão armazenados no cache e como podemos manipulá-los.

Passos para usar a business function

1. Criar a aplicação para passar ou recuperar os valores, conforme abaixo

Valores do Action Code:

1. Adicionar/atualizar
2. Buscar pela chave
3. Apagar do cache

2. No botão Add Record, chamar a BSFN em C para adicionar os registros ao cache

3. No botão Update Record, chamar a BSFN em C para atualizar os registros no cache

4. No botão Fetch Record, chamar a BSFN em C para buscar os registros no cache

5. No botão Delete Record, chamar a BSFN em C para adicionar os registros do cache

6. Executar a aplicação no web client, digitar os valores para inserir o registro no cache e pressionar o botão Add Record

Podemos ver que os valores foram adicionados ao cache depois que a API jdeCacheAdd é chamada na BSFN em C

7. Digitar valores diferentes nos controles do formulário e pressionar novamente o botão Add Record para adicionar mais um registro ao cache

Podemos ver que os valores foram adicionados ao cache depois que a API jdeCacheAdd é chamada na BSFN em C

8. Digitar um valor diferente no controle do formulário para atualizar o primeiro registro do cache

Neste caso, primeiro acontece uma busca no cache para verificar se o registro existe no cache; se o registro estiver lá, ele será atualizado no cache depois que a API jdeCacheUpdate for chamada na BSFN em C.

9. Digitar o valor da chave para buscar o registro no cache

Também neste cenário, primeiro é feita uma busca para verificar a existência do registro e, se ele existir, os valores são atribuídos aos parâmetros da BSFN depois que a API jdeCacheFetchPosition retorna sucesso.

Os valores do primeiro registro foram exibidos na aplicação depois de pressionar o botão Fetch Record

10. Digitar os valores da chave para apagar o registro do cache

Também neste cenário, primeiro é feita uma busca para verificar a existência do registro e, se ele existir, os valores são apagados depois que a API jdeCacheDelete retorna sucesso.

11. Ao tentar apagar novamente o mesmo registro do cache, é retornado um erro, porque o registro não está presente

Da mesma forma, podemos chamar a BSFN em C para buscar os registros sequenciais do cache e destruir o cache.

Conceitos de cache no E1 – JDB Cache – Parte 1

Nos artigos anteriores, compartilhamos os conceitos do cache do JDE e a sua criação. O JDE tem dois tipos de cache; o que explicamos nos posts recentes é conhecido como User Cache ou JDECACHE.

Este artigo fala sobre o segundo tipo de cache que o JDE oferece aos seus usuários, chamado JDB F98613/ DB Cache.

Como sabemos, armazenar dados do banco de dados na memória do programa, em vez de buscá-los no banco, é conhecido como caching. Isso ajuda a eliminar o overhead do banco de dados.

O JDB Cache não é uma memória compartilhada acessada por todos os processos; é memória heap local de cada processo. Cada processo tem a sua própria cópia do DB cache.

O JDB cache é um recurso de mecanismo de caching automático de tabelas do EnterpriseOne.

Quando o processo termina, o JDB cache também vai embora com o processo, para o lixo (bit bucket).

O JDB Cache pode ser implementado por meio de código C em Business Function ou de Event Rules do JDE.

Não há replicação nem sincronização entre as instâncias do JDB cache.

Implementar o JDB cache pode ajudar a melhorar o desempenho do processo, desde que seja feito após uma análise completa.

O JDB cache é memória heap local do processo e está limitado a um total de 2GB em sistemas operacionais de 32 bits.

No próximo artigo, veremos como podemos implementar e quais são as condições para usar o JDB Cache no EnterpriseOne.

Referência:

• JDB cache in EnterpriseOne
• JDEdwards EnterpriseOne Applications Task Force

Conceitos de cache no E1 – JDB Cache – Parte 2

No último artigo (parte 1), compartilhamos o conceito do JDB cache e as suas características. Neste artigo, veremos como podemos implementar o JDB cache e usá-lo de forma eficiente diante dos nossos problemas de desempenho.

Como funciona

Quando uma tabela está configurada para fazer parte do JDB cache, assim que um registro é buscado na tabela, ele também é armazenado no cache, e os Selects seguintes do mesmo registro são buscados no cache em vez de no banco de dados.

Regras básicas

1. Deve existir uma entrada na F98613, que é a lista de tabelas de cache, para a tabela.
2. A tabela deve ser acessada usando a chave primária completa.
3. A tabela deve ser acessada pela API ‘JDB_FetchKeyed’ em Business Function C ou usando a operação de I/O de tabela ‘Fetch Single’ nas event rules do JDE.
4. APIs como JDB_SetSelection ou JDB_SetSequencing não devem ser chamadas ao usar o JDB cache.
5. Não há sincronização / replicação entre processos.

Funciona da seguinte maneira:

Limitações

1. As tabelas devem ser estáticas.
2. Os mesmos registros devem ser buscados repetidamente.
3. Fazer cache de tabelas dinâmicas fará as aplicações falharem.
4. Consultas que retornam zero linha não serão armazenadas em cache.
5. Não é recomendado fazer cache de tabelas com milhões de registros.

Benefícios

1. Um recurso de mecanismo de caching automático de tabelas do EnterpriseOne.
2. Adequado para tabelas que permanecem constantes e estáticas.
3. Pode ajudar a aumentar o desempenho do processo.
4. Comandos Select redundantes sobre a mesma chave primária podem ser eliminados usando o JDB cache.

Referência:

• JDB cache in EnterpriseOne
• JDEdwards EnterpriseOne Applications Task Force

JDE Business Function and Cache Concepts – Part 1

Using the Cache or caching is one of the fundamental concepts for web applications or say any application. Be it Database tier, Application tier, or Web tier. In JD Edwards, Caching is done on the Application tier through code, and web tier through the Server manager (HTML Server).

We can go through the code based caching, which is typically done through Business Function (BSFN).

We always use or see the few business function parameters which JDE uses for communicating or passing information

LPBHVRCOM

• Pointer to a data structure used for communications with business functions
• It has capability to identify the current software version
• It will identify the current user’s access privilege
• It has parameters which will handle the current window and controls in the window
• It can identify the current control which has focus
• It identifies the current timing of the event being processed
• It has ID component for global run time Identifier for job running from menu driver
• It has information about system preferences
• It has information about user preferences
• It can display error message ID or 0L
• It will set the flag to TRUE when changing database behavior
• It contains error message event key for event rules
• It has information about environment handle for ODBC
• It contains pointers for section of RDA
• It has error linked list for batch programs
• It stores form runtime information for FDA
• It has flag which will indicate runtime call or business function call
• It stores flag to indicate remote or 3rd party call object
• It has subscription/publish Address Info of application
• It holds the logic process ID of the caller of API jdeLaunchUBEEx
• It contains future use area for new items as well

LPVOID

• Pointer to a void data structure currently used for error processing
• It will be used for security in the future.

We have Master Business Function for most of the processes which inserts data in transaction tables. Each master business function uses Begin Doc, Edit Line, Edit Doc and End Doc to insert the records in the tables.

In simple layman term, below are the usage of each function which gets called in sequence to create the records.

What is Cache:

Cache is a memory which has recently used information and can be accessed extremely fast for performing data manipulation while creating or updating a transaction in an application.

Pros of Using Cache:

• Cache improves the performance of application where it has been used.
• Cache reduces the load on servers.
• Using cache we can store data from multiple tables and access them as and when require.
• Cache is useful in place of temporary tables by reducing load on the servers.

Cons Of Using Cache:

• Cache has a limitation of storage capacity.
• Implementing cache require knowledge of JDECACHE APIs.
• Troubleshooting of cache memory is difficult.

Few Cache APIs which we use commonly to create the cache and use it to store and update records:

JDE Business Function and Cache Concepts – Part 2

In our last article(part 1) we gave an overview of standard parameters of Business Function and usage of master business functions, also we spoke about cache APIs and its usage.

In this article we will demonstrate the process of cache creation using cache APIs and in our next article we will see how to use this BSFN to insert/update/fetch the data in/from cache.

Steps for Creating a Cache

1. Data structure Creation

Create a Datastructure for the Business Function.

Few parameters are compulsory in data structure to build a cache and other parameters are dependent on the requirement.

• Cachename – Mandatory
• ActionCode – Mandatory
• Cursor – Mandatory

2. Attach the Data structure to C BSFN

3. Generate the Skeleton for the Business function

4. Create Data structure definition in the .h file

5. Define the Cache Structure in .h

6. Define the Cache Key Structure in .h file

7. Create Instances For Cache and Cache Key in .c file

8. Declare pointers and Variables in .c file

9. Initialize User

10. Initialize Cache

The Cache is initialized using ‘jdeCacheInit’ API. This is the most important step for creating a cache.

‘jdeCacheInit’ initializes a named cache, associates the initialized cache with a user and returns a handle to the initialized cache. This API contains four things:

1. Creates a cache in memory.
2. Creates an index that will be used to access records in the cache.
3. Names the cache with the name passed in this API.
4. Associates the cache with a cache handle (HCACHE) that the user will use to reference the cache in call to JDE Cache 1. APIs.

11. Cache Processing

Most of the time cache processing is consist of adding, updating, fetching and deleting the cache.

Some of them are listed below:

Cache Add/Update

‘jdeCacheAdd’ adds a record to the cache identified by the cache handle hCache that was obtained from the call to ‘jdeCacheInit’.

‘jdeCacheUpdate’ updates the record that is currently being pointed to by the passed HJDECURSOR with the passed data.

Cache Single Fetch

‘jdeCacheFetchPosition’ retrieves the record that corresponds to the given key. This API can be used to position the HJDECURSOR to a specific location within the data set. When a call to jdeCacheFetch is made, it will start fetching from the next position. This is useful for making sequential fetches beginning at a specific location in the cache.

Cache Multiple Fetch

Multiple fetch is possible through the ‘JdeCacheFetch’ API. ‘JdeCacheFetch’ advances the cursor to the next record in the data set relative to the current cursor position and retrieves the record. This will now be the new position associated with HJDECURSOR. This API does not search for a record in the cache but fetches whatever record is after the record that is currently being pointed to the passed HJDECURSOR. The API is ideal for performing sequential fetches

Cache Delete

‘jdeCacheDelete’ is the API that deletes the record that is pointed by the cursor. Only one record can be deleted at a time.

Cache Terminate

Once all the processing is complete, the memory allocated for cache should be destroyed. ‘jdeCacheTerminateAll’ destroys all caches with the same name as the one with the given hCache. The caches are physically removed from memory.

Sample code (below) for creating cache is given for reference.

JDE Business Function and Cache Concepts – Part 3

In our last article (part 2) we demonstrated the process of cache creation business function (step by step) using cache APIs and explained the purpose of cache APIs.

In this article we will see how to use the cache business function in JDE object and how the values will get stored in cache and how can we manipulate the same.

Steps for using the business function

1. Create the application to pass or retrieve the values as given below

Action Code Values:

1. Add/Update
2. Fetch based on key
3. Delete from cache

2. In Add Record Button Call the C BSFN to add the records in cache

3. In Update Record Button Call the C BSFN to update the records in cache

4. In Fetch Record Button Call the C BSFN to fetch the records from cache

5. In Delete Record Button Call the C BSFN to add the records from cache

6. Run the application in web client and key in the values for inserting the record in cache and press the Add Record button

We can see the values have been added in cache after jdeCacheAdd API is called in the C BSFN

7. Enter the different values in form control and press the Add Record Button again to add one more record in cache

We can see the values have been added in cache after jdeCacheAdd API is called in the C BSFN

8. Enter the different value in the form control to update the first record of the cache

In this case first fetch from the cache will happen to check if the record exists in the cache, if the record is there then it will get updated in cache after jdeCacheUpdate API gets called in C BSFN.

9. Enter the key value to fetch the record from the cache

In this scenario also, first fetch will get performed to check the existence of the record and if exists then the values will get assign to the BSFN parameters after the jdeCacheFetchPosition API returns success.

Values of the first record got dsiplayed in the application after pressing the Fecth Record Button

10. Enter the key values to Delete the record from cache

In this scenario also, first fetch will get performed to check the existence of the record and if exists then the values will get deleted after the jdeCacheDelete API returns success.

11. When we try to delete the same record in cache again it will return error because record is not present

Similar way we can call the C BSFN to fetch the sequential records from cache and destroy the cache.

E1 Cache Concepts – JDB Cache – Part 1

In previous articles, have shared the JDE Cache concepts and its creation. JDE has two types of cache, the one we have explained in recent posts is known as User Cache or JDECACHE.

This article will speak about the second type of cache which JDE offers to its users which is called JDB F98613/ DB Cache.

As we know storing database data in program memory rather than fetching it from database is known as Caching. This helps in eliminating the overhead of database.

JDB Cache is not a shared memory accessed by all processes rather it is local heap memory to each process. Every process has its own copy of DB cache.

JDB cache is an automated table caching mechanism feature in EnterpriseOne.

When the process completes, JDB cache will also goes away with the process into the bit bucket.

JDB Cache can be implemented through C Code in Business Function or Event Rules of JDE.

There is no replication or synchronization across each of the JDB cache instances.

Implementing JDB cache can help in improving the performance of the process provided it is done after complete analysis.

JDB cache is local process heap memory and it is limited to a total of 2GB in 32-bit operating systems.

In next article we will see the how we can implement and what are the conditions to use the JDB Cache in EnterpriseOne.

Reference:

• JDB cache in EnterpriseOne
• JDEdwards EnterpriseOne Applications Task Force

E1 Cache Concepts – JDB Cache – Part 2

In last article (part 1), have shared about the concept of JDB cache and its features. In this article, we will see how we can implement the JDB cache and use it efficiently during our performance issues.

How it works

When a table is configured to be a part of JDB cache then , once a record is fetched from the table, it gets stored in cache also and then further Selects of the same record are fetched from cache rather than the database.

Basic Rules

1. An entry should be there in F98613 for the table which is a list of cache tables.
2. Table must be accessed using full primary key.
3. Table must be accesses through API ‘JDB_FetchKeyed’ in C Business Function or using ‘Fetch Single’ table I/O operation 1. in JDE event rules.
4. APIs like JDB_SetSelection or JDB_SetSequencing must not be called when using the JDB cache.
5. There is no synchronization / replication across processes.

Works in below manner:

Limitations

1. Tables must be static.
2. Same records must be fetched repeatedly.
3. Caching tables which are dynamic will cause applications to break.
4. Queries which return zero row, will not be cached.
5. Caching table having millions of records is not suggested.

Benefits

1. An automated table caching mechanism feature in EnterpriseOne.
2. Suitable for table which remain constant and static.
3. It can help in increasing performance of the process.
4. Redundant Select statements on same primary key can be eliminated by using JDB cache.

Reference:

• JDB cache in EnterpriseOne
• JDEdwards EnterpriseOne Applications Task Force

Concetti di Business Function e cache in JDE – Parte 1

L’uso della cache, o caching, è uno dei concetti fondamentali delle applicazioni web, o diciamo di qualsiasi applicazione, che si tratti del livello database, del livello applicativo o del livello web. In JD Edwards il caching si fa nel livello applicativo, tramite codice, e nel livello web, tramite il Server Manager (HTML Server).

Possiamo esaminare il caching basato sul codice, che di solito si realizza tramite Business Function (BSFN).

Usiamo o vediamo sempre alcuni parametri delle business function che JDE usa per comunicare o passare informazioni

LPBHVRCOM

• Puntatore a una struttura dati usata per la comunicazione con le business function
• Ha la capacità di identificare la versione corrente del software
• Identifica il privilegio di accesso dell’utente corrente
• Ha parametri che gestiscono la finestra corrente e i controlli della finestra
• Può identificare il controllo corrente che ha il focus
• Identifica il momento corrente dell’evento in elaborazione
• Ha il componente ID per l’identificatore globale di run time del job eseguito dal menu driver
• Ha informazioni sulle preferenze di sistema
• Ha informazioni sulle preferenze dell’utente
• Può mostrare l’ID del messaggio di errore o 0L
• Imposta il flag a TRUE quando si cambia il comportamento del database
• Contiene la chiave evento del messaggio di errore per le event rules
• Ha informazioni sull’handle di ambiente per ODBC
• Contiene puntatori per la sezione di RDA
• Ha la lista concatenata degli errori per i programmi batch
• Memorizza le informazioni di runtime del form per FDA
• Ha un flag che indica una chiamata di runtime o una chiamata di business function
• Memorizza un flag che indica una chiamata remota o un oggetto di chiamata di terze parti
• Ha le informazioni di indirizzo subscription/publish dell’applicazione
• Contiene l’ID del processo logico del chiamante dell’API jdeLaunchUBEEx
• Contiene anche un’area per uso futuro per nuovi elementi

LPVOID

• Puntatore a una struttura dati void, usata attualmente per l’elaborazione degli errori
• Sarà usato per la sicurezza in futuro.

Abbiamo una Master Business Function per la maggior parte dei processi che inseriscono dati nelle tabelle delle transazioni. Ogni master business function usa Begin Doc, Edit Line, Edit Doc ed End Doc per inserire i record nelle tabelle.

In termini semplici, da profano, ecco l’uso di ciascuna funzione, che viene chiamata in sequenza per creare i record.

Che cos’è la cache:

La cache è una memoria che contiene informazioni usate di recente e a cui si può accedere in modo estremamente rapido per manipolare i dati durante la creazione o l’aggiornamento di una transazione in un’applicazione.

Pro dell’uso della cache:

• La cache migliora le prestazioni dell’applicazione in cui è usata.
• La cache riduce il carico sui server.
• Con la cache possiamo memorizzare dati di più tabelle e accedervi quando serve.
• La cache è utile al posto delle tabelle temporanee, riducendo il carico sui server.

Contro dell’uso della cache:

• La cache ha un limite di capacità di memorizzazione.
• Implementare la cache richiede la conoscenza delle API JDECACHE.
• Risolvere i problemi della memoria cache è difficile.

Alcune API della cache che usiamo comunemente per creare la cache e usarla per memorizzare e aggiornare i record:

Concetti di Business Function e cache in JDE – Parte 2

Nel nostro ultimo articolo (parte 1) abbiamo dato una panoramica dei parametri standard delle Business Function e dell’uso delle master business function; abbiamo anche parlato delle API della cache e del loro uso.

In questo articolo mostreremo il processo di creazione di una cache con le API della cache e, nel prossimo articolo, vedremo come usare questa BSFN per inserire/aggiornare/recuperare i dati nella/dalla cache.

Passi per creare una cache

1. Creazione della struttura dati

Crea una struttura dati (data structure) per la Business Function.

Alcuni parametri sono obbligatori nella struttura dati per costruire una cache, mentre gli altri dipendono dal requisito.

• Cachename – Obbligatorio
• ActionCode – Obbligatorio
• Cursor – Obbligatorio

2. Collegare la struttura dati alla BSFN in C

3. Generare lo scheletro della Business Function

4. Creare la definizione della struttura dati nel file .h

5. Definire la struttura della cache nel .h

6. Definire la struttura della chiave della cache nel file .h

7. Creare le istanze della cache e della chiave della cache nel file .c

8. Dichiarare puntatori e variabili nel file .c

9. Inizializzare l’utente

10. Inizializzare la cache

La cache si inizializza con l’API ‘jdeCacheInit’. È il passo più importante per creare una cache.

‘jdeCacheInit’ inizializza una cache con nome, associa la cache inizializzata a un utente e restituisce un handle alla cache inizializzata. Questa API contiene quattro cose:

1. Crea una cache in memoria.
2. Crea un indice che sarà usato per accedere ai record nella cache.
3. Dà alla cache il nome passato in questa API.
4. Associa la cache a un handle di cache (HCACHE), che l’utente userà per riferirsi alla cache nelle chiamate alle API di JDE Cache.

11. Elaborazione della cache

Il più delle volte l’elaborazione della cache consiste nell’aggiungere, aggiornare, recuperare e cancellare nella cache.

Alcune sono elencate qui sotto:

Aggiunta/aggiornamento nella cache

‘jdeCacheAdd’ aggiunge un record alla cache identificata dall’handle di cache hCache, ottenuto dalla chiamata a ‘jdeCacheInit’.

‘jdeCacheUpdate’ aggiorna, con i dati passati, il record a cui punta in quel momento l’HJDECURSOR passato.

Recupero singolo dalla cache

‘jdeCacheFetchPosition’ recupera il record che corrisponde alla chiave data. Questa API si può usare per posizionare l’HJDECURSOR in un punto specifico dell’insieme di dati. Quando si chiama jdeCacheFetch, il recupero inizia dalla posizione successiva. È utile per fare recuperi sequenziali a partire da un punto specifico della cache.

Recupero multiplo dalla cache

Il recupero multiplo è possibile tramite l’API ‘JdeCacheFetch’. ‘JdeCacheFetch’ fa avanzare il cursore al record successivo dell’insieme di dati, rispetto alla posizione corrente del cursore, e recupera il record. Questa diventa la nuova posizione associata all’HJDECURSOR. Questa API non cerca un record nella cache, ma recupera qualunque record si trovi dopo quello a cui punta in quel momento l’HJDECURSOR passato. L’API è ideale per fare recuperi sequenziali

Cancellazione dalla cache

‘jdeCacheDelete’ è l’API che cancella il record puntato dal cursore. Si può cancellare un solo record alla volta.

Terminazione della cache

Quando tutta l’elaborazione è finita, la memoria allocata per la cache deve essere distrutta. ‘jdeCacheTerminateAll’ distrugge tutte le cache con lo stesso nome di quella con l’hCache dato. Le cache vengono rimosse fisicamente dalla memoria.

Il codice di esempio (qui sotto) per creare la cache è fornito come riferimento.

Concetti di Business Function e cache in JDE – Parte 3

Nel nostro ultimo articolo (parte 2) abbiamo mostrato passo per passo il processo di creazione della business function di cache con le API della cache e abbiamo spiegato lo scopo delle API della cache.

In questo articolo vedremo come usare la business function di cache in un oggetto JDE, come i valori vengono memorizzati nella cache e come possiamo manipolarli.

Passi per usare la business function

1. Creare l’applicazione per passare o recuperare i valori, come indicato sotto

Valori dell’Action Code:

1. Aggiungi/aggiorna
2. Recupera in base alla chiave
3. Cancella dalla cache

2. Nel pulsante Add Record, chiamare la BSFN in C per aggiungere i record alla cache

3. Nel pulsante Update Record, chiamare la BSFN in C per aggiornare i record nella cache

4. Nel pulsante Fetch Record, chiamare la BSFN in C per recuperare i record dalla cache

5. Nel pulsante Delete Record, chiamare la BSFN in C per aggiungere i record dalla cache

6. Eseguire l’applicazione nel web client, digitare i valori per inserire il record nella cache e premere il pulsante Add Record

Possiamo vedere che i valori sono stati aggiunti alla cache dopo la chiamata all’API jdeCacheAdd nella BSFN in C

7. Inserire valori diversi nei controlli del form e premere di nuovo il pulsante Add Record per aggiungere un altro record alla cache

Possiamo vedere che i valori sono stati aggiunti alla cache dopo la chiamata all’API jdeCacheAdd nella BSFN in C

8. Inserire un valore diverso nel controllo del form per aggiornare il primo record della cache

In questo caso avviene prima un recupero dalla cache per verificare se il record esiste nella cache; se il record c’è, viene aggiornato nella cache dopo la chiamata all’API jdeCacheUpdate nella BSFN in C.

9. Inserire il valore della chiave per recuperare il record dalla cache

Anche in questo scenario viene eseguito prima un recupero per verificare l’esistenza del record e, se esiste, i valori vengono assegnati ai parametri della BSFN dopo che l’API jdeCacheFetchPosition restituisce successo.

I valori del primo record sono stati mostrati nell’applicazione dopo aver premuto il pulsante Fetch Record

10. Inserire i valori della chiave per cancellare il record dalla cache

Anche in questo scenario viene eseguito prima un recupero per verificare l’esistenza del record e, se esiste, i valori vengono cancellati dopo che l’API jdeCacheDelete restituisce successo.

11. Se proviamo a cancellare di nuovo lo stesso record nella cache, viene restituito un errore, perché il record non è presente

Allo stesso modo possiamo chiamare la BSFN in C per recuperare i record sequenziali dalla cache e distruggere la cache.

Concetti di cache in E1 – JDB Cache – Parte 1

Negli articoli precedenti abbiamo condiviso i concetti della cache di JDE e la sua creazione. JDE ha due tipi di cache; quello che abbiamo spiegato nei post recenti è noto come User Cache o JDECACHE.

Questo articolo parla del secondo tipo di cache che JDE offre ai suoi utenti, chiamato JDB F98613/ DB Cache.

Come sappiamo, memorizzare i dati del database nella memoria del programma invece di recuperarli dal database è noto come caching. Questo aiuta a eliminare l’overhead del database.

La JDB Cache non è una memoria condivisa a cui accedono tutti i processi, ma memoria heap locale di ciascun processo. Ogni processo ha la sua propria copia della DB cache.

La JDB cache è una funzionalità di caching automatico delle tabelle di EnterpriseOne.

Quando il processo termina, anche la JDB cache se ne va con il processo, nel cestino (bit bucket).

La JDB Cache si può implementare tramite codice C in Business Function o Event Rules di JDE.

Non c’è replica né sincronizzazione tra le istanze della JDB cache.

Implementare la JDB cache può aiutare a migliorare le prestazioni del processo, purché lo si faccia dopo un’analisi completa.

La JDB cache è memoria heap locale del processo ed è limitata a un totale di 2GB nei sistemi operativi a 32 bit.

Nel prossimo articolo vedremo come possiamo implementare la JDB Cache in EnterpriseOne e quali sono le condizioni per usarla.

Riferimento:

• JDB cache in EnterpriseOne
• JDEdwards EnterpriseOne Applications Task Force

Concetti di cache in E1 – JDB Cache – Parte 2

Nell’ultimo articolo (parte 1) abbiamo condiviso il concetto della JDB cache e le sue caratteristiche. In questo articolo vedremo come implementare la JDB cache e usarla in modo efficiente di fronte ai nostri problemi di prestazioni.

Come funziona

Quando una tabella è configurata per far parte della JDB cache, una volta che un record viene recuperato dalla tabella, viene memorizzato anche nella cache, e le Select successive dello stesso record vengono recuperate dalla cache invece che dal database.

Regole di base

1. Deve esserci una voce in F98613, che è l’elenco delle tabelle in cache, per la tabella.
2. Si deve accedere alla tabella usando la chiave primaria completa.
3. Si deve accedere alla tabella tramite l’API ‘JDB_FetchKeyed’ in una Business Function C o usando l’operazione di I/O di tabella ‘Fetch Single’ nelle event rules di JDE.
4. API come JDB_SetSelection o JDB_SetSequencing non devono essere chiamate quando si usa la JDB cache.
5. Non c’è sincronizzazione / replica tra i processi.

Funziona nel modo seguente:

Limiti

1. Le tabelle devono essere statiche.
2. Gli stessi record devono essere recuperati ripetutamente.
3. Mettere in cache tabelle dinamiche farà andare in errore le applicazioni.
4. Le query che restituiscono zero righe non vengono messe in cache.
5. Non è consigliato mettere in cache tabelle con milioni di record.

Vantaggi

1. Una funzionalità di caching automatico delle tabelle di EnterpriseOne.
2. Adatta a tabelle che restano costanti e statiche.
3. Può aiutare ad aumentare le prestazioni del processo.
4. Le istruzioni Select ridondanti sulla stessa chiave primaria si possono eliminare usando la JDB cache.

Riferimento:

• JDB cache in EnterpriseOne
• JDEdwards EnterpriseOne Applications Task Force