Geralmente é necessário manejar conflitos possíveis que podem surgir quando vários usuários ou processos carregam e tentar modificara as mesmas entidades ao mesmo tempo. Trancar os registros é uma metodologia usada em bancos de dados relacionais para evitar atualizações inconsistentes dos dados. O conceito é trancar um registro na leitura de modo que outros processo não possam ser atualizadas ou, alternativamente, verificar quando salvar um registro para verificar que alguns outros processos não foram modificados já que foi lida. Trancar o registro na leitura é chamado de trancamento de registro pessimista e assegura que um registro modificado pode ser escrito com o problema de trancar os registros para todos os outros usuários. Verificar quando salvar o registro de que outro processo não o modificou é chamado de um trancamento de registro otimista e troca a garantia de privilégios de escrrita ao registro pela flexibilidade de decidir os privilégios de escrita apenas se o registro precisa ser atualizado. Em trancamento de registro pessimista, o registro é trancado mesmo se não houver necessidade de atualizá-lo. Em trancamento de registro otimista, a validade da modificação do registro é decidida no momento de atualização.

ORDA oferece dois modos de trancar a entidade:

• um modo automático "otimista", adequado para a maioria das aplicações,
• um modo "pessimisto" que permite que tranque as entidades antes do acesso.

Este mecanismo automático é baseado no conceito de "tranca otimista" que é particularmente adequado para os problemas de aplicações web. Esse conceito é caracterizado pelas princípios operativos abaixo:

• Todas as entidades podem sempre ser carregadas em leitura-escrita; não há um trancamento "a priori" das entidades.
• Cada entidade tem um carimbo de trancamento interno que é incrementado a cada vez que é salvado.
• Quando um cliente ou processo tentar salvar uma entidade usando o método entity.save( ), 4D compara o valor do carimbo de uma entidade a ser salvado com aquele da entidade encontrada nos dados (em caso de uma modificação):
  
  • Quando os valores coincidirem, a entidade é salva e o valor do carimbo interno é incrementado.
  • Quando os valores não coincidirem, significa que outro cliente já modificou essa entidade durante o processo. Não se salva e se retorna um erro.

O diagrama abaixo ilustra o trancamento otimista:

1. Dois processos carregam a mesma entidade.

2. O primeiro processo modifica a entidade e valida a mudança. O método entity.save( ) é chamado. O motor 4D automaticamente compara o valor do carimbo interno da entidade modificada com aquele da entidade armazenada nos dados. Já que elas coincidem, a entidade é salva e seu valor de carimbo é incrementado

3. O segundo processo também modifica a entidade carregada e valida suas mudanças. O método entity.save( ) é chamado. Já que o valor do carimbo da entidade modifica não coincide com aquele da entidade armazenada nos dados, não se salva e um erro é retornado.

Isso também pode ser ilustrado pelo código abaixo:

Neste exemplo, nós atribuimos a $person1 uma referência a entidade de pessoa com uma chave de 1. Então, atribuimos outra referência à mesma entidade à variável $person2. Usando $person1, mudamos o primeiro nome da pessoa e salvamos a entidade.Quando tentamos fazer a mesma coisa com  $person2, 4D verifica para ter certeza que a entidade em disco é a mesma de quando a referência em  $person1 foi atribuida. Já que não é a mesma, retorna falso na propriedade sucesso e não salva a segunda modificação.

Quando essa situação ocorrer, é possível por exemplo recarregar a entidade do disco usando o método entity.reload( ) de modo que pode tentar realizar a modificação novamente. O método entity.save( ) também propõe uma opção de  "autofusão" para salvar a entidade no caso de atributos de processos modificados não serem os mesmos

Nota: os selos de registro não são utilizados em transações porque neste contexto só existe uma única cópia de um registro. Seja qual seja o número de entidades que fazem referência a um registro, se modifica a mesma cópia, pelo qual as operações entity.save( ) nunca gerarão erros de selo.

É possível trancar e destrancar entidades quando acessar os dados. Quando uma entidade está sendo trancada por um processo, é carregada em ler/escrever neste processo, mas é trancada para todos os outros processos. A entidade pode ser carregada apenas em modo apenas-leitura nesses processos: seus valores não podem ser editados ou salvados.

Esta propriedade é baseada em dois métodos da classe de Entidade:

• entity.lock( )
• entity.unlock( )

Para saber mais veja a descrição desses métodos.

Usar os comandos clássico e ORDA para trancar registros é baeado nos princípios abaixo:

• Um bloqueio estabelecido com um comando 4D clássico em um registro previne que ORDA tranque a entidade que corresponde ao registro.
• Um bloqueio estabelecido com ORDA em uma entidade previne que os comandos clássicos 4D tranquem o registro que corresponde à entidade.

Estes princípios são mostrados no diagrama abaixo:

Bloqueio de transações também se aplica a comandos clássicos e ORDA. Em uma aplicação multi-processo ou multi-usuário, uma tranca estabelecida dentro de uma transação em um registro por um comando clássico vai resultar em impedir que outros processos tranquem as entidades relacionadas ao registro (ou de outro lado), até que a transação seja validada ou cancelada.

• Exemplo com um bloqueio estabelecido por um comando clássico:
  

• Exemplo com um bloqueio estabelecido por um método ORDA: