# Lookup Tables

### Overview

You can use Lookup transformers to convert identity attributes from a source system into appropriate values for target systems based on CSV reference tables. This is particularly useful when mapping values between systems that use different naming conventions, codes, or formats for the same conceptual data.

For example, you might need to transform a "Location" attribute from Workday (which might be stored as location codes like "MN001") into corresponding values for country, country code, or city names in a target system.

Use Table Lookup Transformers when:

* You need to map source attribute values to different values in target systems
* You have standardized reference data that must be consistent across applications
* You need to extract different pieces of information from a single attribute value
* You have complex mapping requirements that built-in transformers cannot support

#### Examples

1. **Geographic Information**:
   * Transform location codes to country, region, city, or timezone information
   * Map office codes to physical addresses or facility types
2. **Organizational Mapping**:
   * Convert department codes to department names or business units
   * Map cost centers to budget codes or accounting categories
3. **System-Specific Configurations**:
   * Transform job titles to role designations in target systems
   * Convert skill codes to certification requirements or training needs

### How It Works

The Table Lookup Transformer references CSV-based mappings between source and destination values. When synchronizing user attributes, Veza:

1. Takes the source attribute value
2. Looks up this value in the specified lookup table
3. Returns the corresponding value from the designated return column
4. Applies this value to the target attribute

#### Lookup Table Structure

Lookup tables are CSV files with columns that map values from a source of identity to destination values. Each row represents a mapping entry. The first row must contain the column headers.

For example, a location mapping table might look like:

```csv
location_code,state_code,state,city
MN001,MN,Minnesota,Minneapolis
CA001,CA,California,Los Angeles
TX001,TX,Texas,Houston
TX002,TX,Texas,Austin
```

### Creating and Managing Lookup Tables

#### Creating a Lookup Table

To create a new lookup table:

1. Navigate to the **Lookup Tables** tab within your policy configuration
2. Click **Edit** mode to enable policy changes
3. Click **Add New** to create a new lookup table
4. Provide a **Name** and optional **Description** for the lookup table
5. Drag a CSV file or click **Browse** to upload your reference data
6. Review the automatically detected column names
7. Click **Save** to store the lookup table

#### Managing Lookup Tables

From the Lookup Tables tab, you can:

* **Edit** table descriptions or upload a new CSV
* **Delete** tables that are no longer needed

#### Updating a lookup table

To update an existing lookup table:

1. Create a new policy draft version.
2. Delete the CSV from the existing lookup table (do not delete the table itself).
3. Upload the updated CSV.
4. Publish the draft.

### Using Table Lookup Transformers

#### Basic Syntax

To use a Table Lookup Transformer in a common or action-synced attribute:

1. In **Destination Attribute**, choose the attribute on the target entity that will be updated
2. In **Formatter**, choose the source attribute to transform
3. In **Then Apply**, specify the lookup table name, the column to match against, and the column containing values to return.

![Configuring an action-level attribute transformer using lookup tables.](https://1967633068-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MZDkWMxox3pekd0NsZJ%2Fuploads%2Fgit-blob-dffd8ea131d182ba722cbc9581f46921b33de307%2Flookup-tables.png?alt=media)

The full syntax for using lookup table transformers is:

```txt
{<value> | LOOKUP <table_name>, <column_name>, <return_column_name>}
```

Where:

* `<value>` is the source attribute to transform (e.g., `{location}`)
* `<table_name>` is the name of the lookup table to use
* `<column_name>` is the column in the table to match against
* `<return_column_name>` is the column containing the value to return

#### Examples

Assuming a user has `"location": "IL001"` and a lookup table named `locationTable` structured as shown earlier:

| Formatter                                                       | Result       |
| --------------------------------------------------------------- | ------------ |
| `{location} \| LOOKUP locationTable, location_code, city`       | `"Chicago"`  |
| `{location} \| LOOKUP locationTable, location_code, state`      | `"Illinois"` |
| `{location} \| LOOKUP locationTable, location_code, state_code` | `"IL"`       |

### Advanced Features

#### Pipeline Transformations

You can combine lookup transformations with other transformation functions in a pipeline:

```txt
{location | LOOKUP locationTable, location_code, state_code | LOWER}
```

This would look up the `state_code` corresponding to the `location` value and convert it to lowercase.

#### Handling Missing Values

When a lookup value is not found in the table, the transformation will fail for that specific attribute.

For full coverage, ensure your lookup table includes entries for all possible source values that may be encountered during provisioning.

To ensure robust provisioning workflows, it's important to include all expected values in your lookup table, validate source data before implementing lookup transformations, and test transformations with representative data sets.

### Technical Details

#### Implementation Notes

* Lookup tables are immutable and automatically deleted when no longer referenced by any policy version
* Multiple policy versions can reference the same lookup table (e.g., an active version and a draft version)
* Lookup tables are defined at the policy level and can be referenced by any transformer within the policy
* Lookup tables can have multiple columns to support different transformations from the same reference data

#### Best Practices

1. **Standardize Naming**: To use a lookup-based transformer, you will reference the table by file name. Apply consistent conventions for both the table and columns.
2. **Document Mappings**: Add descriptions for each lookup table to explain its purpose
3. **Validate Data**: Ensure lookup tables are complete and accurate before using them in transformers. Consider how lookup tables will be maintained over time, especially for values expected to change.

### Troubleshooting

#### Common Issues

| Issue                             | Resolution                                                                   |
| --------------------------------- | ---------------------------------------------------------------------------- |
| Value not found in lookup table   | Add the missing mapping to the lookup table with the correct source value    |
| Incorrect column name referenced  | Check the column names in your lookup table (they are case-sensitive)        |
| Unexpected transformation results | Verify the lookup table content and ensure the correct columns are specified |

### Related Topics

* [Attribute Transformers](https://docs.veza.com/4yItIzMvkpAvMVFAamTf/features/lifecycle-management/transformers)
* [Common Transformers](https://docs.veza.com/4yItIzMvkpAvMVFAamTf/features/lifecycle-management/transformers/..#common-transformers)
* [Then Apply](https://docs.veza.com/4yItIzMvkpAvMVFAamTf/features/lifecycle-management/transformers)
* [Lifecycle Management Workflows](https://docs.veza.com/4yItIzMvkpAvMVFAamTf/features/policies-workflows/policies#add-workflows-to-policies)