El programador especifica la restricción de integridad referencial entre las clases Cuenta y

Cliente declarando los atributos titulares y cuentas de las dos clases, como en el ejemplo
anterior. La norma define estos atributos como ejemplares de una clase plantilla
d_Rel_Set<T,A>.
Un ejemplar de esta clase contiene un conjunto de referencias a objetos de tipo T. Debe
haber un atributo en la clase T que guarda la referencia inversa; el nombre de este atributo
está guardado en A. Por restricciones del lenguaje C++, no se puede usar directamente la
cadena «titulares» o «cuentas» como un parámetro de la clase plantilla, así que se se usan
las variables titulares y cuentas, que guardan las cadenas «titulares» y «cuentas»
respectivamente.
la clase plantilla d_Rel_Ref<T,A> proporciona un método para la inserción de una
referencia; este método también inserta una referencia inversa (si no está ya presente) en
el atributo, cuyo nombre se guarda en A, de la clase T. Por ejemplo, para añadir una nueva
cuenta a un cliente se inserta una referencia a la cuenta en el atributo cuentas de Cliente;
usando el método para insertar de la clase d_Rel_Set<Cuenta,_titulares>.

Este método conserva la restricción de integridad referencial insertando automáticamente

una referencia a titular en la variable titulares de la cuenta. Análogamente,cuando el
sistema lleva a cabo un borrado, el método correspondiente borra la referencia inversa. De
este modo, el método garantiza que la restricción de integridad referencial no se viola.

La asignación a la variable de tipo d_Rel_Ref<T,A> se redefine para conservar

automáticamente la referencia inversa. Supóngase que el objeto Sucursal tiene un atributo
clientes que guardan la referencia inversa al objeto Cliente. A continuación se puede
declarar el atributo sucursal_raíz de Cliente que será del tipo
d_Rel_Ref<Sucursal,_clientes>, donde _clientes es una variable inicializada a la cadena
«clientes».

El atributo clientes de Sucursal sería del tipo d_Rel_Set<Cliente,_sucursal_raíz>, donde

sucursal_raíz es una variable inicializada a la cadena «sucursal_local».

Así, las restricciones de integridad referencial se conservan automáticamente.

Ejemplo OML
Primero, el programa abre una base de datos y a continuación se inicia una
transacción; las transacciones forman una unidad de trabajo que es atómica; es decir,
si la transacción no se completa con éxito, el sistema deshace el efecto de la
transacción.

Como paso siguiente, el programa crea un objeto cuenta y un objeto titular usando el
operador new. La clase d_Object implementa varios métodos, incluyendo la versión
persistente del operador de asignación de memoria new que se utiliza en el código de
ejemplo.

Esta versión del operador new asigna el objeto a la base de datos especificada en vez
de en la memoria. El operador también toma un parámetro que especifica el nombre de
la clase del objeto que está siendo asignado; el nombre de la clase se usa para seguir
la trayectoria de qué objetos pertenecen a una determinada clase en una base de
datos.

El programa entonces inicializa los objetos cuenta y titular. Se utiliza el método

insert_element de la clase plantilla d_Set<> para insertar las referencias a los clientes y
a las cuentas en los conjuntos adecuados después de crear los objetos cliente y
cuenta. Si se ha declarado cuenta y titular de tipo d_Rel_Set, tan pronto como una
cuenta se añada al conjunto de cuentas de un cliente, las referencias inversas desde el
objeto cuenta (a través del atributo titular) se crearán automáticamente. De este modo,
la inserción del cliente en el conjunto de titulares de la cuenta se vuelve innecesario
(aunque no incorrecto). De manera parecida, si se elimina una cuenta de un cliente, el
conjunto de titulares de la cuenta se actualizaría automáticamente, borrando al cliente.
Al final, el programa compromete la transacción y cierra la base de datos.
Una transacción es una secuencia de pasos, delimitados por una
llamada a begin (iniciar la transacción) y otra llamada a commit
(comprometer) o abort (abortar). Los pasos de la transacción forman una
unidad atómica. Es decir, el sistema de bases de datos garantiza que

1) si se ejecuta la operación commit() para una transacción, todas las

actualizaciones hechas persistirán en la base de datos, y
2) si se ejecuta una operación abort(), o si el programa que está ejecutando
la transacción termina sin ejecutar commit(), todas las actualizaciones
representadas como parte de la transacción serán deshechas. Si hay
algún fallo antes de que una transacción se comprometa, el sistema
deshace todas las modificaciones de la transacción hasta el último estado
estable.