Dependencies

Overview

A DataVeil dependency associates a parent field with a child field to enable automatic synchronization of masked values to maintain referential integrity.

There are two possible origins of a dependency in DataVeil:

1) A DBMS Foreign Key Definition

2) A DataVeil User Defined Dependency

You can view a DataVeil project's dependencies in the Dependencies window.

In this example, you can see that two of the dependencies are user-defined (indicated as "User" in the Origin column) and all of the remaining dependencies are foreign keys (indicated as "DB" in the Origin column.)

When a Dependency is Enabled it means that DataVeil shall synchronize the masked values among the dependants. This is the default and is recommended for most cases.

When a Dependency is Disabled it means that DataVeil shall not synchronize masked values among dependants. To disable a dependency you must first unlock the "Enabled" column by unchecking the "Lock Enabled column" checkbox. You can then uncheck the "Enabled" column for those dependencies that you wish to disable. Please refer to the section "Relationship Obfuscation" below for an explanation of the reasons why you might want to disable dependencies.

Diagram Window

The Diagram Window shows dependencies as arrows where the direction points toward the parent column of a dependency.

Arrows

There are four types of arrows:

1) Regular line: DBMS Foreign Key, dependency is Enabled in DataVeil

2) Regular dotted line: DBMS Foreign Key, dependency is Disabled in DataVeil

3) Thick line: User Defined Dependency, dependency is Enabled

4) Thick dotted line: User Defined Dependency, dependency is Disabled

DBMS Foreign Key Definition

DataVeil shall automatically create dependencies in a Project corresponding to all Foreign Keys defined on your database.

If you mask a column in a dependency then DataVeil shall automatically mask all other columns in the dependency to maintain referential integrity.

DataVeil performs the synchronization using an automatically-generated Inherit Mask.

DataVeil User Defined Dependency

If it is required to synchronize values between columns as described for Foreign Keys above, but there are no Foreign Key definitions for those columns then you can create a DataVeil User Defined Dependency.

DataVeil automatically creates a temporary index on the parent column of a user-defined dependencies if no existing usable index is available in order to maximize performance. Therefore, there is no need for the user to manually create such indexes (we know many other masking tools expect the user to do this).

DataVeil performs the synchronization using an automatically-generated Inherit Mask.

Duplicates in The Parent Column

User Defined Dependencies are actually more versatile than Foreign Keys because they allow duplicate values in the parent column whereas Foreign Keys do not.

For example, suppose there is a music Album table with a column containing the Artist name. There can be many rows in the Album table with the same Artist (an artist can have created many albums).

There is another table called Track which is a listing of each musical track created by every artist.

In this example, a user-defined dependency has been created such that Track.artist is dependent on Album.artist:

Therefore, if a Person Family Name mask is defined on Album.artist then rows in Track.artist shall be synchronized.

This is where DataVeil user-defined dependencies are more versatile than foreign keys, because a foreign key definition would not allow duplicates in the parent column (as is the case of "Jones" in the Album.artist column) whereas DataVeil will handle it.

In the parent column (Album.artist) it is suggested that any duplicates are masked consistently either by using a mask in deterministic mode, or if using non-deterministic mode then by enabling Synchronize duplicates on the parent column. 

As an alternative approach, instead of a defining a dependency, you could just use two identical masks in deterministic mode, one in the parent column and one in the child column, because that means that the same masked value would be generated for a given value wherever it occurs. However, a user-defined dependency is usually much faster in masking execution because the masked value generation is only performed once and then copied to the dependent column(s) rather than repeating the computation of masked values for every identical instance of a mask.